From 7bae8676eed7372591ec67149a9df01e9e7a38ad Mon Sep 17 00:00:00 2001 From: Felix Buehler Date: Mon, 3 May 2021 18:21:59 +0200 Subject: [PATCH 001/163] mediaelch: 2.8.8 -> 2.8.10 --- pkgs/applications/misc/mediaelch/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/misc/mediaelch/default.nix b/pkgs/applications/misc/mediaelch/default.nix index de145efd444..b0ceff85f81 100644 --- a/pkgs/applications/misc/mediaelch/default.nix +++ b/pkgs/applications/misc/mediaelch/default.nix @@ -15,13 +15,13 @@ mkDerivation rec { pname = "mediaelch"; - version = "2.8.8"; + version = "2.8.10"; src = fetchFromGitHub { owner = "Komet"; repo = "MediaElch"; rev = "v${version}"; - sha256 = "0yif0ibmlj0bhl7fnhg9yclxg2iyjygmjhffinp5kgqy0vaabkzw"; + sha256 = "1ay36q1151lvlkzmbibwv84ic90ih2hzgwx34dndxxs034vbxjv8"; fetchSubmodules = true; }; From 9c6b0372706be6fe29704cd948fee7ba60a9685a Mon Sep 17 00:00:00 2001 From: Minijackson Date: Tue, 4 May 2021 21:34:10 +0200 Subject: [PATCH 002/163] xdg-desktop-portal-wlr: add slurp to the environment fixes #121678 --- pkgs/development/libraries/xdg-desktop-portal-wlr/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/libraries/xdg-desktop-portal-wlr/default.nix b/pkgs/development/libraries/xdg-desktop-portal-wlr/default.nix index 59816a4ef6f..3739284d70a 100644 --- a/pkgs/development/libraries/xdg-desktop-portal-wlr/default.nix +++ b/pkgs/development/libraries/xdg-desktop-portal-wlr/default.nix @@ -1,6 +1,6 @@ { lib, stdenv, fetchFromGitHub, makeWrapper , meson, ninja, pkg-config, wayland-protocols -, pipewire, wayland, systemd, libdrm, iniparser, scdoc, grim }: +, pipewire, wayland, systemd, libdrm, iniparser, scdoc, grim, slurp }: stdenv.mkDerivation rec { pname = "xdg-desktop-portal-wlr"; @@ -21,7 +21,7 @@ stdenv.mkDerivation rec { ]; postInstall = '' - wrapProgram $out/libexec/xdg-desktop-portal-wlr --prefix PATH ":" ${lib.makeBinPath [ grim ]} + wrapProgram $out/libexec/xdg-desktop-portal-wlr --prefix PATH ":" ${lib.makeBinPath [ grim slurp ]} ''; meta = with lib; { From ebe8b87ae7373c0aa53b12d7101e909e0b9503c0 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Sat, 1 May 2021 16:59:07 -0400 Subject: [PATCH 003/163] grub2: Add support for armv7l-linux --- pkgs/tools/misc/grub/2.0x.nix | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkgs/tools/misc/grub/2.0x.nix b/pkgs/tools/misc/grub/2.0x.nix index f36e64f57b2..fcf29beb188 100644 --- a/pkgs/tools/misc/grub/2.0x.nix +++ b/pkgs/tools/misc/grub/2.0x.nix @@ -23,6 +23,7 @@ let efiSystemsBuild = { i686-linux.target = "i386"; x86_64-linux.target = "x86_64"; + armv7l-linux.target = "arm"; aarch64-linux.target = "aarch64"; }; @@ -31,6 +32,7 @@ let efiSystemsInstall = { i686-linux.target = "i386"; x86_64-linux.target = "x86_64"; + armv7l-linux.target = "arm"; aarch64-linux.target = "arm64"; }; From d053c05d19aef8f1295dcdc1e81de9103892d8db Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Thu, 22 Apr 2021 15:55:44 -0400 Subject: [PATCH 004/163] iso-image: Fixes for cross-compilation Note that here, since it's not a in a callPackage call, splicing won't work on nativeBuildInputs. --- nixos/modules/installer/cd-dvd/iso-image.nix | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/nixos/modules/installer/cd-dvd/iso-image.nix b/nixos/modules/installer/cd-dvd/iso-image.nix index 7a4738599b0..e25c96d5778 100644 --- a/nixos/modules/installer/cd-dvd/iso-image.nix +++ b/nixos/modules/installer/cd-dvd/iso-image.nix @@ -263,7 +263,7 @@ let # Make our own efi program, we can't rely on "grub-install" since it seems to # probe for devices, even with --skip-fs-probe. - ${grubPkgs.grub2_efi}/bin/grub-mkimage -o $out/EFI/boot/boot${targetArch}.efi -p /EFI/boot -O ${grubPkgs.grub2_efi.grubTarget} \ + ${pkgs.buildPackages.grub2_efi}/bin/grub-mkimage --directory=${grubPkgs.grub2_efi}/lib/grub/${grubPkgs.grub2_efi.grubTarget} -o $out/EFI/boot/boot${targetArch}.efi -p /EFI/boot -O ${grubPkgs.grub2_efi.grubTarget} \ $MODULES cp ${grubPkgs.grub2_efi}/share/grub/unicode.pf2 $out/EFI/boot/ @@ -388,7 +388,7 @@ let ${refind} ''; - efiImg = pkgs.runCommand "efi-image_eltorito" { buildInputs = [ pkgs.mtools pkgs.libfaketime ]; } + efiImg = pkgs.runCommand "efi-image_eltorito" { nativeBuildInputs = [ pkgs.buildPackages.mtools pkgs.buildPackages.libfaketime pkgs.buildPackages.dosfstools ]; } # Be careful about determinism: du --apparent-size, # dates (cp -p, touch, mcopy -m, faketime for label), IDs (mkfs.vfat -i) '' @@ -408,10 +408,10 @@ let echo "Usage size: $usage_size" echo "Image size: $image_size" truncate --size=$image_size "$out" - ${pkgs.libfaketime}/bin/faketime "2000-01-01 00:00:00" ${pkgs.dosfstools}/sbin/mkfs.vfat -i 12345678 -n EFIBOOT "$out" + faketime "2000-01-01 00:00:00" mkfs.vfat -i 12345678 -n EFIBOOT "$out" mcopy -psvm -i "$out" ./EFI ./boot :: # Verify the FAT partition. - ${pkgs.dosfstools}/sbin/fsck.vfat -vn "$out" + fsck.vfat -vn "$out" ''; # */ # Name used by UEFI for architectures. From f1100e15066c7f1eeff66e0e9dcdaf29131f876b Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Sat, 1 May 2021 16:59:24 -0400 Subject: [PATCH 005/163] iso-image: Add support for armv7l-linux --- nixos/modules/installer/cd-dvd/iso-image.nix | 2 ++ 1 file changed, 2 insertions(+) diff --git a/nixos/modules/installer/cd-dvd/iso-image.nix b/nixos/modules/installer/cd-dvd/iso-image.nix index e25c96d5778..d421e3ea428 100644 --- a/nixos/modules/installer/cd-dvd/iso-image.nix +++ b/nixos/modules/installer/cd-dvd/iso-image.nix @@ -420,6 +420,8 @@ let "ia32" else if pkgs.stdenv.isx86_64 then "x64" + else if pkgs.stdenv.isAarch32 then + "arm" else if pkgs.stdenv.isAarch64 then "aa64" else From 556fc32d699e2ee3b1e7fbf3bb35eb80b966e7fc Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Mon, 3 May 2021 15:52:22 -0400 Subject: [PATCH 006/163] iso-image: Build using strictDeps --- nixos/modules/installer/cd-dvd/iso-image.nix | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/nixos/modules/installer/cd-dvd/iso-image.nix b/nixos/modules/installer/cd-dvd/iso-image.nix index d421e3ea428..324b38070e4 100644 --- a/nixos/modules/installer/cd-dvd/iso-image.nix +++ b/nixos/modules/installer/cd-dvd/iso-image.nix @@ -233,7 +233,10 @@ let # Notes about grub: # * Yes, the grubMenuCfg has to be repeated in all submenus. Otherwise you # will get white-on-black console-like text on sub-menus. *sigh* - efiDir = pkgs.runCommand "efi-directory" {} '' + efiDir = pkgs.runCommand "efi-directory" { + nativeBuildInputs = [ pkgs.buildPackages.grub2_efi ]; + strictDeps = true; + } '' mkdir -p $out/EFI/boot/ # ALWAYS required modules. @@ -263,7 +266,7 @@ let # Make our own efi program, we can't rely on "grub-install" since it seems to # probe for devices, even with --skip-fs-probe. - ${pkgs.buildPackages.grub2_efi}/bin/grub-mkimage --directory=${grubPkgs.grub2_efi}/lib/grub/${grubPkgs.grub2_efi.grubTarget} -o $out/EFI/boot/boot${targetArch}.efi -p /EFI/boot -O ${grubPkgs.grub2_efi.grubTarget} \ + grub-mkimage --directory=${grubPkgs.grub2_efi}/lib/grub/${grubPkgs.grub2_efi.grubTarget} -o $out/EFI/boot/boot${targetArch}.efi -p /EFI/boot -O ${grubPkgs.grub2_efi.grubTarget} \ $MODULES cp ${grubPkgs.grub2_efi}/share/grub/unicode.pf2 $out/EFI/boot/ @@ -388,7 +391,10 @@ let ${refind} ''; - efiImg = pkgs.runCommand "efi-image_eltorito" { nativeBuildInputs = [ pkgs.buildPackages.mtools pkgs.buildPackages.libfaketime pkgs.buildPackages.dosfstools ]; } + efiImg = pkgs.runCommand "efi-image_eltorito" { + nativeBuildInputs = [ pkgs.buildPackages.mtools pkgs.buildPackages.libfaketime pkgs.buildPackages.dosfstools ]; + strictDeps = true; + } # Be careful about determinism: du --apparent-size, # dates (cp -p, touch, mcopy -m, faketime for label), IDs (mkfs.vfat -i) '' From 6ba5ac89d255c4e67b0941d0746dbd04e2e5da09 Mon Sep 17 00:00:00 2001 From: Ivan Babrou Date: Tue, 4 May 2021 18:24:12 -0700 Subject: [PATCH 007/163] gfortran11, gnat11: init at 11.1.0 I forgot to add it in #121115. --- pkgs/top-level/all-packages.nix | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 99b3c2098c2..14f358b200b 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -10605,6 +10605,14 @@ in profiledCompiler = false; }); + gfortran11 = wrapCC (gcc11.cc.override { + name = "gfortran"; + langFortran = true; + langCC = false; + langC = false; + profiledCompiler = false; + }); + libgccjit = gcc.cc.override { name = "libgccjit"; langFortran = false; @@ -10656,6 +10664,15 @@ in gnatboot = gnat6; }); + gnat11 = wrapCC (gcc11.cc.override { + name = "gnat"; + langC = true; + langCC = false; + langAda = true; + profiledCompiler = false; + gnatboot = gnat6; + }); + gnatboot = wrapCC (callPackage ../development/compilers/gnatboot { }); gnu-smalltalk = callPackage ../development/compilers/gnu-smalltalk { }; From 8cf144d1392e8187ee5c29d1688c38ea8ba7745c Mon Sep 17 00:00:00 2001 From: Ivan Babrou Date: Tue, 4 May 2021 20:14:01 -0700 Subject: [PATCH 008/163] gnat11: extract gnat-cflags-11.patch from gnat-cflags.patch --- pkgs/development/compilers/gcc/11/default.nix | 2 +- .../compilers/gcc/gnat-cflags-11.patch | 35 +++++++++++++++++++ 2 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 pkgs/development/compilers/gcc/gnat-cflags-11.patch diff --git a/pkgs/development/compilers/gcc/11/default.nix b/pkgs/development/compilers/gcc/11/default.nix index 3a9f50be3e7..73f3d7b2a97 100644 --- a/pkgs/development/compilers/gcc/11/default.nix +++ b/pkgs/development/compilers/gcc/11/default.nix @@ -68,7 +68,7 @@ let majorVersion = "11"; url = "https://git.busybox.net/buildroot/plain/package/gcc/${version}/0900-remove-selftests.patch?id=11271540bfe6adafbc133caf6b5b902a816f5f02"; sha256 = ""; # TODO: uncomment and check hash when available. }) */ - ++ optional langAda ../gnat-cflags.patch + ++ optional langAda ../gnat-cflags-11.patch ++ optional langFortran ../gfortran-driving.patch ++ optional (targetPlatform.libc == "musl" && targetPlatform.isPower) ../ppc-musl.patch diff --git a/pkgs/development/compilers/gcc/gnat-cflags-11.patch b/pkgs/development/compilers/gcc/gnat-cflags-11.patch new file mode 100644 index 00000000000..03ef2866452 --- /dev/null +++ b/pkgs/development/compilers/gcc/gnat-cflags-11.patch @@ -0,0 +1,35 @@ +diff --git a/gcc/ada/gcc-interface/Makefile.in b/gcc/ada/gcc-interface/Makefile.in +index 4e74252bd74..0d848b5b4e3 100644 +--- a/gcc/ada/gcc-interface/Makefile.in ++++ b/gcc/ada/gcc-interface/Makefile.in +@@ -111,7 +111,7 @@ NO_OMIT_ADAFLAGS = -fno-omit-frame-pointer + NO_SIBLING_ADAFLAGS = -fno-optimize-sibling-calls + NO_REORDER_ADAFLAGS = -fno-toplevel-reorder + GNATLIBFLAGS = -W -Wall -gnatg -nostdinc +-GNATLIBCFLAGS = -g -O2 ++GNATLIBCFLAGS = -g -O2 $(CFLAGS_FOR_TARGET) + # Pretend that _Unwind_GetIPInfo is available for the target by default. This + # should be autodetected during the configuration of libada and passed down to + # here, but we need something for --disable-libada and hope for the best. +@@ -198,7 +198,7 @@ RTSDIR = rts$(subst /,_,$(MULTISUBDIR)) + # Link flags used to build gnat tools. By default we prefer to statically + # link with libgcc to avoid a dependency on shared libgcc (which is tricky + # to deal with as it may conflict with the libgcc provided by the system). +-GCC_LINK_FLAGS=-static-libstdc++ -static-libgcc ++GCC_LINK_FLAGS=-static-libstdc++ -static-libgcc $(CFLAGS_FOR_TARGET) + + # End of variables for you to override. + +diff --git a/libada/Makefile.in b/libada/Makefile.in +index 522b9207326..ca866c74471 100644 +--- a/libada/Makefile.in ++++ b/libada/Makefile.in +@@ -59,7 +59,7 @@ LDFLAGS= + CFLAGS=-g + PICFLAG = @PICFLAG@ + GNATLIBFLAGS= -W -Wall -gnatpg -nostdinc +-GNATLIBCFLAGS= -g -O2 ++GNATLIBCFLAGS= -g -O2 $(CFLAGS) + GNATLIBCFLAGS_FOR_C = -W -Wall $(GNATLIBCFLAGS) $(CFLAGS_FOR_TARGET) \ + -fexceptions -DIN_RTS @have_getipinfo@ @have_capability@ + From 007cab96448921b45547a6bc85117052cbc2429a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20Sch=C3=BCtz?= Date: Wed, 5 May 2021 12:30:39 +0200 Subject: [PATCH 009/163] matrix-dendrite: rename to dendrite No other distro calls it matrix-dendrite: https://repology.org/project/matrix-dendrite --- nixos/modules/services/misc/matrix-dendrite.nix | 10 +++++----- pkgs/servers/{matrix-dendrite => dendrite}/default.nix | 0 pkgs/top-level/all-packages.nix | 4 ++-- 3 files changed, 7 insertions(+), 7 deletions(-) rename pkgs/servers/{matrix-dendrite => dendrite}/default.nix (100%) diff --git a/nixos/modules/services/misc/matrix-dendrite.nix b/nixos/modules/services/misc/matrix-dendrite.nix index b719df29c5a..24051e0b3b4 100644 --- a/nixos/modules/services/misc/matrix-dendrite.nix +++ b/nixos/modules/services/misc/matrix-dendrite.nix @@ -30,7 +30,7 @@ in The path to the TLS certificate. - nix-shell -p matrix-dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key" + nix-shell -p dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key" ''; }; @@ -42,7 +42,7 @@ in The path to the TLS key. - nix-shell -p matrix-dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key" + nix-shell -p dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key" ''; }; @@ -95,7 +95,7 @@ in requests and events. - nix-shell -p matrix-dendrite --command "generate-keys --private-key matrix_key.pem" + nix-shell -p dendrite --command "generate-keys --private-key matrix_key.pem" ''; }; @@ -136,7 +136,7 @@ in message = '' If Dendrite is configured to use https, tlsCert and tlsKey must be provided. - nix-shell -p matrix-dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key" + nix-shell -p dendrite --command "generate-keys --tls-cert server.crt --tls-key server.key" ''; }]; @@ -163,7 +163,7 @@ in ${pkgs.coreutils}/bin/cp ${configurationYaml} /run/matrix-dendrite/dendrite.yaml ''; ExecStart = lib.strings.concatStringsSep " " ([ - "${pkgs.matrix-dendrite}/bin/dendrite-monolith-server" + "${pkgs.dendrite}/bin/dendrite-monolith-server" "--config /run/matrix-dendrite/dendrite.yaml" ] ++ lib.optionals (cfg.httpPort != null) [ "--http-bind-address :${builtins.toString cfg.httpPort}" diff --git a/pkgs/servers/matrix-dendrite/default.nix b/pkgs/servers/dendrite/default.nix similarity index 100% rename from pkgs/servers/matrix-dendrite/default.nix rename to pkgs/servers/dendrite/default.nix diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 18430aaa121..0767b7f9cba 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -6113,8 +6113,6 @@ in inherit (darwin.apple_sdk.frameworks) Security; }; - matrix-dendrite = callPackage ../servers/matrix-dendrite { }; - /* Python 3.8 is currently broken with matrix-synapse since `python38Packages.bleach` fails (https://github.com/NixOS/nixpkgs/issues/76093) */ matrix-synapse = callPackage ../servers/matrix-synapse { /*python3 = python38;*/ }; @@ -18582,6 +18580,8 @@ in couchpotato = callPackage ../servers/couchpotato {}; + dendrite = callPackage ../servers/dendrite { }; + dex-oidc = callPackage ../servers/dex { }; dex2jar = callPackage ../development/tools/java/dex2jar { }; From f82c6fdfd5c61b87f5bf19174727fb903e7c6e38 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20Sch=C3=BCtz?= Date: Wed, 5 May 2021 12:34:24 +0200 Subject: [PATCH 010/163] nixos/matrix-dendrite: rename to dendrite --- nixos/modules/module-list.nix | 2 +- .../{matrix-dendrite.nix => dendrite.nix} | 26 +++++++++---------- 2 files changed, 14 insertions(+), 14 deletions(-) rename nixos/modules/services/misc/{matrix-dendrite.nix => dendrite.nix} (88%) diff --git a/nixos/modules/module-list.nix b/nixos/modules/module-list.nix index 0c0935a7992..53f0f6e351e 100644 --- a/nixos/modules/module-list.nix +++ b/nixos/modules/module-list.nix @@ -472,6 +472,7 @@ ./services/misc/cgminer.nix ./services/misc/confd.nix ./services/misc/couchpotato.nix + ./services/misc/dendrite.nix ./services/misc/devmon.nix ./services/misc/dictd.nix ./services/misc/duckling.nix @@ -514,7 +515,6 @@ ./services/misc/mame.nix ./services/misc/matrix-appservice-discord.nix ./services/misc/matrix-appservice-irc.nix - ./services/misc/matrix-dendrite.nix ./services/misc/matrix-synapse.nix ./services/misc/mautrix-telegram.nix ./services/misc/mbpfan.nix diff --git a/nixos/modules/services/misc/matrix-dendrite.nix b/nixos/modules/services/misc/dendrite.nix similarity index 88% rename from nixos/modules/services/misc/matrix-dendrite.nix rename to nixos/modules/services/misc/dendrite.nix index 24051e0b3b4..c967fc3a362 100644 --- a/nixos/modules/services/misc/matrix-dendrite.nix +++ b/nixos/modules/services/misc/dendrite.nix @@ -1,12 +1,12 @@ { config, lib, pkgs, ... }: let - cfg = config.services.matrix-dendrite; + cfg = config.services.dendrite; settingsFormat = pkgs.formats.yaml { }; configurationYaml = settingsFormat.generate "dendrite.yaml" cfg.settings; - workingDir = "/var/lib/matrix-dendrite"; + workingDir = "/var/lib/dendrite"; in { - options.services.matrix-dendrite = { + options.services.dendrite = { enable = lib.mkEnableOption "matrix.org dendrite"; httpPort = lib.mkOption { type = lib.types.nullOr lib.types.port; @@ -24,7 +24,7 @@ in }; tlsCert = lib.mkOption { type = lib.types.nullOr lib.types.path; - example = "/var/lib/matrix-dendrite/server.cert"; + example = "/var/lib/dendrite/server.cert"; default = null; description = '' The path to the TLS certificate. @@ -36,7 +36,7 @@ in }; tlsKey = lib.mkOption { type = lib.types.nullOr lib.types.path; - example = "/var/lib/matrix-dendrite/server.key"; + example = "/var/lib/dendrite/server.key"; default = null; description = '' The path to the TLS key. @@ -48,7 +48,7 @@ in }; environmentFile = lib.mkOption { type = lib.types.nullOr lib.types.path; - example = "/var/lib/matrix-dendrite/registration_secret"; + example = "/var/lib/dendrite/registration_secret"; default = null; description = '' Environment file as defined in @@ -62,7 +62,7 @@ in # snippet of dendrite-related config - services.matrix-dendrite.settings.client_api.registration_shared_secret = "$REGISTRATION_SHARED_SECRET"; + services.dendrite.settings.client_api.registration_shared_secret = "$REGISTRATION_SHARED_SECRET"; @@ -140,7 +140,7 @@ in ''; }]; - systemd.services.matrix-dendrite = { + systemd.services.dendrite = { description = "Dendrite Matrix homeserver"; after = [ "network.target" @@ -149,22 +149,22 @@ in serviceConfig = { Type = "simple"; DynamicUser = true; - StateDirectory = "matrix-dendrite"; + StateDirectory = "dendrite"; WorkingDirectory = workingDir; - RuntimeDirectory = "matrix-dendrite"; + RuntimeDirectory = "dendrite"; RuntimeDirectoryMode = "0700"; EnvironmentFile = lib.mkIf (cfg.environmentFile != null) cfg.environmentFile; ExecStartPre = if (cfg.environmentFile != null) then '' ${pkgs.envsubst}/bin/envsubst \ -i ${configurationYaml} \ - -o /run/matrix-dendrite/dendrite.yaml + -o /run/dendrite/dendrite.yaml '' else '' - ${pkgs.coreutils}/bin/cp ${configurationYaml} /run/matrix-dendrite/dendrite.yaml + ${pkgs.coreutils}/bin/cp ${configurationYaml} /run/dendrite/dendrite.yaml ''; ExecStart = lib.strings.concatStringsSep " " ([ "${pkgs.dendrite}/bin/dendrite-monolith-server" - "--config /run/matrix-dendrite/dendrite.yaml" + "--config /run/dendrite/dendrite.yaml" ] ++ lib.optionals (cfg.httpPort != null) [ "--http-bind-address :${builtins.toString cfg.httpPort}" ] ++ lib.optionals (cfg.httpsPort != null) [ From 6cb46a389741f7916d2c5746d655c76f9333b148 Mon Sep 17 00:00:00 2001 From: Samuel Dionne-Riel Date: Wed, 5 May 2021 15:06:20 -0400 Subject: [PATCH 011/163] sd_image_raspberrypi4: Remove, as planned initially The replacement is the generic AArch64 image. From there, you can customize an image that works better for your needs, if need be. --- .../installer/cd-dvd/sd-image-raspberrypi4.nix | 14 -------------- .../sd-card/sd-image-raspberrypi4-installer.nix | 10 ---------- .../installer/sd-card/sd-image-raspberrypi4.nix | 8 -------- nixos/release.nix | 5 ----- 4 files changed, 37 deletions(-) delete mode 100644 nixos/modules/installer/cd-dvd/sd-image-raspberrypi4.nix delete mode 100644 nixos/modules/installer/sd-card/sd-image-raspberrypi4-installer.nix delete mode 100644 nixos/modules/installer/sd-card/sd-image-raspberrypi4.nix diff --git a/nixos/modules/installer/cd-dvd/sd-image-raspberrypi4.nix b/nixos/modules/installer/cd-dvd/sd-image-raspberrypi4.nix deleted file mode 100644 index 79db1fa29bc..00000000000 --- a/nixos/modules/installer/cd-dvd/sd-image-raspberrypi4.nix +++ /dev/null @@ -1,14 +0,0 @@ -{ config, ... }: -{ - imports = [ - ../sd-card/sd-image-raspberrypi4-installer.nix - ]; - config = { - warnings = [ - '' - .../cd-dvd/sd-image-raspberrypi4.nix is deprecated and will eventually be removed. - Please switch to .../sd-card/sd-image-raspberrypi4-installer.nix, instead. - '' - ]; - }; -} diff --git a/nixos/modules/installer/sd-card/sd-image-raspberrypi4-installer.nix b/nixos/modules/installer/sd-card/sd-image-raspberrypi4-installer.nix deleted file mode 100644 index 59423e40b64..00000000000 --- a/nixos/modules/installer/sd-card/sd-image-raspberrypi4-installer.nix +++ /dev/null @@ -1,10 +0,0 @@ -{ - imports = [ - ../../profiles/installation-device.nix - ./sd-image-raspberrypi4.nix - ]; - - # the installation media is also the installation target, - # so we don't want to provide the installation configuration.nix. - installer.cloneConfig = false; -} diff --git a/nixos/modules/installer/sd-card/sd-image-raspberrypi4.nix b/nixos/modules/installer/sd-card/sd-image-raspberrypi4.nix deleted file mode 100644 index 35a12c5382f..00000000000 --- a/nixos/modules/installer/sd-card/sd-image-raspberrypi4.nix +++ /dev/null @@ -1,8 +0,0 @@ -# To build, use: -# nix-build nixos -I nixos-config=nixos/modules/installer/sd-card/sd-image-raspberrypi4.nix -A config.system.build.sdImage -{ config, lib, pkgs, ... }: - -{ - imports = [ ./sd-image-aarch64.nix ]; - boot.kernelPackages = pkgs.linuxPackages_rpi4; -} diff --git a/nixos/release.nix b/nixos/release.nix index 327a259de7f..510cd8f82a1 100644 --- a/nixos/release.nix +++ b/nixos/release.nix @@ -186,11 +186,6 @@ in rec { inherit system; }); - sd_image_raspberrypi4 = forMatchingSystems [ "aarch64-linux" ] (system: makeSdImage { - module = ./modules/installer/sd-card/sd-image-raspberrypi4-installer.nix; - inherit system; - }); - # A bootable VirtualBox virtual appliance as an OVA file (i.e. packaged OVF). ova = forMatchingSystems [ "x86_64-linux" ] (system: From 4af225856f2e62811b45f9c193e22450decf2341 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 00:11:23 +0200 Subject: [PATCH 012/163] python3Packages.pykoplenti: init at 1.0.0 --- .../python-modules/pykoplenti/default.nix | 41 +++++++++++++++++++ pkgs/top-level/python-packages.nix | 2 + 2 files changed, 43 insertions(+) create mode 100644 pkgs/development/python-modules/pykoplenti/default.nix diff --git a/pkgs/development/python-modules/pykoplenti/default.nix b/pkgs/development/python-modules/pykoplenti/default.nix new file mode 100644 index 00000000000..98182ddf68c --- /dev/null +++ b/pkgs/development/python-modules/pykoplenti/default.nix @@ -0,0 +1,41 @@ +{ lib +, aiohttp +, buildPythonPackage +, click +, fetchFromGitHub +, prompt_toolkit +, pycryptodome +, pythonOlder +}: + +buildPythonPackage rec { + pname = "pykoplenti"; + version = "1.0.0"; + disabled = pythonOlder "3.7"; + + src = fetchFromGitHub { + owner = "stegm"; + repo = pname; + rev = "v${version}"; + sha256 = "12nsyz8a49vhby1jp991vaky82fm93jrgcsjzwa2rixwg1zql4sw"; + }; + + propagatedBuildInputs = [ + aiohttp + click + prompt_toolkit + pycryptodome + ]; + + # Project has no tests + doCheck = false; + + pythonImportsCheck = [ "pykoplenti" ]; + + meta = with lib; { + description = "Python REST client API for Kostal Plenticore Inverters"; + homepage = "https://github.com/stegm/pykoplenti/"; + license = with licenses; [ asl20 ]; + maintainers = with maintainers; [ fab ]; + }; +} diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index 19d2a40dce6..59a9221d2de 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -5665,6 +5665,8 @@ in { pykodi = callPackage ../development/python-modules/pykodi { }; + pykoplenti = callPackage ../development/python-modules/pykoplenti { }; + pykwalify = callPackage ../development/python-modules/pykwalify { }; pylacrosse = callPackage ../development/python-modules/pylacrosse { }; From 2c28e09c610f02f85d975a35232b07ea29befe5a Mon Sep 17 00:00:00 2001 From: upkeep-bot Date: Thu, 6 May 2021 12:14:26 +0000 Subject: [PATCH 013/163] vscode: 1.55.2 -> 1.56.0 --- pkgs/applications/editors/vscode/vscode.nix | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pkgs/applications/editors/vscode/vscode.nix b/pkgs/applications/editors/vscode/vscode.nix index f517f95a812..e15585d7bcf 100644 --- a/pkgs/applications/editors/vscode/vscode.nix +++ b/pkgs/applications/editors/vscode/vscode.nix @@ -13,10 +13,10 @@ let archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz"; sha256 = { - x86_64-linux = "08151qdhf4chg9gfbs0dl0v0k5vla2gz5dfy439jzdg1d022d5rw"; - x86_64-darwin = "1vlxxkv3wvds3xl3ir93l5q5yq2d7mcragsicfayj9x9r49ilqn3"; - aarch64-linux = "0rxw1wsi555z41ak817sxqyyan0rm7hma640zsh8dz0yvhzdv1h8"; - armv7l-linux = "1ijvd7r2fxxlw4zv3zx5h70b3d0b4gcq3aljsi02v1lr2zm8f8gb"; + x86_64-linux = "0v1g7j5q2j86c3r7jib8xs1sf2h3xvwv1s0xsqbig480fchlshjg"; + x86_64-darwin = "109529acrvyassq00mbhnwbxq7rfq9n69rgcw4n0rysgp8n58386"; + aarch64-linux = "0p6pz9apbfmr4pf7fikp2rmvk5gr87md1zrhr6hhd1qwgpc9kl07"; + armv7l-linux = "1qrp75nbzgqp7mv42m6wbj000l33rhfv7cnxdv6lp6cy05381aq6"; }.${system}; in callPackage ./generic.nix rec { @@ -25,7 +25,7 @@ in # Please backport all compatible updates to the stable release. # This is important for the extension ecosystem. - version = "1.55.2"; + version = "1.56.0"; pname = "vscode"; executableName = "code" + lib.optionalString isInsiders "-insiders"; From d6bb50060509045bc9953ec3b1984836eec1de68 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 00:22:15 +0200 Subject: [PATCH 014/163] python3Packages.motioneye-client: init at 0.3.6 --- .../motioneye-client/default.nix | 52 +++++++++++++++++++ pkgs/top-level/python-packages.nix | 2 + 2 files changed, 54 insertions(+) create mode 100644 pkgs/development/python-modules/motioneye-client/default.nix diff --git a/pkgs/development/python-modules/motioneye-client/default.nix b/pkgs/development/python-modules/motioneye-client/default.nix new file mode 100644 index 00000000000..19bb9a39c29 --- /dev/null +++ b/pkgs/development/python-modules/motioneye-client/default.nix @@ -0,0 +1,52 @@ +{ lib +, aiohttp +, buildPythonPackage +, fetchFromGitHub +, poetry-core +, pytest-aiohttp +, pytest-timeout +, pytestCheckHook +, pythonOlder +}: + +buildPythonPackage rec { + pname = "motioneye-client"; + version = "0.3.6"; + format = "pyproject"; + disabled = pythonOlder "3.8"; + + src = fetchFromGitHub { + owner = "dermotduffy"; + repo = pname; + rev = "v${version}"; + sha256 = "0j28rn7059km7q6z1kalp0pjcrd42wcm5mnbi94j93bvfld97w70"; + }; + + nativeBuildInputs = [ + poetry-core + ]; + + propagatedBuildInputs = [ + aiohttp + ]; + + checkInputs = [ + pytest-aiohttp + pytest-timeout + pytestCheckHook + ]; + + postPatch = '' + substituteInPlace pyproject.toml \ + --replace " --cov-report=html:htmlcov --cov-report=xml:coverage.xml --cov-report=term-missing --cov=motioneye_client --cov-fail-under=100" "" + ''; + + pythonImportsCheck = [ "motioneye_client" ]; + + meta = with lib; { + description = "Python library for motionEye"; + homepage = "https://github.com/dermotduffy/motioneye-client"; + license = with licenses; [ mit ]; + maintainers = with maintainers; [ fab ]; + }; +} diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index 33559777930..07f12451ccc 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -4241,6 +4241,8 @@ in { mortgage = callPackage ../development/python-modules/mortgage { }; + motioneye-client = callPackage ../development/python-modules/motioneye-client { }; + moto = callPackage ../development/python-modules/moto { }; moviepy = callPackage ../development/python-modules/moviepy { }; From 4097ca34861c1ed5f081cd13753bb8a007dec764 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 18:49:55 +0200 Subject: [PATCH 015/163] home-assistant: update component-packages --- pkgs/servers/home-assistant/component-packages.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/servers/home-assistant/component-packages.nix b/pkgs/servers/home-assistant/component-packages.nix index 28b7aed5f39..41868a48732 100644 --- a/pkgs/servers/home-assistant/component-packages.nix +++ b/pkgs/servers/home-assistant/component-packages.nix @@ -521,7 +521,7 @@ "monoprice" = ps: with ps; [ ]; # missing inputs: pymonoprice "moon" = ps: with ps; [ ]; "motion_blinds" = ps: with ps; [ ]; # missing inputs: motionblinds - "motioneye" = ps: with ps; [ ]; # missing inputs: motioneye-client + "motioneye" = ps: with ps; [ motioneye-client ]; "mpchc" = ps: with ps; [ ]; "mpd" = ps: with ps; [ mpd2 ]; "mqtt" = ps: with ps; [ aiohttp-cors paho-mqtt ]; From c21b6891044c4fd5aada624df093c2890aa8d488 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 18:56:57 +0200 Subject: [PATCH 016/163] home-assistant: enable motioneye tests --- pkgs/servers/home-assistant/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index 4df380e2b5a..1c11629d787 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -295,6 +295,7 @@ in with py.pkgs; buildPythonApplication rec { "mobile_app" "modbus" "moon" + "motioneye" "mqtt" "mqtt_eventstream" "mqtt_json" From a6252afa36d613228430008b07372237b39164c0 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 20:10:32 +0200 Subject: [PATCH 017/163] python3Packages.pymeteireann: init at 0.2 --- .../python-modules/pymeteireann/default.nix | 39 +++++++++++++++++++ pkgs/top-level/python-packages.nix | 2 + 2 files changed, 41 insertions(+) create mode 100644 pkgs/development/python-modules/pymeteireann/default.nix diff --git a/pkgs/development/python-modules/pymeteireann/default.nix b/pkgs/development/python-modules/pymeteireann/default.nix new file mode 100644 index 00000000000..7e48a4089a1 --- /dev/null +++ b/pkgs/development/python-modules/pymeteireann/default.nix @@ -0,0 +1,39 @@ +{ lib +, aiohttp +, async-timeout +, buildPythonPackage +, fetchFromGitHub +, pytz +, xmltodict +}: + +buildPythonPackage rec { + pname = "pymeteireann"; + version = "0.2"; + + src = fetchFromGitHub { + owner = "DylanGore"; + repo = "PyMetEireann"; + rev = version; + sha256 = "1904f8mvv4ghzbniswmdwyj5v71m6y3yn1b4grjvfds05skalm67"; + }; + + propagatedBuildInputs = [ + aiohttp + async-timeout + pytz + xmltodict + ]; + + # Project has no tests + doCheck = false; + + pythonImportsCheck = [ "meteireann" ]; + + meta = with lib; { + description = "Python module to communicate with the Met Éireann Public Weather Forecast API"; + homepage = "https://github.com/DylanGore/PyMetEireann/"; + license = with licenses; [ mit ]; + maintainers = with maintainers; [ fab ]; + }; +} diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index 33559777930..9e162f131ce 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -5769,6 +5769,8 @@ in { pymetar = callPackage ../development/python-modules/pymetar { }; + pymeteireann = callPackage ../development/python-modules/pymeteireann { }; + pymetno = callPackage ../development/python-modules/pymetno { }; pymitv = callPackage ../development/python-modules/pymitv { }; From 29b2ee5b07afb5da4e571b5b95c6591d3d86c4e1 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 20:11:17 +0200 Subject: [PATCH 018/163] home-assistant: update component-packages --- pkgs/servers/home-assistant/component-packages.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/servers/home-assistant/component-packages.nix b/pkgs/servers/home-assistant/component-packages.nix index 28b7aed5f39..bf1aa9d76c7 100644 --- a/pkgs/servers/home-assistant/component-packages.nix +++ b/pkgs/servers/home-assistant/component-packages.nix @@ -495,7 +495,7 @@ "meraki" = ps: with ps; [ aiohttp-cors ]; "message_bird" = ps: with ps; [ ]; # missing inputs: messagebird "met" = ps: with ps; [ pymetno ]; - "met_eireann" = ps: with ps; [ ]; # missing inputs: pyMetEireann + "met_eireann" = ps: with ps; [ pymeteireann ]; "meteo_france" = ps: with ps; [ ]; # missing inputs: meteofrance-api "meteoalarm" = ps: with ps; [ ]; # missing inputs: meteoalertapi "metoffice" = ps: with ps; [ ]; # missing inputs: datapoint From d79f71927c692dfa1970e8d7caad117c49e578b1 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 20:11:52 +0200 Subject: [PATCH 019/163] home-assistant: enable met_eireann tests --- pkgs/servers/home-assistant/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index 4df380e2b5a..310deda06ce 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -291,6 +291,7 @@ in with py.pkgs; buildPythonApplication rec { "media_player" "media_source" "met" + "met_eireann" "minecraft_server" "mobile_app" "modbus" From 847937c11d48215c6e2b9a2f87925ad43ee0151f Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Wed, 5 May 2021 23:10:44 +0200 Subject: [PATCH 020/163] python3Packages.mutesync: init at 0.0.1 --- .../python-modules/mutesync/default.nix | 42 +++++++++++++++++++ pkgs/top-level/python-packages.nix | 2 + 2 files changed, 44 insertions(+) create mode 100644 pkgs/development/python-modules/mutesync/default.nix diff --git a/pkgs/development/python-modules/mutesync/default.nix b/pkgs/development/python-modules/mutesync/default.nix new file mode 100644 index 00000000000..98bf6ce0745 --- /dev/null +++ b/pkgs/development/python-modules/mutesync/default.nix @@ -0,0 +1,42 @@ +{ lib +, aiohttp +, async-timeout +, buildPythonPackage +, fetchpatch +, fetchPypi +}: + +buildPythonPackage rec { + pname = "mutesync"; + version = "0.0.1"; + + src = fetchPypi { + inherit pname version; + sha256 = "05r8maq59glwgysg98y1vrysfb1mkh9jpbag3ixl13n8jw8clp85"; + }; + + propagatedBuildInputs = [ + aiohttp + async-timeout + ]; + + patches = [ + # Don't parse requirements.txt, https://github.com/currentoor/pymutesync/pull/1 + (fetchpatch { + name = "add-requirements.patch"; + url = "https://github.com/currentoor/pymutesync/commit/d66910fc83b1ae3060cdb3fe22a6f91fb70a67f0.patch"; + sha256 = "0axhgriyyv31b1r1yidxcrv0nyrqbb63xw5qrmv2iy2h0v96ijsk"; + }) + ]; + + # Project has not published tests yet + doCheck = false; + pythonImportsCheck = [ "mutesync" ]; + + meta = with lib; { + description = "Python module for interacting with mutesync buttons"; + homepage = "https://github.com/currentoor/pymutesync"; + license = with licenses; [ asl20 ]; + maintainers = with maintainers; [ fab ]; + }; +} diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index 37ae756d9da..8111a5110c6 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -4317,6 +4317,8 @@ in { mutatormath = callPackage ../development/python-modules/mutatormath { }; + mutesync = callPackage ../development/python-modules/mutesync { }; + mwclient = callPackage ../development/python-modules/mwclient { }; mwdblib = callPackage ../development/python-modules/mwdblib { }; From ba7d8bdb9fc06ad6a1e7beaa75c4ecd89df8d8cd Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 21:08:44 +0200 Subject: [PATCH 021/163] home-assistant: update component-packages --- pkgs/servers/home-assistant/component-packages.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/servers/home-assistant/component-packages.nix b/pkgs/servers/home-assistant/component-packages.nix index 28b7aed5f39..82e585f19c3 100644 --- a/pkgs/servers/home-assistant/component-packages.nix +++ b/pkgs/servers/home-assistant/component-packages.nix @@ -531,7 +531,7 @@ "mqtt_statestream" = ps: with ps; [ aiohttp-cors paho-mqtt ]; "msteams" = ps: with ps; [ pymsteams ]; "mullvad" = ps: with ps; [ mullvad-api ]; - "mutesync" = ps: with ps; [ ]; # missing inputs: mutesync + "mutesync" = ps: with ps; [ mutesync ]; "mvglive" = ps: with ps; [ PyMVGLive ]; "my" = ps: with ps; [ aiohttp-cors pillow ]; "mychevy" = ps: with ps; [ ]; # missing inputs: mychevy From 382a580b18e3132de280f2ac0d99c9ef3718e560 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Thu, 6 May 2021 21:09:31 +0200 Subject: [PATCH 022/163] home-assistant: enable mutesync tests --- pkgs/servers/home-assistant/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index 4df380e2b5a..b04d07457f8 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -301,6 +301,7 @@ in with py.pkgs; buildPythonApplication rec { "mqtt_room" "mqtt_statestream" "mullvad" + "mutesync" "nexia" "notify" "notion" From 55619fd85e25e193507629fa0f2f16ec8aadc8a6 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Fri, 7 May 2021 20:08:39 +0800 Subject: [PATCH 023/163] kile-wl: add meta.mainProgram --- pkgs/applications/misc/kile-wl/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/applications/misc/kile-wl/default.nix b/pkgs/applications/misc/kile-wl/default.nix index 333f008fedc..479c5bf1d8d 100644 --- a/pkgs/applications/misc/kile-wl/default.nix +++ b/pkgs/applications/misc/kile-wl/default.nix @@ -22,5 +22,6 @@ rustPlatform.buildRustPackage rec { license = licenses.mit; platforms = platforms.linux; # It's meant for river, a wayland compositor maintainers = with maintainers; [ fortuneteller2k ]; + mainProgram = "kile"; }; } From b99ef3d4d81c452ae0bc835ae42f4f00d181d330 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Fri, 7 May 2021 07:40:42 +0800 Subject: [PATCH 024/163] hilbish: init at 0.4.0 --- pkgs/shells/hilbish/default.nix | 26 ++++++++++++++++++++++++++ pkgs/top-level/all-packages.nix | 2 ++ 2 files changed, 28 insertions(+) create mode 100644 pkgs/shells/hilbish/default.nix diff --git a/pkgs/shells/hilbish/default.nix b/pkgs/shells/hilbish/default.nix new file mode 100644 index 00000000000..e0449ce24c2 --- /dev/null +++ b/pkgs/shells/hilbish/default.nix @@ -0,0 +1,26 @@ +{ lib, buildGoModule, fetchFromGitHub, readline }: + +buildGoModule rec { + pname = "hilbish"; + version = "0.4.0"; + + src = fetchFromGitHub { + owner = "Hilbis"; + repo = "Hilbish"; + rev = "v${version}"; + sha256 = "sha256-7YJkjkA6lGyO4PwJcdeUzqQvFsslDfIqAH6vlBtyYz8="; + }; + + vendorSha256 = "sha256-9FftzTn5nxjfsHStcnrn9a+sECmcHRBUEtFjsMp8/ks="; + + buildInputs = [ readline ]; + + meta = with lib; { + description = "An interactive Unix-like shell written in Go"; + changelog = "https://github.com/Hilbis/Hilbish/releases/tag/v${version}"; + homepage = "https://github.com/Hilbis/Hilbish"; + maintainers = with maintainers; [ fortuneteller2k ]; + license = licenses.mit; + platforms = platforms.linux; # only officially supported on Linux + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index d8e77bcf6d4..7447386099d 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -1477,6 +1477,8 @@ in harvid = callPackage ../tools/video/harvid { }; + hilbish = callPackage ../shells/hilbish { }; + hime = callPackage ../tools/inputmethods/hime {}; hinit = haskell.lib.justStaticExecutables haskellPackages.hinit; From 4d555436340f4ce7e46e933a7f0958d29597284b Mon Sep 17 00:00:00 2001 From: Andrey Kuznetsov Date: Sat, 8 May 2021 09:31:43 +0000 Subject: [PATCH 025/163] maintainers: add onsails --- maintainers/maintainer-list.nix | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/maintainers/maintainer-list.nix b/maintainers/maintainer-list.nix index e9d5e811149..60fce67936b 100644 --- a/maintainers/maintainer-list.nix +++ b/maintainers/maintainer-list.nix @@ -7417,6 +7417,12 @@ githubId = 1538622; name = "Michael Reilly"; }; + onsails = { + email = "andrey@onsails.com"; + github = "onsails"; + githubId = 107261; + name = "Andrey Kuznetsov"; + }; onny = { email = "onny@project-insanity.org"; github = "onny"; From 9f050c691c0e3f7473b1525f4725e48d97b27211 Mon Sep 17 00:00:00 2001 From: Andreas Schmid Date: Fri, 7 May 2021 19:57:50 +0200 Subject: [PATCH 026/163] bat-extras: fix build on Darwin (#119987) introduced by #119689 Signed-off-by: Andreas Schmid --- pkgs/tools/misc/bat-extras/default.nix | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkgs/tools/misc/bat-extras/default.nix b/pkgs/tools/misc/bat-extras/default.nix index 4fb09f4d8dc..cb483567f21 100644 --- a/pkgs/tools/misc/bat-extras/default.nix +++ b/pkgs/tools/misc/bat-extras/default.nix @@ -1,6 +1,7 @@ { lib, stdenv, fetchFromGitHub, bash, makeWrapper, bat # batdiff, batgrep, and batwatch , coreutils +, getconf , less # batgrep , ripgrep @@ -48,6 +49,7 @@ let # Run the library tests as they don't have external dependencies doCheck = true; + checkInputs = lib.optionals stdenv.isDarwin [ getconf ]; checkPhase = '' runHook preCheck # test list repeats suites. Unique them @@ -104,6 +106,7 @@ let dontBuild = true; # we've already built doCheck = true; + checkInputs = lib.optionals stdenv.isDarwin [ getconf ]; checkPhase = '' runHook preCheck bash ./test.sh --compiled --suite ${name} From 86ac115276c4294f8fea995e76efdb29fb31c00e Mon Sep 17 00:00:00 2001 From: xfnw Date: Sat, 8 May 2021 04:13:44 +0000 Subject: [PATCH 027/163] xcd: init at 1.2 --- pkgs/tools/misc/xcd/default.nix | 26 ++++++++++++++++++++++++++ pkgs/top-level/all-packages.nix | 2 ++ 2 files changed, 28 insertions(+) create mode 100644 pkgs/tools/misc/xcd/default.nix diff --git a/pkgs/tools/misc/xcd/default.nix b/pkgs/tools/misc/xcd/default.nix new file mode 100644 index 00000000000..c379ed21c19 --- /dev/null +++ b/pkgs/tools/misc/xcd/default.nix @@ -0,0 +1,26 @@ +{ lib, stdenv, fetchurl, ncurses }: + +stdenv.mkDerivation rec { + pname = "xcd"; + version = "1.2"; + + src = fetchurl { + url = "https://www.muppetlabs.com/~breadbox/pub/software/${pname}-${version}.tar.gz"; + sha256 = "1cgwspy08q05rhxbp7m1yrrix252i9jzfcfbzmhdvlgf5bfpl25g"; + }; + + buildInputs = [ ncurses ]; + installPhase = '' + runHook preInstall + install -D $pname $out/bin/$pname + runHook postInstall + ''; + + meta = with lib; { + description = "Colorized hexdump tool"; + homepage = "https://www.muppetlabs.com/~breadbox/software/xcd.html"; + maintainers = [ maintainers.xfnw ]; + license = licenses.mit; + platforms = platforms.unix; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 8b0e720e750..e6a2d8ecc9d 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -808,6 +808,8 @@ in tfk8s = callPackage ../tools/misc/tfk8s { }; + xcd = callPackage ../tools/misc/xcd { }; + xtrt = callPackage ../tools/archivers/xtrt { }; yabridge = callPackage ../tools/audio/yabridge { From 5390d4b9468f2027660e48a694d593a948be308f Mon Sep 17 00:00:00 2001 From: paumr Date: Sat, 8 May 2021 23:13:58 +0200 Subject: [PATCH 028/163] nixos/bind: formatted with nixpkgs-fmt --- nixos/modules/services/networking/bind.nix | 23 +++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/nixos/modules/services/networking/bind.nix b/nixos/modules/services/networking/bind.nix index b73b2b62685..20eef2c3455 100644 --- a/nixos/modules/services/networking/bind.nix +++ b/nixos/modules/services/networking/bind.nix @@ -32,7 +32,7 @@ let slaves = mkOption { type = types.listOf types.str; description = "Addresses who may request zone transfers."; - default = []; + default = [ ]; }; extraConfig = mkOption { type = types.str; @@ -105,7 +105,7 @@ in enable = mkEnableOption "BIND domain name server"; cacheNetworks = mkOption { - default = ["127.0.0.0/24"]; + default = [ "127.0.0.0/24" ]; type = types.listOf types.str; description = " What networks are allowed to use us as a resolver. Note @@ -117,7 +117,7 @@ in }; blockedNetworks = mkOption { - default = []; + default = [ ]; type = types.listOf types.str; description = " What networks are just blocked. @@ -141,7 +141,7 @@ in }; listenOn = mkOption { - default = ["any"]; + default = [ "any" ]; type = types.listOf types.str; description = " Interfaces to listen on. @@ -149,7 +149,7 @@ in }; listenOnIpv6 = mkOption { - default = ["any"]; + default = [ "any" ]; type = types.listOf types.str; description = " Ipv6 interfaces to listen on. @@ -157,7 +157,7 @@ in }; zones = mkOption { - default = []; + default = [ ]; type = with types; coercedTo (listOf attrs) bindZoneCoerce (attrsOf (types.submodule bindZoneOptions)); description = " List of zones we claim authority over. @@ -166,8 +166,8 @@ in "example.com" = { master = false; file = "/var/dns/example.com"; - masters = ["192.168.0.1"]; - slaves = []; + masters = [ "192.168.0.1" ]; + slaves = [ ]; extraConfig = ""; }; }; @@ -212,7 +212,8 @@ in networking.resolvconf.useLocalResolver = mkDefault true; users.users.${bindUser} = - { uid = config.ids.uids.bind; + { + uid = config.ids.uids.bind; description = "BIND daemon user"; }; @@ -232,9 +233,9 @@ in ''; serviceConfig = { - ExecStart = "${pkgs.bind.out}/sbin/named -u ${bindUser} ${optionalString cfg.ipv4Only "-4"} -c ${cfg.configFile} -f"; + ExecStart = "${pkgs.bind.out}/sbin/named -u ${bindUser} ${optionalString cfg.ipv4Only "-4"} -c ${cfg.configFile} -f"; ExecReload = "${pkgs.bind.out}/sbin/rndc -k '/etc/bind/rndc.key' reload"; - ExecStop = "${pkgs.bind.out}/sbin/rndc -k '/etc/bind/rndc.key' stop"; + ExecStop = "${pkgs.bind.out}/sbin/rndc -k '/etc/bind/rndc.key' stop"; }; unitConfig.Documentation = "man:named(8)"; From 52b718303abf3e195b59a7dc5fb347c2fd3b21b8 Mon Sep 17 00:00:00 2001 From: Dmitry Kalinkin Date: Sat, 8 May 2021 18:53:43 -0400 Subject: [PATCH 029/163] yoda: fix a functionality regression in v1.9.0 --- .../libraries/physics/yoda/default.nix | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/pkgs/development/libraries/physics/yoda/default.nix b/pkgs/development/libraries/physics/yoda/default.nix index 3b9057ad31a..c5a83f782f4 100644 --- a/pkgs/development/libraries/physics/yoda/default.nix +++ b/pkgs/development/libraries/physics/yoda/default.nix @@ -1,4 +1,4 @@ -{ lib, stdenv, fetchurl, python, root, makeWrapper, zlib, withRootSupport ? false }: +{ lib, stdenv, fetchurl, fetchpatch, python, root, makeWrapper, zlib, withRootSupport ? false }: stdenv.mkDerivation rec { pname = "yoda"; @@ -9,6 +9,24 @@ stdenv.mkDerivation rec { sha256 = "1x7xi6w7lb92x8202kbaxgqg1sly534wana4f38l3gpbzw9dwmcs"; }; + patches = [ + # fix a minor bug + # https://gitlab.com/hepcedar/yoda/-/merge_requests/38 + (fetchpatch { + name = "yoda-fix-fuzzy-compare-bin2d.patch"; + url = "https://gitlab.com/hepcedar/yoda/-/commit/a2999d78cb3d9ed874f367bad375dc39a1a11148.diff"; + sha256 = "sha256-BsaVm+4VtCvRoEuN4r6A4bj9XwgMe75UesKzN+b56Qw="; + }) + # fix a regression + # https://gitlab.com/hepcedar/yoda/-/merge_requests/40 + (fetchpatch { + name = "yoda-fix-for-yodagz.patch"; + url = "https://gitlab.com/hepcedar/yoda/-/commit/3338ba5a7466599ac6969e4ae462f133d6cf4fd8.diff"; + sha256 = "sha256-MZTOIt468bdPCS7UVfr5hQZUsVy3TpY/TjRrNySIL70="; + excludes = [ "ChangeLog" ]; + }) + ]; + nativeBuildInputs = with python.pkgs; [ cython makeWrapper ]; buildInputs = [ python ] ++ (with python.pkgs; [ numpy matplotlib ]) From 5d54dd8e3e581ab952c9557dfaa48086423b924d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Eduardo=20S=C3=A1nchez=20Mu=C3=B1oz?= Date: Sun, 9 May 2021 01:32:36 +0200 Subject: [PATCH 030/163] gnomeExtensions.appindicator: 36 -> 37 --- pkgs/desktops/gnome/extensions/appindicator/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/desktops/gnome/extensions/appindicator/default.nix b/pkgs/desktops/gnome/extensions/appindicator/default.nix index 0906d762956..65576d292a8 100644 --- a/pkgs/desktops/gnome/extensions/appindicator/default.nix +++ b/pkgs/desktops/gnome/extensions/appindicator/default.nix @@ -2,13 +2,13 @@ stdenv.mkDerivation rec { pname = "gnome-shell-extension-appindicator"; - version = "36"; + version = "37"; src = fetchFromGitHub { owner = "Ubuntu"; repo = "gnome-shell-extension-appindicator"; rev = "v${version}"; - sha256 = "1nx1lgrrp3w5z5hymb91frjdvdkk7x677my5v4jjd330ihqa02dq"; + sha256 = "1yss91n94laakzhym409iyjs5gwhln2pkq0zrdrsxc3z70zlslxl"; }; # This package has a Makefile, but it's used for building a zip for From 25cb63fed65f88a484cf0d4c52388b03ef5d89e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Eduardo=20S=C3=A1nchez=20Mu=C3=B1oz?= Date: Sun, 9 May 2021 01:39:07 +0200 Subject: [PATCH 031/163] gnomeExtensions.arcmenu: 5 -> 10 Supports GNOME 40 --- pkgs/desktops/gnome/extensions/arcmenu/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/desktops/gnome/extensions/arcmenu/default.nix b/pkgs/desktops/gnome/extensions/arcmenu/default.nix index 851a816c61c..8fa29126a30 100644 --- a/pkgs/desktops/gnome/extensions/arcmenu/default.nix +++ b/pkgs/desktops/gnome/extensions/arcmenu/default.nix @@ -2,13 +2,13 @@ stdenv.mkDerivation rec { pname = "gnome-shell-arcmenu"; - version = "5"; + version = "10"; src = fetchFromGitLab { owner = "arcmenu"; repo = "ArcMenu"; rev = "v${version}"; - sha256 = "1w4avvnp08l7lkf76vc7wvfn1cd81l4r4dhz8qnai49rvrjgqcg3"; + sha256 = "04kn3gnjz1wakp0pyiwm0alf0pwsralhis36miif9i6l5iv6a394"; }; patches = [ From 73c19f66827577683dd07644aeb76a6dd2947bc0 Mon Sep 17 00:00:00 2001 From: Thiago Kenji Okada Date: Sat, 8 May 2021 21:08:41 -0300 Subject: [PATCH 032/163] babashka: 0.3.5 -> 0.4.0 --- pkgs/development/interpreters/clojure/babashka.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/interpreters/clojure/babashka.nix b/pkgs/development/interpreters/clojure/babashka.nix index 774bcbe11b2..233a4282a5a 100644 --- a/pkgs/development/interpreters/clojure/babashka.nix +++ b/pkgs/development/interpreters/clojure/babashka.nix @@ -2,7 +2,7 @@ stdenv.mkDerivation rec { pname = "babashka"; - version = "0.3.5"; + version = "0.4.0"; reflectionJson = fetchurl { name = "reflection.json"; @@ -12,7 +12,7 @@ stdenv.mkDerivation rec { src = fetchurl { url = "https://github.com/babashka/${pname}/releases/download/v${version}/${pname}-${version}-standalone.jar"; - sha256 = "sha256-tOLT5W5kK38fb9XL9jOQpw0LjHPjbn+BarckbCuwQAc="; + sha256 = "sha256-NY78gkKJd9ATdu7Ja1AvWkaPv0PuDIKWDZBeYGMJufU="; }; dontUnpack = true; From 8f4ba475d9d922a903ed96a2f8280e4480ae0fe4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Romildo=20Malaquias?= Date: Sat, 8 May 2021 22:04:30 -0300 Subject: [PATCH 033/163] xfce.thunar: 4.16.6 -> 4.16.8 --- pkgs/desktops/xfce/core/thunar/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/desktops/xfce/core/thunar/default.nix b/pkgs/desktops/xfce/core/thunar/default.nix index e220e29f3ed..4e6072c7112 100644 --- a/pkgs/desktops/xfce/core/thunar/default.nix +++ b/pkgs/desktops/xfce/core/thunar/default.nix @@ -20,9 +20,9 @@ let unwrapped = mkXfceDerivation { category = "xfce"; pname = "thunar"; - version = "4.16.6"; + version = "4.16.8"; - sha256 = "12zqwazsqdmghy4h2c4fwxha069l07d46i512395y22h7n6655rn"; + sha256 = "1r7qkd6l0mgf97m1xnnizm7fkvl4a52r3hsds5z68y6myvb78p18"; nativeBuildInputs = [ docbook_xsl From b324675a1533a510b25e5a49e19d1650c6b434cb Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Sun, 9 May 2021 03:35:25 +0200 Subject: [PATCH 034/163] hackage2nix: Unmark all builds broken --- .../configuration-hackage2nix/broken.yaml | 8863 -------- .../transitive-broken.yaml | 112 +- .../haskell-modules/hackage-packages.nix | 17727 ---------------- 3 files changed, 11 insertions(+), 26691 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 52c18b3e43d..21593ab7ece 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -1,8865 +1,2 @@ broken-packages: # These packages don't compile. - - 3dmodels - - 4Blocks - - a50 - - AAI - - abcBridge - - abcnotation - - abeson - - abides - - abnf - - AbortT-monadstf - - AbortT-mtl - - AbortT-transformers - - abstract-par-accelerate - - abt - - AC-BuildPlatform - - AC-EasyRaster-GTK - - AC-HalfInteger - - ac-machine - - ac-machine-conduit - - AC-MiniTest - - AC-Terminal - - AC-VanillaArray - - AC-Vector - - AC-Vector-Fancy - - acc - - accelerate-arithmetic - - accelerate-fftw - - accelerate-fourier - - accelerate-llvm-native - - accelerate-random - - accelerate-typelits - - accelerate-utility - - accentuateus - - access-time - - access-token-provider - - achille - - acid-state-dist - - acid-state-tls - - ACME - - acme-all-monad - - acme-comonad - - acme-dont - - acme-flipping-tables - - acme-hq9plus - - acme-http - - acme-inator - - acme-kitchen-sink - - acme-left-pad - - acme-miscorder - - acme-mutable-package - - acme-now - - acme-numbersystem - - acme-operators - - acme-php - - acme-schoenfinkel - - acme-strfry - - acme-stringly-typed - - acme-this - - acme-zero - - acousticbrainz-client - - ActionKid - - activehs - - activehs-base - - activitypub - - activitystreams-aeson - - actor - - acts - - Adaptive - - Adaptive-Blaisorblade - - adaptive-containers - - adaptive-tuple - - adb - - addy - - adhoc-network - - adict - - adjunction - - adobe-swatch-exchange - - adp-multi - - adp-multi-monadiccp - - ADPfusion - - ADPfusionForest - - ADPfusionSet - - adtrees - - advent-of-code-api - - Advgame - - Advise-me - - AERN-Basics - - AERN-Net - - AERN-Real - - AERN-Real-Double - - AERN-Real-Interval - - AERN-RnToRm - - AERN-RnToRm-Plot - - aern2-mp - - aern2-real - - aeson-applicative - - aeson-decode - - aeson-diff-generic - - aeson-extra - - aeson-filthy - - aeson-flowtyped - - aeson-injector - - aeson-match-qq - - aeson-native - - aeson-options - - aeson-prefix - - aeson-schema - - aeson-schemas - - aeson-smart - - aeson-streams - - aeson-t - - aeson-tiled - - aeson-typescript - - aeson-utils - - aeson-via - - affection - - affine-invariant-ensemble-mcmc - - afv - - ag-pictgen - - Agata - - agda-language-server - - agda-server - - agda-snippets - - agda-snippets-hakyll - - agda-unused - - agentx - - AGI - - AhoCorasick - - aig - - aip - - air-th - - airbrake - - airship - - airtable-api - - aivika-distributed - - aivika-experiment-diagrams - - ajhc - - AlanDeniseEricLauren - - alerta - - alex-prelude - - alfred - - alga - - algebra-checkers - - algebra-dag - - algebra-driven-design - - algebra-sql - - algebraic - - algebraic-prelude - - algo-s - - algolia - - AlgoRhythm - - AlgorithmW - - align-text - - AlignmentAlgorithms - - Allure - - ally-invest - - alms - - alpha - - alphachar - - alsa - - alsa-gui - - alsa-midi - - alsa-pcm-tests - - alsa-seq-tests - - altcomposition - - alternative-extra - - alternative-io - - alto - - alure - - amazon-emailer - - amazon-emailer-client-snap - - amazon-products - - amazonka-ec2 - - amazonka-s3-streaming - - amby - - AMI - - ampersand - - amqp-conduit - - amqp-streamly - - analyze - - analyze-client - - anansi-pandoc - - anatomy - - android - - android-activity - - android-lint-summary - - AndroidViewHierarchyImporter - - angel - - angle - - Animas - - animascii - - animate - - animate-example - - animate-frames - - animate-preview - - animate-sdl2 - - annah - - annotated-fix - - Annotations - - anonymous-sums - - anonymous-sums-tests - - ansi-terminal-game - - ansigraph - - antagonist - - antfarm - - anticiv - - antigate - - antimirov - - antiope-athena - - antiope-contract - - antiope-core - - antiope-dynamodb - - antiope-es - - antiope-messages - - antiope-optparse-applicative - - antiope-s3 - - antiope-shell - - antiope-sns - - antiope-sqs - - antiquoter - - antisplice - - antlr-haskell - - antlrc - - anydbm - - aop-prelude - - aos-signature - - aosd - - apart - - apecs-stm - - apelsin - - api-builder - - api-rpc-factom - - api-rpc-pegnet - - api-tools - - api-yoti - - apiary - - apiary-authenticate - - apiary-clientsession - - apiary-cookie - - apiary-eventsource - - apiary-helics - - apiary-http-client - - apiary-logger - - apiary-memcached - - apiary-mongoDB - - apiary-persistent - - apiary-purescript - - apiary-redis - - apiary-session - - apiary-websockets - - apis - - apns-http2 - - apotiki - - app-lens - - appc - - ApplePush - - AppleScript - - applicative-fail - - applicative-parsec - - applicative-quoters - - applicative-splice - - apply-unordered - - approveapi - - approx - - ApproxFun-hs - - arb-fft - - arbb-vm - - arbor-datadog - - arbor-monad-counter - - arbor-monad-logger - - arbor-monad-metric - - arbor-monad-metric-datadog - - arbor-postgres - - arch-hs - - arch-web - - archive-libarchive - - archiver - - archlinux - - archlinux-web - - archnews - - arduino-copilot - - arena - - arff - - arghwxhaskell - - argon - - argon2 - - argparser - - arguedit - - ariadne - - arion - - arithmetic-circuits - - armada - - armor - - arpa - - arpack - - array-builder - - array-chunks - - array-forth - - array-list - - array-primops - - arrayfire - - arraylist - - ArrayRef - - arrow-improve - - arrow-list - - arrowapply-utils - - arrowp - - arrowp-qq - - ArrowVHDL - - artery - - artifact - - asap - - ascii-flatten - - ascii-string - - ascii-table - - ascii-vector-avc - - ascii85-conduit - - asic - - asil - - asn - - ASN1 - - asn1-codec - - asn1-data - - assert - - assert4hs - - assert4hs-core - - assert4hs-hspec - - assert4hs-tasty - - assertions - - asset-map - - assimp - - assumpta - - ast-monad - - ast-monad-json - - astrds - - astview - - async-combinators - - async-dejafu - - async-manager - - async-timer - - asynchronous-exceptions - - aterm-utils - - atlassian-connect-core - - atlassian-connect-descriptor - - atmos-dimensional-tf - - atndapi - - atom-msp430 - - atomic-modify - - atomic-primops-foreign - - atomic-primops-vector - - atomo - - atp - - atp-haskell - - ats-pkg - - ats-setup - - ats-storable - - attempt - - attic-schedule - - atto-lisp - - AttoBencode - - AttoJson - - attomail - - attoparsec-enumerator - - attoparsec-ip - - attoparsec-iteratee - - attoparsec-text - - attoparsec-text-enumerator - - attoparsec-trans - - attoparsec-uri - - attosplit - - Attrac - - atuin - - audiovisual - - augeas - - augur - - aur - - aur-api - - aura - - Aurochs - - authenticate-ldap - - authinfo-hs - - authoring - - AutoForms - - autom - - automata - - autonix-deps - - autonix-deps-kf5 - - autopack - - avatar-generator - - avers - - avers-api - - avers-api-docs - - avers-server - - avl-static - - AvlTree - - avr-shake - - avro-piper - - awesome-prelude - - awesomium - - awesomium-glut - - awesomium-raw - - aws-cloudfront-signer - - aws-configuration-tools - - aws-dynamodb-conduit - - aws-dynamodb-streams - - aws-easy - - aws-ec2 - - aws-ec2-knownhosts - - aws-elastic-transcoder - - aws-general - - aws-kinesis - - aws-kinesis-client - - aws-kinesis-reshard - - aws-lambda - - aws-lambda-haskell-runtime-wai - - aws-lambda-runtime - - aws-larpi - - aws-mfa-credentials - - aws-performance-tests - - aws-route53 - - aws-sdk - - aws-sdk-text-converter - - aws-sdk-xml-unordered - - aws-ses-easy - - aws-sign4 - - aws-simple - - aws-sns - - axel - - axiom - - azimuth-hs - - azubi - - azure-acs - - azure-email - - azure-functions-worker - - azure-service-api - - azure-servicebus - - azurify - - b-tree - - b9 - - babylon - - backblaze-b2-hs - - backdropper - - backstop - - backtracking-exceptions - - backward-state - - bag - - Baggins - - bake - - ballast - - bamboo - - bamboo-launcher - - bamboo-plugin-highlight - - bamboo-plugin-photo - - bamboo-theme-blueprint - - bamboo-theme-mini-html5 - - bamse - - bamstats - - ban-instance - - Bang - - bank-holiday-usa - - banwords - - barchart - - barcodes-code128 - - barecheck - - Barracuda - - barrie - - barrier - - barrier-monad - - base-compat-migrate - - base-encoding - - base-feature-macros - - base-generics - - base-io-access - - base16 - - base16-lens - - base32-bytestring - - base62 - - base64-bytes - - base64-conduit - - baserock-schema - - basex-client - - BASIC - - basic - - basic-sop - - baskell - - batchd - - battlenet - - battlenet-yesod - - battleplace - - battleplace-api - - battleship-combinatorics - - battleships - - bayes-stack - - bazel-coverage-report-renderer - - bbi - - BCMtools - - bcp47 - - bcp47-orphans - - bdcs - - bdcs-api - - bdd - - bdo - - beam - - beam-automigrate - - beam-core - - beam-migrate - - beam-mysql - - beam-newtype-field - - beam-postgres - - beam-sqlite - - beam-th - - beamable - - beautifHOL - - bech32 - - bech32-th - - bed-and-breakfast - - beeminder-api - - Befunge93 - - bein - - belka - - bench-graph - - bench-show - - BenchmarkHistory - - bencodex - - berkeleydb - - BerkeleyDBXML - - BerlekampAlgorithm - - berp - - bert - - besout - - bet - - betacode - - betris - - bff - - bglib - - bgmax - - bgzf - - bhoogle - - bibdb - - bidi-icu - - bidirectional - - bidirectionalization-combined - - bidispec - - bidispec-extras - - BiGUL - - billboard-parser - - billeksah-forms - - billeksah-main - - billeksah-pane - - billeksah-services - - binary-bits - - binary-communicator - - binary-derive - - binary-ext - - binary-file - - binary-indexed-tree - - binary-protocol - - binary-protocol-zmq - - binary-streams - - binary-tagged - - binary-typed - - bind-marshal - - BinderAnn - - binding-core - - binding-gtk - - binding-wx - - bindings-apr - - bindings-apr-util - - bindings-bfd - - bindings-cctools - - bindings-common - - bindings-dc1394 - - bindings-eskit - - bindings-EsounD - - bindings-fann - - bindings-fluidsynth - - bindings-friso - - bindings-gsl - - bindings-hamlib - - bindings-hdf5 - - bindings-K8055 - - bindings-libftdi - - bindings-libg15 - - bindings-libpci - - bindings-librrd - - bindings-libstemmer - - bindings-libusb - - bindings-libv4l2 - - bindings-linux-videodev2 - - bindings-monetdb-mapi - - bindings-mpdecimal - - bindings-ppdev - - bindings-sc3 - - bindings-sipc - - bindings-wlc - - bindynamic - - binembed - - binembed-example - - bio - - bio-sequence - - bioace - - bioalign - - Biobase - - BiobaseBlast - - BiobaseDotP - - BiobaseENA - - BiobaseEnsembl - - BiobaseFasta - - BiobaseFR3D - - BiobaseHTTP - - BiobaseHTTPTools - - BiobaseInfernal - - BiobaseMAF - - BiobaseNewick - - BiobaseTrainingData - - BiobaseTurner - - BiobaseTypes - - BiobaseVienna - - BiobaseXNA - - biocore - - biofasta - - biofastq - - biohazard - - BioHMM - - bioinformatics-toolkit - - biophd - - biopsl - - biosff - - biostockholm - - bip32 - - birch-beer - - bird - - BirdPP - - birds-of-paradise - - bisect-binary - - bishbosh - - bit-array - - bit-stream - - bitcoin-address - - bitcoin-api - - bitcoin-api-extra - - bitcoin-block - - bitcoin-compact-filters - - bitcoin-hs - - bitcoin-keys - - bitcoin-rpc - - bitcoin-script - - bitcoin-scripting - - bitcoin-tx - - bitcoin-types - - bitcoind-regtest - - bitcoind-rpc - - Bitly - - bitly-cli - - bitmaps - - bits-atomic - - bits-conduit - - bits-extras - - bitset - - bitspeak - - BitStringRandomMonad - - BitSyntax - - bittorrent - - bitwise-enum - - bitx-bitcoin - - bizzlelude - - bizzlelude-js - - bkr - - bla - - blakesum - - blakesum-demo - - blas - - BlastHTTP - - blastxml - - blatex - - blaze-builder-enumerator - - blaze-colonnade - - blaze-html-contrib - - blaze-html-hexpat - - blaze-html-truncate - - blaze-json - - blaze-textual-native - - blazeT - - ble - - blink1 - - blip - - bliplib - - Blobs - - blockchain - - blockhash - - Blogdown - - blogination - - BlogLiterately - - BlogLiterately-diagrams - - bloodhound - - bloodhound-amazonka-auth - - bloomfilter-redis - - blosum - - bloxorz - - blubber - - blubber-server - - Blueprint - - bluetile - - bluetileutils - - blunk-hask-tests - - blunt - - bno055-haskell - - bogocopy - - bogre-banana - - boilerplate - - bolt - - boltzmann-brain - - bond - - bond-haskell - - bond-haskell-compiler - - bookkeeper - - bookkeeper-permissions - - Bookshelf - - boolean-normal-forms - - boolexpr - - boombox - - boomslang - - boopadoop - - boots-app - - boots-cloud - - boots-web - - borel - - boring-window-switcher - - bot - - botpp - - bottom - - bound-extras - - bounded-array - - bowntz - - box - - box-csv - - box-socket - - braid - - brain-bleep - - Bravo - - breakout - - breve - - brians-brain - - brick-dropdownmenu - - bricks - - bricks-internal - - bricks-internal-test - - bricks-parsec - - bricks-rendering - - bricks-syntax - - brillig - - broccoli - - brok - - broker-haskell - - bronyradiogermany-common - - bronyradiogermany-streaming - - brotli - - brotli-conduit - - brotli-streams - - browscap - - bsd-sysctl - - bson - - bson-generic - - bson-generics - - bson-lens - - bsparse - - btree - - btree-concurrent - - buchhaltung - - buffer - - buffer-builder - - buffer-builder-aeson - - BufferedSocket - - buffet - - buffon - - bugsnag-haskell - - bugzilla - - build - - buildable - - buildbox - - buildbox-tools - - builder - - buildwrapper - - bullet - - bulletproofs - - bulmex - - bumper - - bunz - - burnt-explorer - - burst-detection - - bus-pirate - - Buster - - buster - - buster-gtk - - buster-network - - butter - - butterflies - - bv-sized - - byline - - bytable - - bytearray-parsing - - bytebuild - - bytehash - - bytelog - - byteslice - - bytesmith - - bytestring-arbitrary - - bytestring-builder-varword - - bytestring-class - - bytestring-csv - - bytestring-plain - - bytestring-read - - bytestring-rematch - - bytestring-show - - bytestring-substring - - bytestring-time - - bytestring-trie - - bytestring-typenats - - bytestringparser - - bytestringparser-temporary - - bytestringreadp - - c-dsl - - c-io - - c-mosquitto - - c0check - - c0parser - - c10k - - c2ats - - cab - - cabal-appimage - - cabal-audit - - cabal-bounds - - cabal-bundle-clib - - cabal-cache - - cabal-cargs - - cabal-constraints - - cabal-db - - cabal-dependency-licenses - - cabal-dev - - cabal-dir - - cabal-edit - - cabal-file-th - - cabal-ghc-dynflags - - cabal-ghci - - cabal-graphdeps - - Cabal-ide-backend - - cabal-info - - cabal-install-bundle - - cabal-install-ghc72 - - cabal-install-ghc74 - - cabal-lenses - - cabal-meta - - cabal-mon - - cabal-nirvana - - cabal-progdeps - - cabal-query - - cabal-setup - - cabal-sort - - cabal-src - - cabal-test - - cabal-test-quickcheck - - cabal-upload - - cabal2arch - - cabal2doap - - cabal2ebuild - - cabal2ghci - - cabalgraph - - cabalish - - cabalmdvrpm - - cabalQuery - - cabalrpmdeps - - CabalSearch - - cabalvchk - - cabin - - cabocha - - cache-polysemy - - cached - - caching - - caching-vault - - cacophony - - cafeteria-prelude - - caffegraph - - cairo-core - - cake - - cake3 - - cakyrespa - - cal-layout - - cal3d - - cal3d-examples - - cal3d-opengl - - calamity - - calc - - calculator - - caldims - - caledon - - calenderweek - - call - - call-alloy - - call-haskell-from-anything - - camfort - - campfire - - candid - - canon - - canonical-filepath - - canonical-json - - canteven-http - - canteven-listen-http - - canteven-log - - canteven-parsedate - - cantor - - cao - - cap - - Capabilities - - capnp - - capped-list - - capri - - car-pool - - caramia - - carbonara - - carboncopy - - cardano-coin-selection - - carettah - - CarneadesDSL - - CarneadesIntoDung - - carte - - cartel - - Cartesian - - casa-abbreviations-and-acronyms - - casadi-bindings - - casadi-bindings-control - - casadi-bindings-core - - casadi-bindings-internal - - casadi-bindings-ipopt-interface - - casadi-bindings-snopt-interface - - Cascade - - cascading - - caseof - - cases - - cash - - cassandra-cql - - Cassava - - cassava-conduit - - cassava-records - - cassette - - cassy - - castle - - casui - - catamorphism - - Catana - - catch-fd - - categorical-algebra - - category-extras - - category-traced - - catnplus - - cautious-file - - cautious-gen - - cayene-lpp - - cayley-client - - CBOR - - CC-delcont-alt - - CC-delcont-cxe - - CC-delcont-exc - - CC-delcont-ref - - CC-delcont-ref-tf - - CCA - - cci - - ccnx - - cctools-workqueue - - cedict - - cef - - cef3-raw - - cef3-simple - - ceilometer-common - - cellrenderer-cairo - - celtchar - - cerberus - - cereal-derive - - cereal-enumerator - - cereal-ieee754 - - cereal-io-streams - - cereal-plus - - cereal-streams - - certificate - - cf - - cfenv - - cfipu - - cflp - - cfopu - - cg - - cgen - - cgi-utils - - cgrep - - chainweb-mining-client - - chakra - - chalkboard - - chalkboard-viewer - - character-cases - - charade - - chart-cli - - Chart-fltkhs - - chart-histogram - - Chart-simple - - chart-svg - - chart-svg-various - - chart-unit - - charter - - chatty-text - - chatwork - - cheapskate-terminal - - check-pvp - - Checked - - checked - - checkmate - - chell-quickcheck - - chessIO - - chevalier-common - - chiasma - - chiphunk - - chitauri - - Chitra - - choose - - choose-exe - - chorale - - chorale-geo - - chp - - chp-mtl - - chp-plus - - chp-spec - - chp-transformers - - chr-core - - chr-lang - - chr-parse - - ChristmasTree - - chromatin - - chronograph - - chronos-bench - - chu2 - - chunks - - chunky - - church - - church-maybe - - churros - - cielo - - cil - - cinvoke - - cio - - cipher-blowfish - - ciphersaber2 - - circlehs - - circular - - citation-resolve - - citeproc-hs - - citeproc-hs-pandoc-filter - - cj-token - - cjk - - cl3 - - cl3-hmatrix-interface - - cl3-linear-interface - - clac - - clafer - - claferIG - - claferwiki - - clang-compilation-database - - clang-pure - - clanki - - clarifai - - CLASE - - clash - - clash-ghc - - clash-lib - - clash-multisignal - - clash-prelude - - Clash-Royale-Hack-Cheats - - clash-systemverilog - - clash-verilog - - clash-vhdl - - classify-frog - - ClassLaws - - classy-influxdb-simple - - classy-miso - - classy-parallel - - classyplate - - ClassyPrelude - - clckwrks - - clckwrks-cli - - clckwrks-dot-com - - clckwrks-plugin-bugs - - clckwrks-plugin-ircbot - - clckwrks-plugin-mailinglist - - clckwrks-plugin-media - - clckwrks-plugin-page - - clckwrks-plugin-redirect - - clckwrks-theme-bootstrap - - clckwrks-theme-clckwrks - - clckwrks-theme-geo-bootstrap - - cld2 - - Clean - - clean-unions - - cless - - clevercss - - clexer - - CLI - - cli-builder - - cli-extras - - cli-git - - cli-nix - - clickhouse-haskell - - clif - - clifford - - clifm - - clingo - - clippard - - clipper - - clippings - - clisparkline - - clit - - clocked - - clogparse - - clone-all - - closure - - cloud-haskell - - cloud-seeder - - cloudfront-signer - - clr-inline - - clua - - cluss - - ClustalParser - - clustering - - clustertools - - clutterhs - - cmark-highlight - - cmark-patterns - - cmark-sections - - cmath - - cmathml3 - - CMCompare - - cmd-item - - cmdlib - - cmdtheline - - cmf - - cmonad - - cmph - - cmptype - - CMQ - - cmt - - cmv - - cnc-spec-compiler - - co-log-polysemy - - co-log-polysemy-formatting - - co-log-sys - - Coadjute - - coalpit - - cobot-io - - cobot-tools - - code-builder - - codec - - codec-beam - - codec-libevent - - codec-rpm - - codecov-haskell - - codemonitor - - codepad - - codeworld-api - - codex - - codo-notation - - coercible-utils - - coin - - coinbase-exchange - - coinbase-pro - - coincident-root-loci - - colada - - colchis - - collada-output - - collapse-duplication - - collapse-util - - collection-json - - collections - - collections-api - - collections-base-instances - - colonnade - - color-counter - - colorless - - colorless-http-client - - colorless-scotty - - colour-space - - coltrane - - columbia - - columnar - - com - - comark-syntax - - combinat - - combinat-diagrams - - combinator-interactive - - combinatorial-problems - - Combinatorrent - - combobuffer - - comic - - Command - - commander - - Commando - - commodities - - commsec - - commsec-keyexchange - - ComonadSheet - - compact-list - - compact-map - - compact-mutable - - compact-mutable-vector - - compact-socket - - compact-string - - compact-string-fix - - compact-word-vectors - - Compactable - - compactable - - compdata - - compdata-automata - - compdata-dags - - compdata-param - - compendium-client - - competition - - compilation - - complex-generic - - complexity - - compose-trans - - composite-opaleye - - composite-swagger - - composition-tree - - comprehensions-ghc - - compressed - - compstrat - - comptrans - - computational-algebra - - computational-geometry - - computations - - ConClusion - - concraft - - concraft-hr - - concraft-pl - - concrete-haskell - - concrete-haskell-autogen - - concrete-relaxng-parser - - concrete-typerep - - concurrency-benchmarks - - concurrent-buffer - - Concurrent-Cache - - concurrent-machines - - concurrent-state - - Concurrential - - Condor - - condor - - condorcet - - conductive-base - - conductive-hsc3 - - conductive-song - - conduit-audio-lame - - conduit-audio-samplerate - - conduit-find - - conduit-iconv - - conduit-network-stream - - conduit-resumablesink - - conduit-throttle - - conduit-tokenize-attoparsec - - conduit-vfs - - conduit-vfs-zip - - conf - - confcrypt - - conferer-dhall - - conferer-provider-dhall - - conferer-provider-json - - conferer-provider-yaml - - conferer-snap - - conferer-source-dhall - - conferer-source-json - - conferer-source-yaml - - conffmt - - confide - - config-parser - - config-select - - config-value-getopt - - ConfigFileTH - - Configger - - configifier - - Configurable - - configuration - - configurator-ng - - confsolve - - congruence-relation - - conjure - - conkin - - conlogger - - connection-string - - connections - - Conscript - - consistent - - console-program - - const-math-ghc-plugin - - constr-eq - - constrained-categories - - constrained-category - - constrained-dynamic - - constrained-monads - - constraint-manip - - ConstraintKinds - - constraints-emerge - - constructible - - constructive-algebra - - consul-haskell - - Consumer - - consumers - - container - - containers-benchmark - - containers-verified - - ContArrow - - content-store - - context-free-grammar - - context-stack - - ContextAlgebra - - contiguous - - contiguous-checked - - contiguous-fft - - continue - - continuum - - continuum-client - - Contract - - control - - control-iso - - control-monad-attempt - - control-monad-exception-monadsfd - - control-monad-failure - - control-monad-failure-mtl - - Control-Monad-MultiPass - - Control-Monad-ST2 - - contstuff-monads-tf - - contstuff-transformers - - conversions - - convert - - convert-annotation - - convertible-ascii - - convertible-text - - cookies - - coordinate - - copilot - - copilot-c99 - - copilot-cbmc - - copilot-language - - copilot-libraries - - copilot-sbv - - copilot-theorem - - copr - - COrdering - - core - - core-haskell - - corebot-bliki - - CoreDump - - CoreErlang - - CoreFoundation - - corenlp-parser - - Coroutine - - coroutine-enumerator - - coroutine-iteratee - - coroutine-object - - couch-hs - - CouchDB - - couchdb-conduit - - couchdb-enumerator - - countable-inflections - - counter - - country-codes - - courier - - court - - coverage - - cparsing - - CPBrainfuck - - cpio-conduit - - cpkg - - CPL - - cplusplus-th - - cprng-aes-effect - - cpuperf - - cpython - - cql-io - - cql-io-tinylog - - cqrs-core - - cqrs-example - - cqrs-memory - - cqrs-postgresql - - cqrs-sqlite3 - - cqrs-test - - cqrs-testkit - - cr - - crack - - craft - - Craft3e - - craftwerk - - craftwerk-cairo - - craftwerk-gtk - - crawlchain - - craze - - crc - - crc16 - - crdt - - crdt-event-fold - - creatur - - credential-store - - crf-chain1 - - crf-chain1-constrained - - crf-chain2-generic - - crf-chain2-tiers - - critbit - - criterion-cmp - - criterion-compare - - criterion-plus - - criterion-to-html - - criu-rpc - - criu-rpc-types - - crjdt-haskell - - crockford - - crocodile - - cron-compat - - cruncher-types - - crunghc - - crypt-sha512 - - crypto-cipher-benchmarks - - crypto-classical - - crypto-conduit - - crypto-keys-ssh - - crypto-multihash - - crypto-pubkey-openssh - - crypto-random-effect - - crypto-simple - - cryptocipher - - cryptocompare - - cryptoconditions - - cryptoids - - cryptoids-class - - cryptoids-types - - cryptol - - cryptsy-api - - crystalfontz - - cse-ghc-plugin - - csg - - CSPM-cspm - - CSPM-FiringRules - - CSPM-Frontend - - CSPM-Interpreter - - CSPM-ToProlog - - cspmchecker - - cspretty - - css - - css-easings - - css-selectors - - csv-enumerator - - csv-nptools - - ctemplate - - ctkl - - ctpl - - cube - - cubical - - cuboid - - cuckoo - - curl-runnings - - currency-codes - - currency-convert - - curry-frontend - - CurryDB - - curryer-rpc - - cursedcsv - - cursor-fuzzy-time-gen - - curves - - custom-prelude - - CV - - cv-combinators - - cypher - - d-bus - - d3js - - dag - - DAG-Tournament - - damnpacket - - Dangerous - - danibot - - Dao - - dao - - dapi - - darcs-benchmark - - darcs-beta - - darcs-buildpackage - - darcs-cabalized - - darcs-fastconvert - - darcs-graph - - darcs-monitor - - darcs2dot - - darcsden - - DarcsHelpers - - darcswatch - - darkplaces-demo - - darkplaces-rcon - - darkplaces-rcon-util - - darkplaces-text - - dash-haskell - - data-accessor-monads-fd - - data-accessor-monads-tf - - data-aviary - - data-base - - data-basic - - data-check - - data-combinator-gen - - data-concurrent-queue - - data-construction - - data-cycle - - data-dispersal - - data-diverse-lens - - data-easy - - data-elf - - data-embed - - data-emoticons - - data-filepath - - data-fin - - data-fin-simple - - data-flagset - - data-interval - - data-ivar - - data-kiln - - data-layer - - data-lens - - data-lens-fd - - data-lens-ixset - - data-lens-template - - data-map-multikey - - data-nat - - data-object - - data-object-json - - data-object-yaml - - data-pprint - - data-quotientref - - data-r-tree - - data-reify-cse - - data-repr - - data-result - - data-rev - - Data-Rope - - data-rope - - data-rtuple - - data-size - - data-spacepart - - data-standards - - data-store - - data-stringmap - - data-structure-inferrer - - data-sword - - data-type - - data-util - - data-validation - - data-variant - - database-id-groundhog - - database-study - - datadog - - datadog-tracing - - datafix - - dataflow - - datalog - - datapacker - - datasets - - DataTreeView - - dataurl - - DataVersion - - date-conversions - - dates - - datetime - - datetime-sb - - dawdle - - dawg - - dbcleaner - - dbf - - DBFunctor - - dbjava - - DBlimited - - dbm - - dbmigrations-mysql - - dbmigrations-postgresql - - dbmigrations-sqlite - - DBus - - dbus-client - - dbus-core - - dbus-qq - - dclabel - - dclabel-eci11 - - dcpu16 - - ddate - - ddc-base - - ddc-build - - ddc-code - - ddc-core - - ddc-core-babel - - ddc-core-eval - - ddc-core-flow - - ddc-core-llvm - - ddc-core-salt - - ddc-core-simpl - - ddc-core-tetra - - ddc-driver - - ddc-interface - - ddc-source-tetra - - ddc-tools - - ddc-war - - ddci-core - - dead-code-detection - - dead-simple-json - - Deadpan-DDP - - debug - - debug-me - - debug-trace-var - - debug-tracy - - decepticons - - decidable - - decimal-arithmetic - - decimal-literals - - DecisionTree - - decoder-conduit - - dedukti - - deep-transformations - - DeepArrow - - deepcontrol - - DeepDarkFantasy - - deeplearning-hs - - deepseq-bounded - - deepseq-magic - - deepseq-th - - deepzoom - - defargs - - DefendTheKing - - deka - - deka-tests - - delaunay - - delicious - - delimited-text - - delimiter-separated - - delta - - delta-h - - Delta-Lambda - - delude - - demarcate - - denominate - - dense - - dense-int-set - - dep-t - - dep-t-advice - - dependent-hashmap - - dependent-monoidal-map - - dependent-state - - depends - - dephd - - deptrack-core - - deptrack-devops - - deptrack-dot - - dequeue - - derangement - - derivation-trees - - derive - - derive-enumerable - - derive-gadt - - derive-IG - - derive-monoid - - derive-trie - - derp-lib - - describe - - descript-lang - - deterministic-game-engine - - detour-via-uom - - deunicode - - devil - - devtools - - dewdrop - - dfinity-radix-tree - - Dflow - - dfsbuild - - dgim - - dgs - - dhall-check - - dhall-docs - - dhall-fly - - dhall-nix - - dhall-nixpkgs - - dhall-recursive-adt - - dhall-text - - dhall-to-cabal - - dhcp-lease-parser - - dhrun - - dia-base - - dia-functions - - diagrams-boolean - - diagrams-braille - - diagrams-builder - - diagrams-canvas - - diagrams-graphviz - - diagrams-gtk - - diagrams-haddock - - diagrams-html5 - - diagrams-pandoc - - diagrams-pdf - - diagrams-pgf - - diagrams-qrcode - - diagrams-rasterific - - diagrams-rubiks-cube - - diagrams-tikz - - diagrams-wx - - dib - - dice2tex - - dicom - - dictionaries - - dictparser - - diet - - diff - - diffcabal - - difference-monoid - - DifferenceLogic - - differential - - DifferentialEvolution - - diffmap - - difftodo - - digestive-bootstrap - - digestive-foundation-lucid - - digestive-functors-aeson - - digestive-functors-happstack - - digestive-functors-hsp - - DigitalOcean - - digitalocean-kzs - - digits - - dimensional-codata - - dimensional-tf - - DimensionalHash - - dingo-core - - dingo-example - - dingo-widgets - - diohsc - - diophantine - - diplomacy - - diplomacy-server - - direct-binary-files - - direct-fastcgi - - direct-http - - direct-plugins - - direct-rocksdb - - directed-cubical - - directory-contents - - direm - - dirfiles - - discogs-haskell - - discord-gateway - - discord-hs - - discord-register - - discord-rest - - discord-types - - discordian-calendar - - discrete - - DiscussionSupportSystem - - Dish - - disjoint-containers - - disjoint-set - - disjoint-set-stateful - - Dist - - dist-upload - - distance - - DisTract - - distributed-fork-aws-lambda - - distributed-process - - distributed-process-async - - distributed-process-azure - - distributed-process-client-server - - distributed-process-ekg - - distributed-process-execution - - distributed-process-extras - - distributed-process-fsm - - distributed-process-lifted - - distributed-process-monad-control - - distributed-process-p2p - - distributed-process-platform - - distributed-process-registry - - distributed-process-simplelocalnet - - distributed-process-supervisor - - distributed-process-systest - - distributed-process-task - - distributed-process-tests - - distributed-process-zookeeper - - distribution - - distribution-plot - - diversity - - dixi - - djembe - - djinn-th - - dl-fedora - - dmcc - - dmenu - - dmenu-pkill - - dmenu-pmount - - dmenu-search - - DMuCheck - - DnaProteinAlignment - - dnscache - - dnsrbl - - dnssd - - dobutok - - doc-review - - doccheck - - docidx - - docker - - docker-build-cacher - - dockercook - - dockerfile-creator - - docopt - - docrecords - - DocTest - - doctest-discover-configurator - - doctest-prop - - docusign-base - - docusign-base-minimal - - docusign-client - - docusign-example - - docvim - - doi - - DOM - - domain - - domain-core - - domain-optics - - domplate - - dot-linker - - dotfs - - doublify-toolkit - - dow - - download-media-content - - downloader - - dozenal - - dozens - - DP - - dph-base - - dph-examples - - dph-lifted-base - - dph-lifted-copy - - dph-lifted-vseg - - dph-prim-interface - - dph-prim-par - - dph-prim-seq - - dpkg - - DPM - - dpor - - dragen - - drawille - - drClickOn - - dresdner-verkehrsbetriebe - - DrHylo - - DrIFT - - DrIFT-cabalized - - drifter - - drifter-postgresql - - drifter-sqlite - - drmaa - - drone - - dropbox - - dropbox-sdk - - dropsolve - - ds-kanren - - DSA - - dsc - - DSH - - dsh-sql - - dsmc - - dsmc-tools - - dson - - dson-parsec - - DSTM - - dstring - - DTC - - dtd - - dtd-text - - dtw - - dualizer - - duet - - dumb-cas - - dump-core - - dunai-core - - Dung - - duplo - - dura - - Dust - - Dust-crypto - - Dust-tools - - Dust-tools-pcap - - dvault - - dvda - - dvdread - - dvi-processing - - dwarf - - dwarfadt - - dyckword - - dyepack - - dynamic-cabal - - dynamic-graphs - - dynamic-mvector - - dynamic-object - - dynamic-plot - - dynamic-pp - - DynamicTimeWarp - - dynamodb-simple - - dynloader - - dynobud - - DysFRP - - DysFRP-Cairo - - DysFRP-Craftwerk - - dywapitchtrack - - dzen-dhall - - dzen-utils - - each - - earclipper - - early - - easy-api - - easy-bitcoin - - easyjson - - easyplot - - easytensor - - easytensor-vulkan - - easytest - - ebeats - - ebnf-bff - - ec2-unikernel - - eccrypto - - eccrypto-ed25519-bindings - - ecma262 - - ecu - - eddie - - ede - - edenmodules - - edenskel - - edentv - - edge - - edges - - edis - - edit - - edit-lenses - - editable - - editline - - EditTimeReport - - effect-handlers - - effect-monad - - effect-stack - - effin - - egison - - egison-pattern-src - - egison-pattern-src-haskell-mode - - egison-pattern-src-th-mode - - egison-quote - - egison-tutorial - - ehaskell - - ehs - - eibd-client-simple - - eigen - - Eight-Ball-Pool-Hack-Cheats - - eio - - either-list-functions - - either-unwrap - - EitherT - - ejdb2-binding - - ekg-bosun - - ekg-carbon - - ekg-cloudwatch - - ekg-elastic - - ekg-elasticsearch - - ekg-log - - ekg-push - - ekg-rrd - - ekg-wai - - elerea-examples - - elevator - - elision - - elliptic-curve - - elm-street - - elm-websocket - - elsa - - elynx - - elynx-tree - - emacs-keys - - emacs-module - - email - - email-header - - email-postmark - - emailaddress - - emailparse - - embeddock - - embeddock-example - - embla - - embroidery - - emgm - - Emping - - Empty - - empty-monad - - enchant - - encoding - - encoding-io - - encryptable - - engine-io - - engine-io-growler - - engine-io-snap - - engine-io-wai - - engine-io-yesod - - entangle - - EntrezHTTP - - entwine - - enum-text - - enum-text-rio - - enum-utf8 - - EnumContainers - - enumerate - - enumerate-function - - enumerator - - enumerator-fd - - enumerator-tf - - enumfun - - EnumMap - - enummapmap - - env-extra - - env-parser - - envstatus - - epanet-haskell - - epass - - ephemeral - - epi-sim - - epic - - epoll - - eprocess - - epubname - - Eq - - EqualitySolver - - equational-reasoning-induction - - equeue - - erf-native - - erlang - - erlang-ffi - - eros - - eros-client - - eros-http - - error-codes - - error-context - - error-continuations - - error-list - - error-loc - - error-message - - error-util - - errors-ext - - ersaconcat - - ersatz - - ersatz-toysat - - ert - - escape-artist - - escoger - - esotericbot - - EsounD - - espial - - ess - - estimators - - EstProgress - - estreps - - Etage - - Etage-Graph - - EtaMOO - - eternal - - Eternal10Seconds - - eternity - - eternity-timestamped - - ether - - Etherbunny - - ethereum-analyzer - - ethereum-analyzer-cli - - ethereum-analyzer-webui - - ethereum-client-haskell - - ethereum-merkle-patricia-db - - ethereum-rlp - - euphoria - - eurofxref - - evdev - - evdev-streamly - - eve-cli - - event - - event-driven - - event-monad - - eventful-dynamodb - - eventful-postgresql - - eventful-sql-common - - eventful-sqlite - - eventlog2html - - eventloop - - EventSocket - - eventsource-geteventstore-store - - eventstore - - every-bit-counts - - ewe - - exact-cover - - exact-real-positional - - except-exceptions - - exception-monads-fd - - exceptional - - exceptionfree-readfile - - exchangerates - - execs - - executor - - exference - - exh - - exherbo-cabal - - exif - - exigo-schema - - exinst-deepseq - - exinst-hashable - - exists - - exitcode - - exp-extended - - expand - - expat-enumerator - - expiring-containers - - explain - - explicit-constraint-lens - - explicit-determinant - - explicit-iomodes - - explicit-iomodes-bytestring - - explicit-iomodes-text - - explicit-sharing - - explore - - exposed-containers - - expression-parser - - expressions - - expressions-z3 - - expresso - - extcore - - extemp - - extended-categories - - extensible-data - - extensible-effects-concurrent - - extensible-skeleton - - external-sort - - Extra - - extract-dependencies - - extractelf - - extralife - - ez-couch - - ez3 - - f-algebra-gen - - f-ree-hack-cheats-free-v-bucks-generator - - Facebook-Password-Hacker-Online-Latest-Version - - faceted - - factory - - Facts - - facts - - factual-api - - fadno - - fadno-braids - - fadno-xml - - failable-list - - failure-detector - - FailureT - - fake - - fake-type - - faktory - - falling-turnip - - fallingblocks - - family-tree - - fast-arithmetic - - fast-combinatorics - - fast-digits - - fast-nats - - fasta - - fastbayes - - fastedit - - fastirc - - fastly - - fastpbkdf2 - - FastPush - - fastsum - - FastxPipe - - fathead-util - - fault-tree - - fay-builder - - fay-hsx - - fay-simplejson - - fb-persistent - - fbmessenger-api - - fbrnch - - fca - - fcache - - fcd - - fcf-containers - - fcg - - fckeditor - - fclabels-monadlib - - fcm-client - - FComp - - fdo-trash - - feature-flipper - - feature-flipper-postgres - - fedora-img-dl - - fedora-packages - - feed-cli - - feed-collect - - feed-crawl - - feed-gipeda - - feed-translator - - feed2lj - - feed2twitter - - fei-base - - fei-cocoapi - - fei-dataiter - - fei-datasets - - fei-examples - - fei-modelzoo - - fei-nn - - feldspar-compiler - - feldspar-language - - fenfire - - FermatsLastMargin - - fernet - - FerryCore - - festung - - Feval - - fez-conf - - ffeed - - fficxx - - ffmpeg-tutorials - - ffunctor - - fgl-extras-decompositions - - fibon - - ficketed - - fields - - FieldTrip - - fieldwise - - fig - - file-collection - - file-command-qq - - file-embed-poly - - file-location - - filecache - - filediff - - FileManip - - FileManipCompat - - fileneglect - - filepath-crypto - - filepath-io-access - - FilePather - - filepather - - fileplow - - Files - - FileSystem - - filesystem-abstractions - - filesystem-conduit - - filesystem-enumerator - - filesystem-trees - - fillit - - Fin - - final-pretty-printer - - Finance-Quote-Yahoo - - Finance-Treasury - - find-clumpiness - - find-conduit - - find-source-files - - findhttp - - fingertree-psqueue - - fingertree-tf - - finitary-derive - - FiniteMap - - firefly-example - - first-and-last - - first-class-instances - - firstify - - FirstOrderTheory - - fishfood - - fit - - fits-parse - - fitsio - - fix-imports - - fix-parser-simple - - fix-symbols-gitit - - fixed-point - - fixed-point-vector - - fixed-point-vector-space - - fixed-precision - - fixed-storable-array - - fixed-timestep - - fixed-vector-binary - - fixed-vector-cborg - - fixed-vector-cereal - - fixed-width - - fixer - - fixfile - - fixhs - - fixie - - fizzbuzz - - fizzbuzz-as-a-service - - flac - - flac-picture - - flaccuraterip - - flamethrower - - flamingra - - flashblast - - flat-maybe - - flatbuffers - - flay - - flexible-time - - flexiwrap - - flexiwrap-smallcheck - - flickr - - flink-statefulfun - - Flippi - - flite - - float-binstring - - floating-bits - - flow-er - - flowdock - - flowdock-api - - flowdock-rest - - flower - - flowlocks-framework - - flowsim - - flp - - fltkhs - - fltkhs-fluid-examples - - fluent-logger - - fluffy-parser - - fluidsynth - - flux-monoid - - FM-SBLEX - - fmark - - FModExRaw - - fmt-for-rio - - fmt-terminal-colors - - fn-extra - - foldl-incremental - - foldl-statistics - - foldl-transduce - - foldl-transduce-attoparsec - - folds-common - - follow - - follower - - foma - - font-opengl-basic4x6 - - foo - - for-free - - forbidden-fruit - - fordo - - forecast-io - - foreign-var - - forest - - forest-fire - - Forestry - - forex2ledger - - forger - - ForkableT - - formal - - FormalGrammars - - format - - format-status - - formatn - - formattable - - forml - - formlets - - formlets-hsp - - formura - - ForSyDe - - forsyde-deep - - forth-hll - - Fortnite-Hack-Cheats-Free-V-Bucks-Generator - - fortran-src - - fortran-src-extras - - fortytwo - - foscam-directory - - foscam-filename - - foscam-sort - - Foster - - fp-ieee - - fpco-api - - fplll - - fpnla-examples - - FPretty - - fptest - - Fractaler - - fractals - - fraction - - frag - - frame-markdown - - Frames-beam - - Frames-dsv - - Frames-map-reduce - - franchise - - Frank - - fraxl - - freddy - - free-algebras - - free-category - - free-concurrent - - free-game - - free-http - - free-operational - - free-theorems - - free-theorems-counterexamples - - free-theorems-seq - - free-theorems-seq-webui - - free-theorems-webui - - free-v-bucks-generator-no-survey - - free-v-bucks-generator-ps4-no-survey - - freekick2 - - freelude - - freer-converse - - freer-effects - - freer-simple-catching - - freer-simple-http - - freer-simple-profiling - - freer-simple-random - - freer-simple-time - - freesect - - freesound - - freetype-simple - - FreeTypeGL - - freq - - fresh - - friday-devil - - friday-scale-dct - - friendly - - front - - frown - - frp-arduino - - frpnow - - frpnow-gloss - - frpnow-gtk - - frpnow-gtk3 - - frpnow-vty - - fs-events - - fsh-csv - - fsmActions - - fst - - fsutils - - fswait - - fswatch - - ft-generator - - ftdi - - FTGL-bytestring - - ftp-client - - ftp-client-conduit - - ftp-conduit - - ftphs - - FTPLine - - ftree - - ftshell - - full-sessions - - funbot - - funbot-client - - funbot-git-hook - - funcons-lambda-cbv-mp - - funcons-simple - - funcons-tools - - funcons-values - - function-combine - - function-instances-algebra - - functional-arrow - - functor - - functor-combinators - - functor-combo - - functor-friends - - functor-infix - - functor-products - - functor-utils - - functorm - - funflow - - funflow-nix - - Fungi - - funion - - funnyprint - - funpat - - funsat - - funspection - - fused-effects-exceptions - - fused-effects-resumable - - fused-effects-squeal - - fused-effects-th - - fusion - - futun - - future - - fuzzy-time-gen - - fuzzy-timings - - fwgl - - fwgl-glfw - - fwgl-javascript - - fxpak - - g-npm - - g2 - - g2q - - g4ip - - gact - - galois-fft - - galois-field - - game-probability - - gameclock - - gamgee - - Gamgine - - gamma - - Ganymede - - garepinoh - - gargoyle-postgresql-connect - - gargoyle-postgresql-nix - - gas - - gather - - gbu - - gc-monitoring-wai - - gconf - - gdax - - gdiff-ig - - gdiff-th - - GeBoP - - gedcom - - geek - - geek-server - - gegl - - gelatin - - gelatin-freetype2 - - gelatin-fruity - - gelatin-gl - - gelatin-sdl2 - - gelatin-shaders - - gemini-textboard - - gemstone - - gen-imports - - gen-passwd - - Genbank - - gencheck - - gender - - genders - - Gene-CluEDO - - general-prelude - - GeneralTicTacToe - - generator - - generators - - generic-accessors - - generic-binary - - generic-church - - generic-enum - - generic-enumeration - - generic-labels - - generic-lens-labels - - generic-lucid-scaffold - - generic-maybe - - generic-optics - - generic-override-aeson - - generic-pretty - - generic-server - - generic-storable - - generic-tree - - generic-trie - - generic-xml - - generic-xmlpickler - - generics-mrsop - - generics-mrsop-gdiff - - genericserialize - - genesis - - genesis-test - - genetics - - GenI - - geni-gui - - geni-util - - geniconvert - - geniplate - - geniserver - - genprog - - GenSmsPdu - - gentlemark - - GenussFold - - genvalidity-persistent - - geo-resolver - - GeocoderOpenCage - - geodetic - - geodetic-types - - geojson-types - - geolite-csv - - geom2d - - GeomPredicates-SSE - - geos - - Get - - getemx - - getflag - - GGg - - ggtsTC - - gh-labeler - - ghc-clippy-plugin - - ghc-core-smallstep - - ghc-datasize - - ghc-dump-core - - ghc-dump-tree - - ghc-dump-util - - ghc-dup - - ghc-events-analyze - - ghc-events-parallel - - ghc-generic-instances - - ghc-imported-from - - ghc-instances - - ghc-justdoit - - ghc-man-completion - - ghc-mod - - ghc-parmake - - ghc-pkg-autofix - - ghc-pkg-lib - - ghc-plugs-out - - ghc-proofs - - ghc-session - - ghc-simple - - ghc-srcspan-plugin - - ghc-syb - - ghc-syb-utils - - ghc-tags-core - - ghc-tags-plugin - - ghc-time-alloc-prof - - ghc-usage - - ghc-vis - - ghci-dap - - ghci-diagrams - - ghci-haskeline - - ghci-history-parser - - ghci-lib - - ghci-ng - - ghci-pretty - - ghcjs-dom-jsffi - - ghcjs-fetch - - ghcjs-hplay - - ghcjs-promise - - ghcjs-xhr - - ghclive - - ghcprofview - - ghcup - - ght - - gi-cairo-again - - gi-graphene - - gi-gsk - - gi-gstaudio - - gi-gstpbutils - - gi-gsttag - - gi-gtkosxapplication - - gi-gtksheet - - gi-handy - - gi-poppler - - gi-vips - - gi-wnck - - giak - - Gifcurry - - ginsu - - gipeda - - giphy-api - - GiST - - gist - - git - - git-all - - git-checklist - - git-config - - git-cuk - - git-date - - git-fmt - - git-gpush - - git-jump - - git-monitor - - git-object - - git-remote-ipfs - - git-repair - - git-sanity - - git-vogue - - gitdo - - github-backup - - github-data - - github-tools - - github-utils - - github-webhook-handler - - github-webhook-handler-snap - - githud - - gitignore - - gitlab-api - - gitlib - - gitlib-cmdline - - gitlib-cross - - gitlib-libgit2 - - gitlib-s3 - - gitlib-sample - - gitlib-test - - gitlib-utils - - gitson - - gitter - - givegif - - glade - - gladexml-accessor - - glapp - - glazier - - glazier-pipes - - glazier-react - - glazier-react-examples - - glazier-react-widget - - Gleam - - GLFW - - GLFW-b-demo - - GLFW-OGL - - GLFW-task - - gli - - glider-nlp - - GLMatrix - - glob-posix - - global - - global-config - - global-variables - - glome-hs - - GlomeTrace - - GlomeView - - gloss-banana - - gloss-devil - - gloss-examples - - gloss-export - - gloss-game - - gloss-sodium - - glpk-headers - - glpk-hs - - gltf-codec - - glue - - gmap - - gmndl - - gnome-desktop - - gnomevfs - - gnss-converters - - gnuidn - - goa - - goal-core - - goal-geometry - - goal-probability - - goal-simulation - - goatee - - goatee-gtk - - gochan - - godot-haskell - - gofer-prelude - - goldplate - - gooey - - google-cloud - - google-drive - - google-html5-slide - - google-mail-filters - - google-maps-geocoding - - google-oauth2 - - google-oauth2-easy - - google-oauth2-jwt - - google-search - - google-server-api - - google-static-maps - - google-translate - - GoogleCodeJam - - GoogleDirections - - googleplus - - googlepolyline - - GoogleSB - - GoogleTranslate - - gopherbot - - gopro-plus - - gore-and-ash - - gore-and-ash-actor - - gore-and-ash-async - - gore-and-ash-demo - - gore-and-ash-glfw - - gore-and-ash-lambdacube - - gore-and-ash-logging - - gore-and-ash-network - - gore-and-ash-sdl - - gore-and-ash-sync - - GotoT-transformers - - gpah - - GPipe - - GPipe-Collada - - GPipe-Core - - GPipe-Examples - - GPipe-GLFW - - GPipe-GLFW4 - - GPipe-TextureLoad - - gps - - gps2htmlReport - - GPX - - gpx-conduit - - grab - - grab-form - - graceful - - grafana - - graflog - - Grafos - - grakn - - grammar-combinators - - GrammarProducts - - grammatical-parsers - - grapefruit-examples - - grapefruit-frp - - grapefruit-records - - grapefruit-ui - - grapefruit-ui-gtk - - graph-core - - graph-matchings - - graph-rewriting - - graph-rewriting-cl - - graph-rewriting-gl - - graph-rewriting-lambdascope - - graph-rewriting-layout - - graph-rewriting-ski - - graph-rewriting-strategies - - graph-rewriting-trs - - graph-rewriting-ww - - graph-serialize - - graph-utils - - graph-visit - - Graph500 - - graphbuilder - - graphene - - GraphHammer - - GraphHammer-examples - - graphics-drawingcombinators - - graphics-formats-collada - - graphicsFormats - - graphicstools - - graphmod-plugin - - graphql - - graphql-api - - graphql-client - - graphql-utils - - graphql-w-persistent - - graphted - - graphtype - - graphula - - graphula-core - - graql - - grasp - - gray-code - - greencard - - greencard-lib - - greg-client - - gremlin-haskell - - Grempa - - grenade - - grid-proto - - gridbounds - - gridland - - grm - - groot - - gross - - GroteTrap - - groundhog-converters - - groundhog-mysql - - group-theory - - group-with - - grouped-list - - groups-generic - - growler - - GrowlNotify - - grpc-api-etcd - - grpc-etcd-client - - grpc-haskell - - grpc-haskell-core - - gruff - - gruff-examples - - gscholar-rss - - gsl-random - - gsl-random-fu - - gstorable - - gstreamer - - GTALib - - gtfs - - gtfs-realtime - - gtk-serialized-event - - gtk-toy - - gtk2hs-hello - - gtk2hs-rpn - - Gtk2hsGenerics - - gtk3-mac-integration - - gtkglext - - GtkGLTV - - gtkimageview - - gtkrsync - - gtksourceview2 - - gtksourceview3 - - GtkTV - - guarded-rewriting - - guess-combinator - - GuiHaskell - - GuiTV - - gulcii - - gw - - gyah-bin - - gym-http-api - - h-booru - - h-gpgme - - h-reversi - - h2048 - - h2c - - haar - - habit - - hablo - - hablog - - HABQT - - Hach - - hack-contrib - - hack-contrib-press - - hack-frontend-happstack - - hack-handler-cgi - - hack-handler-epoll - - hack-handler-evhttp - - hack-handler-fastcgi - - hack-handler-happstack - - hack-handler-hyena - - hack-handler-kibro - - hack-handler-simpleserver - - hack-middleware-cleanpath - - hack-middleware-clientsession - - hack-middleware-jsonp - - hack2-handler-happstack-server - - hack2-handler-mongrel2-http - - hack2-handler-snap-server - - hack2-handler-warp - - hackage-api - - hackage-diff - - hackage-mirror - - hackage-processing - - hackage-proxy - - hackage-repo-tool - - hackage-server - - hackage-whatsnew - - hackage2hwn - - hackage2twitter - - hackager - - hackernews - - HackMail - - hackmanager - - hackport - - hactor - - hactors - - haddock - - haddock-api - - haddock-cheatsheet - - haddock-leksah - - haddock-test - - haddocset - - hadoop-formats - - hadoop-rpc - - hadoop-tools - - hafar - - haggis - - Haggressive - - hahp - - haiji - - hailgun-send - - hails-bin - - hairy - - hakaru - - hakismet - - hakka - - hako - - hakyll - - hakyll-agda - - hakyll-alectryon - - hakyll-blaze-templates - - hakyll-contrib - - hakyll-contrib-csv - - hakyll-contrib-elm - - hakyll-contrib-hyphenation - - hakyll-contrib-links - - hakyll-dhall - - hakyll-dir-list - - hakyll-elm - - hakyll-favicon - - hakyll-filestore - - hakyll-images - - hakyll-ogmarkup - - hakyll-process - - hakyll-R - - hakyll-sass - - hakyll-series - - hakyll-shakespeare - - hakyll-shortcode - - hakyll-shortcut-links - - hakyll-typescript - - hal - - halberd - - HaLeX - - halfs - - halipeto - - halive - - hall-symbols - - halma - - halma-gui - - halma-telegram-bot - - halves - - ham - - HaMinitel - - hampp - - hamsql - - hamtmap - - hamusic - - hanabi-dealer - - handa-gdata - - handle-like - - HandlerSocketClient - - handsy - - Hangman - - hannahci - - hans - - hans-pcap - - hanspell - - haphviz - - happindicator - - happindicator3 - - happlets - - happlets-lib-gtk - - happraise - - HAppS-Data - - happs-hsp - - happs-hsp-template - - HAppS-IxSet - - HAppS-Server - - HAppS-State - - happs-tutorial - - HAppS-Util - - happstack - - happstack-auth - - happstack-authenticate - - happstack-contrib - - happstack-data - - happstack-dlg - - happstack-facebook - - happstack-fay - - happstack-fay-ajax - - happstack-foundation - - happstack-hamlet - - happstack-heist - - happstack-helpers - - happstack-hstringtemplate - - happstack-ixset - - happstack-jmacro - - happstack-lite - - happstack-monad-peel - - happstack-plugins - - happstack-server-tls-cryptonite - - happstack-state - - happstack-util - - happstack-yui - - happy-hour - - happybara - - happybara-webkit - - happybara-webkit-server - - HappyTree - - hapstone - - HaPy - - haquery - - haquil - - harchive - - hArduino - - hardware-edsl - - HaRe - - harg - - hark - - harmony - - HarmTrace - - haroonga - - haroonga-httpd - - harpy - - harvest-api - - has - - has-th - - hasbolt - - hasbolt-extras - - HasCacBDD - - hascard - - hascas - - Haschoo - - HasGP - - hash - - hashable-extras - - hashable-generics - - hashable-orphans - - hashabler - - hashed-storage - - Hashell - - hashflare - - hashring - - hashtables-plus - - hasim - - hask - - hask-home - - haskarrow - - haskbot-core - - haskdeep - - haskeem - - haskeline-class - - haskelisp - - haskell-abci - - haskell-aliyun - - haskell-awk - - haskell-bitmex-client - - haskell-bitmex-rest - - haskell-brainfuck - - haskell-ci - - haskell-cnc - - haskell-coffee - - haskell-compression - - haskell-conll - - haskell-course-preludes - - haskell-debug-adapter - - haskell-disque - - haskell-docs - - haskell-eigen-util - - haskell-formatter - - haskell-ftp - - haskell-generate - - haskell-go-checkers - - haskell-holes-th - - haskell-igraph - - haskell-in-space - - haskell-kubernetes - - haskell-lsp-client - - haskell-ml - - haskell-mpfr - - haskell-mpi - - haskell-names - - haskell-neo4j-client - - haskell-openflow - - haskell-overridez - - haskell-packages - - haskell-pdf-presenter - - haskell-platform-test - - haskell-player - - haskell-plot - - haskell-postal - - haskell-read-editor - - haskell-reflect - - haskell-rules - - haskell-spacegoo - - haskell-src-exts-observe - - haskell-src-exts-prisms - - haskell-src-exts-qq - - haskell-src-exts-sc - - haskell-src-match - - haskell-src-meta-mwotton - - haskell-stack-trace-plugin - - haskell-token-utils - - haskell-tools-ast - - haskell-tools-ast-fromghc - - haskell-tools-ast-gen - - haskell-tools-ast-trf - - haskell-tools-backend-ghc - - haskell-tools-builtin-refactorings - - haskell-tools-cli - - haskell-tools-daemon - - haskell-tools-debug - - haskell-tools-demo - - haskell-tools-experimental-refactorings - - haskell-tools-prettyprint - - haskell-tools-refactor - - haskell-tools-rewrite - - haskell-tor - - haskell-type-exts - - haskell-typescript - - haskell-tyrant - - haskell2010 - - haskell2020 - - haskell98 - - haskell98libraries - - HaskellAnalysisProgram - - haskelldb - - haskelldb-connect-hdbc - - haskelldb-connect-hdbc-catchio-mtl - - haskelldb-connect-hdbc-catchio-tf - - haskelldb-connect-hdbc-catchio-transformers - - haskelldb-connect-hdbc-lifted - - haskelldb-dynamic - - haskelldb-flat - - haskelldb-hdbc - - haskelldb-hdbc-mysql - - haskelldb-hdbc-odbc - - haskelldb-hdbc-postgresql - - haskelldb-hdbc-sqlite3 - - haskelldb-hsql - - haskelldb-hsql-mysql - - haskelldb-hsql-odbc - - haskelldb-hsql-postgresql - - haskelldb-hsql-sqlite3 - - haskelldb-th - - haskelldb-wx - - haskellish - - HaskellLM - - HaskellNet - - HaskellNet-SSL - - HaskellNN - - Haskelloids - - haskellscrabble - - haskellscript - - HaskellTorrent - - HaskellTutorials - - haskelm - - haskelzinc - - haskeme - - haskey - - haskey-mtl - - haskgame - - haskheap - - haskhol-core - - haskmon - - haskoin - - haskoin-bitcoind - - haskoin-core - - haskoin-crypto - - haskoin-node - - haskoin-protocol - - haskoin-script - - haskoin-store - - haskoin-store-data - - haskoin-util - - haskoin-wallet - - haskoon - - haskoon-httpspec - - haskoon-salvia - - haskore - - haskore-realtime - - haskore-supercollider - - haskore-synthesizer - - HaskRel - - hasktorch - - hasktorch-codegen - - hasktorch-ffi-th - - hasktorch-ffi-thc - - hasktorch-indef - - hasktorch-signatures - - hasktorch-signatures-partial - - hasktorch-signatures-support - - hasktorch-zoo - - haskus-binary - - haskus-system-build - - haskus-utils - - haskus-utils-compat - - haskus-utils-data - - haskus-utils-types - - haskus-utils-variant - - haskus-web - - haskyapi - - haslo - - hasloGUI - - hasmin - - hasparql-client - - hasql-backend - - hasql-class - - hasql-cursor-query - - hasql-cursor-transaction - - hasql-dynamic-statements - - hasql-generic - - hasql-postgres - - hasql-postgres-options - - hasql-queue - - hasql-simple - - hasql-th - - hasql-url - - hastache - - hastache-aeson - - haste - - haste-app - - haste-lib - - haste-markup - - haste-prim - - Hate - - hatex-guide - - HaTeX-meta - - HaTeX-qq - - hats - - hatt - - haven - - haverer - - HaVSA - - hawitter - - Hawk - - hax - - haxl-amazonka - - haxl-facebook - - haxparse - - haxr-th - - haxy - - hayland - - Hayoo - - hayoo-cli - - hback - - hbayes - - hbb - - hbcd - - hBDD-CMUBDD - - hBDD-CUDD - - hbeanstalk - - hbeat - - hbf - - hblas - - hblock - - hburg - - hcad - - HCard - - hcc - - hcg-minus - - hcg-minus-cairo - - hcheat - - hcheckers - - hchesslib - - HCL - - hcltest - - hCM - - hcoap - - hcom - - hcount - - hcron - - hCsound - - hcube - - hdaemonize-buildfix - - hdbc-aeson - - HDBC-mysql - - HDBC-postgresql-hstore - - hdbc-postgresql-hstore - - hdbi - - hdbi-conduit - - hdbi-postgresql - - hdbi-sqlite - - hdbi-tests - - hdevtools - - hdf - - hDFA - - hdiff - - hdigest - - hdirect - - hdis86 - - hdiscount - - hdm - - hdo - - hdocs - - hdph - - hdph-closure - - hdr-histogram - - HDRUtils - - headergen - - heap-console - - heapsort - - heart-app - - heart-core - - heartbeat-streams - - heatitup - - heatitup-complete - - heavy-log-shortcuts - - heavy-logger - - heavy-logger-amazon - - heavy-logger-instances - - hebrew-time - - hecc - - heckle - - hedgehog-checkers - - hedgehog-checkers-lens - - hedgehog-fakedata - - hedgehog-gen-json - - hedgehog-generic - - hedgehog-golden - - hedgehog-servant - - Hedi - - hedis-config - - hedis-namespace - - hedis-pile - - hedis-simple - - hedis-tags - - hedn-functor - - hedra - - heidi - - hein - - heist-aeson - - heist-async - - helics - - helics-wai - - helisp - - helium - - helix - - hell - - hellage - - hellnet - - help-esb - - hemkay - - hemokit - - hen - - henet - - hepevt - - her-lexer - - her-lexer-parsec - - HERA - - herbalizer - - HerbiePlugin - - heredocs - - Hermes - - hermit - - hermit-syb - - herms - - herringbone - - herringbone-embed - - herringbone-wai - - hesh - - hesql - - hetero-dict - - heterogeneous-list-literals - - heterolist - - hetris - - heukarya - - hevm - - hevolisa - - hevolisa-dph - - hex-text - - HExcel - - hexchat - - hexif - - hexmino - - hexml-lens - - hexpat-iteratee - - hexpat-pickle-generic - - hexpr - - hexpress - - hexquote - - hexstring - - hext - - hextream - - heyefi - - heyting-algebras - - hF2 - - hfann - - hfd - - hfiar - - HFitUI - - hfmt - - hfoil - - hfov - - hfractal - - HFrequencyQueue - - hfusion - - hg-buildpackage - - hgalib - - hgdbmi - - HGE2D - - hgearman - - hGelf - - hgen - - hgeometric - - hgeometry-ipe - - hgeometry-svg - - hgeos - - hgettext - - hgis - - hgithub - - hgmp - - hgom - - hgopher - - HGraphStorage - - hgrep - - hgrib - - hharp - - HHDL - - hhp - - hhwloc - - hi - - hi3status - - hiccup - - hichi - - hid-examples - - hidden-char - - hie-core - - hieraclus - - hierarchical-exceptions - - hierarchical-spectral-clustering - - hierarchy - - hiernotify - - Hieroglyph - - higgledy - - HiggsSet - - higherorder - - highjson - - highjson-swagger - - highjson-th - - highlight-versions - - highWaterMark - - himg - - himpy - - hindent - - hindley-milner - - hinduce-classifier - - hinduce-classifier-decisiontree - - hinduce-examples - - hinquire - - hinstaller - - hint-server - - hinter - - hinterface - - hinvaders - - hinze-streams - - hip - - hipbot - - hipchat-hs - - hipe - - Hipmunk-Utils - - hipsql-api - - hipsql-client - - hipsql-server - - hircules - - hirt - - Hish - - hissmetrics - - hist-pl - - hist-pl-dawg - - hist-pl-fusion - - hist-pl-lexicon - - hist-pl-lmf - - hist-pl-types - - historian - - hit - - hit-graph - - hit-on - - HJavaScript - - hjcase - - hjs - - HJScript - - hjson-query - - hjsonpointer - - hjsonschema - - hjugement-cli - - HJVM - - hkd-delta - - hkd-lens - - hkt - - hlbfgsb - - hlcm - - HLearn-algebra - - HLearn-approximation - - HLearn-classification - - HLearn-datastructures - - HLearn-distributions - - hledger-api - - hledger-chart - - hledger-irr - - hledger-vty - - hlibBladeRF - - hlibev - - hlibfam - - HList - - hlivy - - HLogger - - hlogger - - hlongurl - - hlrdb - - hlrdb-core - - hls - - hls-exactprint-utils - - hlwm - - hly - - hmark - - hmarkup - - hmatrix-banded - - hmatrix-mmap - - hmatrix-nipals - - hmatrix-sparse - - hmatrix-static - - hmatrix-sundials - - hmatrix-svdlibc - - hmatrix-syntax - - hmatrix-tests - - hmeap - - hmeap-utils - - hmenu - - hmep - - hmk - - HMM - - hmm - - hmm-hmatrix - - hmm-lapack - - hMollom - - hmp3 - - Hmpf - - hmt - - hmt-diagrams - - hmumps - - hnetcdf - - HNM - - hnormalise - - ho-rewriting - - hoauth - - hob - - hobbes - - hobbits - - hocilib - - hocker - - hodatime - - HODE - - hoe - - Hoed - - hOff-display - - hog - - hogg - - hoggl - - hogre - - hogre-examples - - hois - - hol - - hold-em - - hole - - holmes - - Holumbus-Searchengine - - holy-project - - homeomorphic - - hommage - - homoiconic - - homplexity - - HongoDB - - honi - - hoobuddy - - hood - - hood-off - - hood2 - - hoodie - - hoodle - - hoodle-builder - - hoodle-core - - hoodle-extra - - hoodle-parser - - hoodle-publish - - hoodle-render - - hoodle-types - - hoogle-index - - hooks-dir - - hoop - - hoopl - - hoovie - - hopencc - - hopencl - - HOpenCV - - hopfield - - hops - - hoq - - horizon - - horname - - hosc-json - - hosts-server - - hothasktags - - hotswap - - hourglass-fuzzy-parsing - - houseman - - hp2any-core - - hp2any-graph - - hp2any-manager - - hpack-convert - - hpack-dhall - - hpaco - - hpaco-lib - - hpage - - hpapi - - hpaste - - hpasteit - - HPath - - hpc-coveralls - - hpc-tracer - - hPDB - - hPDB-examples - - HPDF - - hpg - - HPi - - hpio - - hplaylist - - HPlot - - hpodder - - HPong - - hpqtypes - - hpqtypes-extras - - hprotoc - - hprotoc-fork - - hps - - hps-cairo - - hps-kmeans - - hPushover - - hpygments - - hpylos - - hpyrg - - hpython - - hquantlib - - hquantlib-time - - hR - - hranker - - HRay - - hreader - - hreader-lens - - hreq-client - - hreq-conduit - - hreq-core - - Hricket - - hricket - - hriemann - - HROOT - - HROOT-core - - HROOT-graf - - HROOT-hist - - HROOT-io - - HROOT-math - - HROOT-tree - - hs-blake2 - - hs-brotli - - hs-carbon-examples - - hs-cdb - - hs-conllu - - hs-di - - hs-dotnet - - hs-excelx - - hs-ffmpeg - - hs-fltk - - hs-gen-iface - - hs-gizapp - - hs-inspector - - hs-java - - hs-json-rpc - - hs-logo - - hs-nombre-generator - - hs-pattrans - - hs-pgms - - hs-pkg-config - - hs-pkpass - - hs-re - - hs-rqlite - - hs-rs-notify - - hs-scrape - - hs-snowtify - - hs-speedscope - - hs-tags - - hs-twitter - - hs-twitterarchiver - - hs-vcard - - hs-watchman - - hs2bf - - Hs2lib - - hs2ps - - hsaml2 - - hsautogui - - hsay - - hsbackup - - hsbc - - hsbencher - - hsbencher-codespeed - - hsbencher-fusion - - hsc3 - - hsc3-auditor - - hsc3-cairo - - hsc3-data - - hsc3-db - - hsc3-dot - - hsc3-forth - - hsc3-graphs - - hsc3-lang - - hsc3-lisp - - hsc3-plot - - hsc3-process - - hsc3-rec - - hsc3-rw - - hsc3-server - - hsc3-sf - - hsc3-sf-hsndfile - - hsc3-unsafe - - hsc3-utils - - hscaffold - - hscamwire - - hscassandra - - hscd - - hsclock - - hscope - - hScraper - - hscuid - - hsdev - - hsdif - - hsdip - - hsdns-cache - - Hsed - - hsendxmpp - - hsenv - - HSet - - hset - - hsfacter - - hsfcsh - - HSFFIG - - hsfilt - - hsforce - - HSGEP - - hsgnutls - - hsgnutls-yj - - hsgsom - - HsHaruPDF - - HSHHelpers - - HsHTSLib - - HsHyperEstraier - - hsI2C - - hSimpleDB - - hsimport - - hsinspect - - hsinspect-lsp - - HsJudy - - hskeleton - - hslackbuilder - - hslibsvm - - hslinks - - hslogger-reader - - hslogger-template - - hslogstash - - hsluv-haskell - - hsmagick - - HSmarty - - hsmodetweaks - - Hsmtlib - - hsmtpclient - - hsnock - - hsns - - hsnsq - - hsntp - - hsoptions - - HSoundFile - - hsoz - - hsp-cgi - - hsparql - - HsParrot - - hspear - - hspec-expectations-json - - hspec-expectations-match - - hspec-expectations-pretty - - hspec-experimental - - hspec-hashable - - hspec-jenkins - - hspec-monad-control - - hspec-pg-transact - - hspec-setup - - hspec-shouldbe - - hspec-snap - - hspec-structured-formatter - - hspec-test-sandbox - - hspec-webdriver - - hspec2 - - hspecVariant - - HsPerl5 - - hspkcs11 - - hspread - - hspresent - - hsprocess - - hsql - - hsql-mysql - - hsql-odbc - - hsql-postgresql - - hsql-sqlite3 - - hsreadability - - hsrelp - - hsseccomp - - hsSqlite3 - - hssqlppp - - hssqlppp-th - - HsSVN - - hstar - - hstats - - hstatsd - - hstest - - hstidy - - hstox - - hstradeking - - HStringTemplateHelpers - - hstyle - - hstzaar - - hsubconvert - - hsudoku - - HsWebots - - hswip - - hsx - - hsx-jmacro - - hsx-xhtml - - hsXenCtrl - - hsyscall - - hsyslog-tcp - - hszephyr - - HTab - - htags - - hTalos - - htar - - htdp-image - - hTensor - - htestu - - HTicTacToe - - htiled - - htlset - - html-charset - - html-kure - - html-rules - - html-tokenizer - - hts - - htsn - - htsn-import - - htssets - - http-attoparsec - - http-client-auth - - http-client-lens - - http-client-request-modifiers - - http-client-session - - http-client-streams - - http-client-websockets - - http-conduit-browser - - http-conduit-downloader - - http-directory - - http-dispatch - - http-enumerator - - http-grammar - - http-io-streams - - http-kinder - - http-listen - - http-monad - - http-pony - - http-pony-serve-wai - - http-proxy - - http-querystring - - http-response-decoder - - http-rfc7807 - - http-server - - http-shed - - http-wget - - http2-client - - http2-client-exe - - http2-client-grpc - - http2-grpc-proto-lens - - http2-grpc-proto3-wire - - https-everywhere-rules - - https-everywhere-rules-raw - - httpspec - - htune - - htvm - - htzaar - - huck - - HueAPI - - huff - - huffman - - hugs2yc - - hulk - - HulkImport - - human-parse - - human-text - - humble-prelude - - hums - - hunch - - HUnit-Diff - - hunit-gui - - hunit-rematch - - hunp - - hunspell-hs - - hunt-searchengine - - hunt-server - - hup - - hurdle - - hurl - - hurriyet - - husk-scheme - - husk-scheme-libs - - husky - - hutton - - huttons-razor - - huzzy - - hVOIDP - - hw-all - - hw-aws-sqs-conduit - - hw-ci-assist - - hw-dsv - - hw-json - - hw-json-lens - - hw-json-simd - - hw-json-simple-cursor - - hw-json-standard-cursor - - hw-kafka-avro - - hw-prim-bits - - hw-simd - - hw-simd-cli - - hw-uri - - hwall-auth-iitk - - hweblib - - hwhile - - hworker - - hworker-ses - - hwormhole - - hws - - hwsl2 - - hwsl2-bytevector - - hwsl2-reducers - - hx - - HXMPP - - hxmppc - - hxournal - - HXQ - - hxt-pickle-utils - - hxthelper - - hxweb - - hyakko - - hybrid - - hydra-hs - - hydra-print - - Hydrogen - - hydrogen - - hydrogen-cli - - hydrogen-cli-args - - hydrogen-data - - hydrogen-multimap - - hydrogen-parsing - - hydrogen-prelude - - hydrogen-prelude-parsec - - hydrogen-syntax - - hydrogen-util - - hyena - - hylide - - hylolib - - hylotab - - hyloutils - - hyperdrive - - hyperfunctions - - hyperion - - hyperloglogplus - - hyperpublic - - hypher - - hzk - - hzulip - - i18n - - I1M - - i3ipc - - iap-verifier - - ib-api - - iban - - ical - - ice40-prim - - icepeak - - IcoGrid - - iconv-typed - - ide-backend - - ide-backend-common - - ide-backend-server - - ideas - - ideas-math - - ideas-math-types - - ideas-statistics - - idempotent - - identifiers - - idiii - - idna2008 - - IDynamic - - ieee-utils - - iexcloud - - ifcxt - - IFS - - ig - - ige - - ige-mac-integration - - ignore - - igraph - - ihaskell-parsec - - ihaskell-rlangqq - - ihaskell-widgets - - ihttp - - illuminate - - imagepaste - - imap - - imapget - - imbib - - imgur - - imgurder - - imj-animation - - imj-base - - imj-game-hamazed - - imj-measure-stdout - - imj-prelude - - imm - - immortal-worker - - imparse - - imperative-edsl - - imperative-edsl-vhdl - - ImperativeHaskell - - impl - - implicit-logging - - implicit-params - - importify - - imports - - impossible - - imprint - - improve - - INblobs - - inch - - inchworm - - incremental-computing - - incremental-maps - - increments - - indentation - - indentation-core - - indentation-parsec - - indentation-trifecta - - indents - - index-core - - indexation - - IndexedList - - indextype - - indices - - indieweb-algorithms - - inf-interval - - infer-upstream - - infernal - - infernu - - infinity - - infix - - InfixApplicative - - inflist - - informative - - ini-qq - - inilist - - initialize - - inject-function - - inline-asm - - inline-java - - inserts - - inspector-wrecker - - instana-haskell-trace-sdk - - instance-map - - instant-aeson - - instant-bytes - - instant-deepseq - - instant-generics - - instant-hashable - - instant-zipper - - instapaper-sender - - instinct - - int-multimap - - intcode - - integer-pure - - integreat - - intel-aes - - intensional-datatys - - interlude-l - - internetmarke - - intero - - interpol - - interpolatedstring-qq - - interpolatedstring-qq-mwotton - - interpolatedstring-qq2 - - interruptible - - interval - - IntFormats - - intricacy - - intro-prelude - - introduction - - introduction-test - - intset - - invert - - invertible-hlist - - invertible-syntax - - io-capture - - io-choice - - io-reactive - - ioctl - - ion - - IOR - - IORefCAS - - iostring - - iothread - - iotransaction - - ip - - ip-quoter - - ip2location - - ip2proxy - - ipatch - - ipc - - ipfs - - ipfs-api - - ipld-cid - - ipopt-hs - - ipprint - - iptables-helpers - - iptadmin - - IPv6DB - - Irc - - irc-dcc - - irc-fun-bot - - irc-fun-client - - irc-fun-color - - irc-fun-messages - - irc-fun-types - - iri - - iridium - - iron-mq - - ironforge - - irt - - isdicom - - isevaluated - - ismtp - - IsNull - - iso8601-duration - - isobmff - - isobmff-builder - - isohunt - - isotope - - it-has - - itcli - - itemfield - - iter-stats - - iteratee - - iteratee-compress - - iteratee-mtl - - iteratee-parsec - - iteratee-stm - - iterIO - - iterio-server - - iterm-show - - iterm-show-diagrams - - iterm-show-JuicyPixels - - ivor - - ivory - - ivory-avr-atmega328p-registers - - ivory-backend-c - - ivory-bitdata - - ivory-eval - - ivory-examples - - ivory-hw - - ivory-opts - - ivory-quickcheck - - ivory-serialize - - ivory-stdlib - - ivy-web - - ixdopp - - ixmonad - - ixshader - - iyql - - j - - j2hs - - jack-bindings - - JackMiniMix - - jackminimix - - jacobi-roots - - jaeger-flamegraph - - jail - - jalla - - jarfind - - jarify - - jason - - java-bridge - - java-bridge-extras - - java-character - - java-reflect - - javascript-bridge - - Javasf - - javasf - - Javav - - javav - - jbi - - jcdecaux-vls - - Jdh - - jdi - - jenga - - jenkinsPlugins2nix - - jespresso - - jinquantities - - jmacro - - jmacro-rpc - - jmacro-rpc-happstack - - jmacro-rpc-snap - - jml-web-service - - jmonkey - - jni - - jobqueue - - jobs-ui - - join - - join-api - - joinlist - - jonathanscard - - jot - - jpeg - - js-good-parts - - jsaddle-hello - - jsaddle-wkwebview - - JsContracts - - jsmw - - json-alt - - json-assertions - - json-ast-json-encoder - - json-ast-quickcheck - - json-autotype - - json-b - - json-builder - - JSON-Combinator - - JSON-Combinator-Examples - - json-encoder - - json-enumerator - - json-extra - - json-fu - - json-incremental-decoder - - json-litobj - - json-pointer-hasql - - json-pointy - - json-python - - json-query - - json-rpc-client - - json-schema - - json-sop - - json-syntax - - json-to-haskell - - json-togo - - json-tokens - - json-tools - - json-tracer - - json2 - - json2-hdbc - - JSONb - - jsonextfilter - - JsonGrammar - - jsonifier - - jsonnet - - jsonresume - - jsonrpc-conduit - - jsons-to-schema - - jsonschema-gen - - jsonsql - - jsontsv - - jsonxlsx - - jspath - - juandelacosa - - judge - - judy - - JuicyPixels-blp - - JuicyPixels-canvas - - JunkDB - - JunkDB-driver-gdbm - - JunkDB-driver-hashtables - - jupyter - - JuPyTer-notebook - - JustParse - - jvm - - jvm-batching - - jvm-binary - - jvm-parser - - jvm-streaming - - JYU-Utils - - kademlia - - kafka-client - - kafka-client-sync - - kafka-device - - kafka-device-glut - - kafka-device-joystick - - kafka-device-leap - - kafka-device-spacenav - - kafka-device-vrpn - - kaleidoscope - - Kalman - - kalman - - kangaroo - - kansas-lava - - kansas-lava-cores - - kansas-lava-papilio - - kansas-lava-shake - - karakuri - - karps - - katip-elasticsearch - - katip-kafka - - katip-raven - - katip-rollbar - - katip-scalyr-scribe - - katip-syslog - - katt - - katydid - - kawaii - - kawhi - - kd-tree - - kdesrc-build-extra - - keccak - - keera-hails-i18n - - keera-hails-mvc-environment-gtk - - keera-hails-mvc-model-lightmodel - - keera-hails-mvc-model-protectedmodel - - keera-hails-mvc-solutions-gtk - - keera-hails-reactive-cbmvar - - keera-hails-reactive-fs - - keera-hails-reactive-gtk - - keera-hails-reactive-htmldom - - keera-hails-reactive-network - - keera-hails-reactive-polling - - keera-hails-reactive-wx - - keera-hails-reactive-yampa - - keera-hails-reactivelenses - - keera-hails-reactivevalues - - kempe - - kerry - - Ketchup - - keter - - kevin - - keyed - - keyring - - keysafe - - keystore - - keyvaluehash - - keyword-args - - khph - - kicad-data - - kickass-torrents-dump-parser - - kickchan - - kif-parser - - kit - - kleene - - kmeans-par - - kmeans-vector - - kmonad - - kmp-dfa - - knead - - knead-arithmetic - - knit-haskell - - knots - - koellner-phonetic - - kontra-config - - korfu - - kparams - - kqueue - - kraken - - krapsh - - Kriens - - krpc - - ks-test - - KSP - - ktx - - ktx-codec - - kubernetes-client - - kubernetes-client-core - - kuifje - - kure - - kure-your-boilerplate - - kurita - - KyotoCabinet - - l-bfgs-b - - L-seed - - labeled-graph - - laborantin-hs - - labsat - - labyrinth - - labyrinth-server - - lackey - - lagrangian - - laika - - lambda-bridge - - lambda-calculator - - lambda-canvas - - lambda-devs - - lambda-options - - lambda-toolbox - - lambda2js - - lambdaBase - - lambdabot-utils - - lambdabot-zulip - - lambdacms-core - - lambdacms-media - - lambdacube - - lambdacube-bullet - - lambdacube-compiler - - lambdacube-core - - lambdacube-edsl - - lambdacube-engine - - lambdacube-examples - - lambdacube-gl - - lambdacube-ir - - lambdacube-samples - - LambdaDesigner - - lambdaFeed - - LambdaHack - - LambdaINet - - Lambdajudge - - lambdaLit - - LambdaNet - - LambdaPrettyQuote - - LambdaShell - - lambdatex - - lambdatwit - - Lambdaya - - lambdaya-bus - - lambdiff - - lame - - lame-tester - - lang - - language-asn - - language-boogie - - language-c-comments - - language-c-inline - - language-conf - - language-csharp - - language-dart - - language-dickinson - - language-dockerfile - - language-eiffel - - language-elm - - language-fortran - - language-gcl - - language-go - - language-guess - - language-hcl - - language-java-classfile - - language-kort - - language-lua-qq - - language-lua2 - - language-mixal - - language-Modula2 - - language-ninja - - language-oberon - - language-objc - - language-ocaml - - language-openscad - - language-pig - - language-puppet - - language-python-colour - - language-qux - - language-rust - - language-sh - - language-spelling - - language-sqlite - - language-sygus - - language-thrift - - language-tl - - language-typescript - - language-vhdl - - language-webidl - - lapack - - lapack-carray - - lapack-comfort-array - - lapack-ffi - - large-hashable - - Lastik - - lat - - latest-npm-version - - latex-formulae-hakyll - - latex-formulae-image - - latex-formulae-pandoc - - latex-svg-hakyll - - latex-svg-image - - latex-svg-pandoc - - LATS - - launchdarkly-server-sdk - - launchpad-control - - lawless-concurrent-machines - - layered-state - - layers - - layers-game - - layout - - layout-bootstrap - - layout-rules - - layouting - - lazy-hash - - lazy-hash-cache - - lazy-io-streams - - lazy-priority-queue - - lazy-search - - lazyarray - - lazyboy - - lazyset - - LazyVault - - ld-intervals - - lda - - ldapply - - LDAPv3 - - ldif - - leaf - - leaky - - lean - - leanpub-wreq - - leapseconds - - learn - - learn-physics-examples - - Learning - - leb128 - - leetify - - legion - - legion-discovery - - legion-discovery-client - - legion-extra - - leksah-server - - lendingclub - - lens-filesystem - - lens-labels - - lens-prelude - - lens-process - - lens-simple - - lens-text-encoding - - lens-th-rewrite - - lens-time - - lens-toml-parser - - lens-tutorial - - lens-typelevel - - lens-utils - - lensref - - lentil - - level-monad - - Level0 - - levmar - - levmar-chart - - lex-applicative - - lfst - - lgtk - - lha - - lhae - - lhc - - lhe - - lhs2TeX-hl - - lhslatex - - libarchive - - LibClang - - libconfig - - libcspm - - libexpect - - libfuse3 - - libGenI - - libhbb - - libinfluxdb - - libjenkins - - libjwt-typed - - liblastfm - - liblawless - - liblinear-enumerator - - libltdl - - libmolude - - libnix - - liboath-hs - - liboleg - - libpafe - - libpq - - libraft - - librandomorg - - librato - - libssh2 - - libssh2-conduit - - libsystemd-daemon - - libtagc - - libxls - - libxml-enumerator - - libxslt - - lie - - life-sync - - lifetimes - - lifted-base-tf - - lifted-protolude - - lifter - - ligature - - lightning-haskell - - lightstep-haskell - - lighttpd-conf - - lighttpd-conf-qq - - lilypond - - Limit - - limp-cbc - - linda - - linden - - line-bot-sdk - - line-drawing - - linear-algebra-cblas - - linear-base - - linear-circuit - - linear-code - - linear-maps - - linear-opengl - - linear-vect - - linearmap-category - - linearscan - - linearscan-hoopl - - LinearSplit - - lines-of-action - - LinkChecker - - linkchk - - linkcore - - linked-list-with-iterator - - linkedhashmap - - linklater - - linnet - - linnet-aeson - - linnet-conduit - - linode - - linode-v4 - - linux-blkid - - linux-cgroup - - linux-kmod - - linux-perf - - linux-ptrace - - linx-gateway - - lio-eci11 - - lio-simple - - lion - - lipsum-gen - - liquid - - liquid-base - - liquid-bytestring - - liquid-containers - - liquid-ghc-prim - - liquid-parallel - - liquid-platform - - liquid-prelude - - liquid-vector - - liquidhaskell - - liquidhaskell-cabal - - Liquorice - - list-fusion-probe - - list-mux - - list-prompt - - list-remote-forwards - - list-t-attoparsec - - list-t-html-parser - - list-t-http-client - - list-t-text - - list-witnesses - - list-zip-def - - list-zipper - - listenbrainz-client - - listlike-instances - - ListT - - liszt - - lit - - literals - - LiterateMarkdown - - little-logger - - live-sequencer - - ll-picosat - - llsd - - llvm - - llvm-analysis - - llvm-base - - llvm-base-types - - llvm-base-util - - llvm-data-interop - - llvm-dsl - - llvm-extension - - llvm-extra - - llvm-ffi - - llvm-ffi-tools - - llvm-general - - llvm-general-pure - - llvm-general-quote - - llvm-ht - - llvm-pkg-config - - llvm-pretty - - llvm-pretty-bc-parser - - llvm-tf - - llvm-tools - - lmonad - - lmonad-yesod - - load-balancing - - load-font - - local-address - - local-search - - localize - - located - - located-monad-logger - - loch - - locked-poll - - log - - log-postgres - - log-utils - - log-warper - - log2json - - log4hs - - logentries - - logger - - logging-effect-extra - - logging-effect-extra-file - - logging-effect-extra-handler - - Logic - - logic-classes - - LogicGrowsOnTrees - - LogicGrowsOnTrees-MPI - - LogicGrowsOnTrees-network - - LogicGrowsOnTrees-processes - - logicst - - logict-state - - logplex-parse - - lojban - - lojbanParser - - lojbanXiragan - - lojysamban - - lol - - lol-apps - - lol-benches - - lol-calculus - - lol-cpp - - lol-repa - - lol-tests - - lol-typing - - loli - - longboi - - longshot - - lookup-tables - - loop-effin - - loop-while - - loopbreaker - - looper - - loops - - loopy - - lord - - lorem - - lorentz - - loris - - loshadka - - lostcities - - loup - - lowgl - - lp-diagrams-svg - - LRU - - ls-usb - - lscabal - - lsfrom - - LslPlus - - lsystem - - lti13 - - ltk - - LTS - - lua-bc - - luachunk - - luautils - - lucid-colonnade - - lucienne - - Lucu - - luhn - - lui - - luis-client - - luka - - luminance - - luminance-samples - - lushtags - - luthor - - lvish - - lvmlib - - lxc - - lxd-client - - lye - - Lykah - - lz4-bytes - - lz4-conduit - - lz4-frame-conduit - - lzip - - lzma-enumerator - - lzma-streams - - lzo - - maam - - mac - - macaroon-shop - - macbeth-lib - - machinecell - - machines-amazonka - - machines-attoparsec - - machines-binary - - machines-bytestring - - machines-directory - - machines-encoding - - machines-io - - machines-process - - machines-zlib - - macho - - maclight - - macos-corelibs - - macosx-make-standalone - - macrm - - madlang - - mage - - magic-tyfams - - magic-wormhole - - magicbane - - MagicHaskeller - - magico - - magma - - mahoro - - maid - - mail-pool - - mail-reports - - mailchimp - - mailchimp-subscribe - - MailchimpSimple - - mailgun - - majordomo - - majority - - make-hard-links - - make-monofoldable-foldable - - make-package - - makedo - - makefile - - mallard - - manatee - - manatee-anything - - manatee-core - - manatee-curl - - manatee-editor - - manatee-filemanager - - manatee-imageviewer - - manatee-ircclient - - manatee-mplayer - - manatee-pdfviewer - - manatee-processmanager - - manatee-template - - manatee-terminal - - manatee-welcome - - mandrill - - mandulia - - mangopay - - manifold-random - - manifolds - - Map - - map-exts - - mapalgebra - - Mapping - - mappy - - marionetta - - markdown-kate - - markdown-pap - - markdown2svg - - marked-pretty - - markov-processes - - markov-realization - - markup - - marmalade-upload - - marquise - - mars - - marvin - - marvin-interpolate - - masakazu-bot - - MASMGen - - massiv-persist - - massiv-serialise - - master-plan - - matchers - - math-grads - - math-interpolate - - math-metric - - math-programming - - math-programming-glpk - - math-programming-tests - - mathblog - - mathflow - - mathlink - - matrix-as-xyz - - matrix-market - - matrix-sized - - matsuri - - maude - - maxent - - maxent-learner-hw - - maxent-learner-hw-gui - - maxsharing - - maybench - - MaybeT - - MaybeT-monads-tf - - MaybeT-transformers - - MazesOfMonad - - MBot - - mbox-tools - - mbug - - MC-Fold-DP - - mcl - - mcm - - mcmaster-gloss-examples - - mcmc - - mcmc-samplers - - mcmc-synthesis - - mcpi - - mdapi - - mdcat - - mDNSResponder-client - - mdp - - mealstrom - - mealy - - MeanShift - - Measure - - mecab - - mech - - Mecha - - Mechs - - mechs - - mediabus - - mediabus-fdk-aac - - mediabus-rtp - - mediawiki - - medium-sdk-haskell - - mega-sdist - - megalisp - - mellon-core - - mellon-gpio - - mellon-web - - melody - - memcache - - memcache-conduit - - memcache-haskell - - memcached-binary - - memis - - memo-ptr - - memoization-utils - - memorypool - - menoh - - menshen - - mergeful-persistent - - mergeless-persistent - - merkle-patricia-db - - merkle-tree - - messagepack-rpc - - messente - - meta-misc - - meta-par - - meta-par-accelerate - - metadata - - MetaHDBC - - metaheuristics - - MetaObject - - metaplug - - metar - - metar-http - - metric - - Metrics - - metricsd-client - - metronome - - mezzo - - mezzolens - - MFlow - - mgeneric - - Mhailist - - MHask - - mi - - Michelangelo - - miconix-test - - micro-gateway - - micro-recursion-schemes - - microbase - - microformats2-parser - - microformats2-types - - microgroove - - microlens-each - - micrologger - - microsoft-translator - - MicrosoftTranslator - - mida - - midi-music-box - - midi-utils - - midimory - - midisurface - - mighttpd - - migrant-core - - migrant-hdbc - - migrant-postgresql-simple - - migrant-sqlite-simple - - mikmod - - mikrokosmos - - miku - - milena - - mime-directory - - minecraft-data - - minesweeper - - mini-egison - - miniforth - - minilens - - minilight - - minilight-lua - - minimung - - minions - - minioperational - - miniplex - - minirotate - - ministg - - minizinc-process - - minst-idx - - mios - - MIP - - MIP-glpk - - mirror-tweet - - miso - - miso-action-logger - - miso-examples - - miss - - miss-porcelain - - missing-py2 - - MissingPy - - mit-3qvpPyAi6mH - - mix-arrows - - mixed-strategies - - mixpanel-client - - mkbndl - - mkcabal - - ml-w - - mlist - - mm2 - - mmark - - mmark-cli - - mmark-ext - - mmsyn7h - - mmtf - - mmtl - - mmtl-base - - moan - - Mobile-Legends-Hack-Cheats - - modelicaparser - - modify-fasta - - modsplit - - modular-prelude - - modular-prelude-classy - - modularity - - module-management - - modulespection - - modulo - - Moe - - moe - - MoeDict - - moesocks - - mohws - - mole - - mollie-api-haskell - - monad-atom - - monad-atom-simple - - monad-bayes - - monad-branch - - monad-exception - - monad-fork - - monad-http - - monad-interleave - - monad-levels - - monad-lgbt - - monad-log - - monad-lrs - - monad-mersenne-random - - monad-metrics-extensible - - monad-mock - - monad-open - - monad-parallel-progressbar - - monad-param - - monad-persist - - monad-ran - - monad-recorder - - monad-state - - monad-statevar - - monad-ste - - monad-stlike-io - - monad-stlike-stm - - monad-task - - monad-timing - - monad-tx - - monad-unify - - monad-var - - monad-wrap - - monadacme - - MonadCatchIO-mtl - - MonadCatchIO-mtl-foreign - - MonadCatchIO-transformers - - MonadCatchIO-transformers-foreign - - MonadCompose - - monadic-recursion-schemes - - monadiccp - - monadiccp-gecode - - Monadius - - MonadLab - - monadLib-compose - - monadloc-pp - - monadlog - - Monadoro - - monadplus - - monads-fd - - MonadStack - - monarch - - Monaris - - Monatron - - Monatron-IO - - mondo - - monetdb-mapi - - money - - mongoDB - - mongodb-queue - - mongrel2-handler - - monitor - - monky - - mono-foldable - - Monocle - - monoid - - monoid-absorbing - - monoid-owns - - monoidplus - - monoids - - monopati - - monte-carlo - - months - - monus - - monzo - - moo - - morfette - - morfeusz - - morley - - morloc - - morpheus-graphql - - morpheus-graphql-app - - morpheus-graphql-cli - - morpheus-graphql-subscriptions - - morphisms-functors - - morphisms-functors-inventory - - morphisms-objects - - morte - - mosaico-lib - - moto-postgresql - - motor-diagrams - - motor-reflection - - mount - - movie-monad - - mp - - mpdmate - - mpppc - - mprelude - - mpretty - - mpris - - mprover - - mps - - mptcp-pm - - mpvguihs - - mqtt - - mqtt-hs - - mrifk - - mrm - - ms - - msgpack - - msgpack-aeson - - msgpack-binary - - msgpack-idl - - msgpack-rpc - - msgpack-rpc-conduit - - msh - - msi-kb-backlit - - MSQueue - - MTGBuilder - - mtgoxapi - - mtl-c - - mtl-evil-instances - - mtl-extras - - mtl-tf - - mtlx - - mtp - - mu-avro - - mu-graphql - - mu-grpc-client - - mu-grpc-common - - mu-grpc-server - - mu-kafka - - mu-lens - - mu-optics - - mu-persistent - - mu-prometheus - - mu-protobuf - - mu-rpc - - mu-schema - - mu-servant-server - - mu-tracing - - MuCheck - - MuCheck-Hspec - - MuCheck-HUnit - - MuCheck-QuickCheck - - MuCheck-SmallCheck - - mud - - muesli - - mulang - - multext-east-msd - - multi-cabal - - multi-instance - - multi-trie - - multiaddr - - multiarg - - multibase - - multifocal - - multihash - - multihash-serialise - - multilinear - - multilinear-io - - multipass - - multipath - - multiplate-simplified - - multiplicity - - multipool-persistent-postgresql - - multirec - - multirec-alt-deriver - - multirec-binary - - multisetrewrite - - multivariant - - Munkres-simple - - muon - - murder - - murmur - - murmur3 - - murmurhash3 - - mushu - - music-graphics - - music-parts - - music-pitch - - music-preludes - - music-score - - music-sibelius - - music-suite - - music-util - - musicbrainz-email - - musicScroll - - musicxml - - musicxml2 - - mustache-haskell - - mutable-iter - - MutationOrder - - mute-unmute - - mvar-lock - - mvc - - mvc-updates - - mvclient - - mxnet - - mxnet-dataiter - - mxnet-examples - - mxnet-nn - - mxnet-nnvm - - my-package-testing - - my-test-docs - - myanimelist-export - - myo - - MyPrimes - - mysnapsession - - mysnapsession-example - - mysql-effect - - mysql-haskell-openssl - - mysql-simple-quasi - - mysql-simple-typed - - mystem - - myTestlll - - mywatch - - myxine-client - - mzv - - n-tuple - - n2o-protocols - - n2o-web - - nagios-plugin-ekg - - nakadi-client - - named-lock - - named-servant - - named-servant-client - - named-servant-server - - named-sop - - namelist - - namespace - - nano-hmac - - nano-md5 - - nanocurses - - nanomsg - - nanomsg-haskell - - nanoparsec - - NanoProlog - - nanovg - - nanovg-simple - - nanq - - naperian - - NaperianNetCDF - - naqsha - - narc - - nat-sized-numbers - - nationstates - - nats-client - - nats-queue - - natural - - natural-number - - NaturalLanguageAlphabets - - NaturalSort - - naver-translate - - nbt - - NearContextAlgebra - - neat - - needle - - neet - - nehe-tuts - - neither - - neko-lib - - Neks - - nemesis-titan - - neptune-backend - - nerf - - nero - - nero-wai - - nero-warp - - nest - - nested-routes - - nested-sequence - - NestedFunctor - - nestedmap - - net-spider - - net-spider-cli - - net-spider-pangraph - - net-spider-rpl - - net-spider-rpl-cli - - netclock - - netcore - - netease-fm - - netlines - - netrium - - NetSNMP - - netspec - - netstring-enumerator - - nettle-frp - - nettle-netkit - - nettle-openflow - - netwire-input-javascript - - netwire-vinylglfw-examples - - network-address - - network-anonymous-i2p - - network-anonymous-tor - - network-api-support - - network-arbitrary - - network-attoparsec - - network-bitcoin - - network-builder - - network-bytestring - - network-carbon - - network-connection - - network-dns - - network-enumerator - - network-hans - - network-house - - network-interfacerequest - - network-messagepack-rpc-websocket - - network-minihttp - - network-msgpack-rpc - - network-netpacket - - network-packet-linux - - network-protocol-xmpp - - network-rpca - - network-server - - network-service - - network-simple-sockaddr - - network-simple-wss - - network-socket-options - - network-stream - - network-topic-models - - network-transport-amqp - - network-transport-inmemory - - network-uri-json - - network-voicetext - - network-wai-router - - network-websocket - - networked-game - - neural - - neural-network-blashs - - neural-network-hmatrix - - newhope - - newports - - newsletter - - newsletter-mailgun - - newt - - newtype-deriving - - newtype-th - - newtype-zoo - - next-ref - - nextstep-plist - - nfc - - NGrams - - ngrams-loader - - ngx-export-tools-extra - - niagra - - nibblestring - - nice-html - - nicovideo-translator - - nikepub - - Ninjas - - nirum - - nitro - - nix-delegate - - nix-deploy - - nix-eval - - nix-freeze-tree - - nix-thunk - - nix-tools - - nixfromnpm - - nixpkgs-update - - nkjp - - nlp-scores - - nlp-scores-scripts - - nm - - NMap - - nntp - - no-role-annots - - noether - - nofib-analyse - - nofib-analyze - - noise - - noli - - nom - - Nomyx - - Nomyx-Core - - Nomyx-Language - - Nomyx-Rules - - Nomyx-Web - - non-empty-zipper - - NonEmpty - - nonempty-lift - - NonEmptyList - - normalization-insensitive - - NoSlow - - not-gloss-examples - - notcpp - - notifications-tray-icon - - notmuch-haskell - - notmuch-web - - NoTrace - - now-haskell - - np-extras - - np-linear - - nptools - - ntp-control - - ntrip-client - - nuha - - null-canvas - - nullary - - nullpipe - - numbered-semigroups - - NumberSieves - - NumberTheory - - numerals - - numerals-base - - numeric-ode - - numeric-qq - - numeric-ranges - - numerical - - numhask-array - - numhask-free - - numhask-hedgehog - - numhask-histogram - - numhask-prelude - - numhask-range - - numhask-space - - numhask-test - - Nussinov78 - - Nutri - - NXT - - NXTDSL - - nylas - - nymphaea - - nyx-game - - oanda-rest-api - - oasis-xrd - - oauth2-jwt-bearer - - oauthenticated - - obd - - obdd - - oberon0 - - obj - - Object - - objectid - - ObjectIO - - objective - - oblivious-transfer - - ocaml-export - - ochan - - octane - - octohat - - octopus - - Octree - - oculus - - odbc - - odd-jobs - - OddWord - - oden-go-packages - - oeis2 - - off-simple - - OGL - - ogmarkup - - ohloh-hs - - oi - - oidc-client - - ois-input-manager - - olwrapper - - om-actor - - om-doh - - om-elm - - om-fail - - om-http-logging - - omaketex - - ombra - - Omega - - omega - - omnifmt - - on-a-horse - - on-demand-ssh-tunnel - - onama - - ONC-RPC - - oneormore - - online - - online-csv - - onpartitions - - OnRmt - - onu-course - - op - - opaleye-classy - - opaleye-sqlite - - opaleye-trans - - open-adt - - open-adt-tutorial - - open-haddock - - open-pandoc - - open-signals - - open-typerep - - open-union - - OpenAFP - - OpenAFP-Utils - - openai-hs - - openai-servant - - openapi-petstore - - openapi-typed - - openapi3-code-generator - - opench-meteo - - OpenCL - - OpenCLRaw - - OpenCLWrappers - - opencv-raw - - opendatatable - - OpenGLCheck - - opengles - - openid-connect - - OpenSCAD - - opensoundcontrol-ht - - openssh-github-keys - - openssh-protocol - - opentelemetry-http-client - - opentheory-char - - opentok - - opentracing-jaeger - - opentracing-zipkin-v1 - - opentype - - OpenVG - - OpenVGRaw - - openweathermap - - Operads - - operate-do - - operational-extra - - oplang - - opn - - optima - - optima-for-hasql - - optimal-blocks - - optimization - - optimusprime - - optional - - options-time - - optparse-applicative-simple - - optparse-enum - - optparse-helper - - orc - - orchestrate - - OrchestrateDB - - orchid - - orchid-demo - - order-maintenance - - order-statistics - - ordinal - - Ordinary - - ordrea - - oref - - org-mode - - org-mode-lucid - - organize-imports - - orgmode - - origami - - orizentic - - OrPatterns - - osc - - oscpacking - - oset - - Oslo-Vectize - - OSM - - osm-conduit - - osm-download - - oso2pdf - - osx-ar - - ot - - OTP - - otp-authenticator - - ottparse-pretty - - overloaded - - overloaded-records - - overture - - pack - - package-description-remote - - package-o-tron - - package-vt - - packed - - packed-dawg - - packed-multikey-map - - packedstring - - packer-messagepack - - packman - - packunused - - pacman-memcache - - padKONTROL - - pads-haskell - - pagarme - - PageIO - - pagure-hook-receiver - - Paillier - - pairing - - palette - - pan-os-syslog - - panda - - pandoc-citeproc - - pandoc-csv2table - - pandoc-filter-graphviz - - pandoc-filter-indent - - pandoc-include - - pandoc-japanese-filters - - pandoc-lens - - pandoc-markdown-ghci-filter - - pandoc-placetable - - pandoc-plantuml-diagrams - - pandoc-pyplot - - pandoc-unlit - - pandoc-utils - - PandocAgda - - pang-a-lambda - - pangraph - - panpipe - - pansite - - pantry-tmp - - papa - - papa-base - - papa-base-export - - papa-base-implement - - papa-export - - papa-implement - - papa-include - - papa-prelude - - papa-prelude-core - - papa-prelude-lens - - papa-prelude-semigroupoids - - papa-prelude-semigroups - - papa-semigroupoids - - papa-semigroupoids-implement - - paphragen - - papillon - - pappy - - paprika - - par-dual - - paragon - - Paraiso - - Parallel-Arrows-Eden - - parallel-tasks - - parameterized-utils - - paranoia - - parco - - parco-attoparsec - - parco-parsec - - parcom-lib - - parconc-examples - - pareto - - parochial - - parquet-hs - - Parry - - parse-help - - parseargs - - parsec-free - - parsec-parsers - - parsec-pratt - - parsec2 - - parsec3 - - parseerror-eq - - parsely - - parser-combinators-tests - - parser-helper - - parser241 - - parsergen - - parsers-megaparsec - - parsestar - - parsimony - - parsnip - - partage - - partial-lens - - partial-records - - partly - - passage - - passman - - PasswordGenerator - - passwords - - pasta - - pastis - - pasty - - patat - - patches-vector - - Pathfinder - - pathfindingcore - - PathTree - - patronscraper - - patterns - - paypal-adaptive-hoops - - paypal-api - - paypal-rest-client - - pb - - pb-next - - pbc4hs - - PBKDF2 - - pcap-enumerator - - pcapng - - pcd-loader - - pcf - - pcf-font - - pcf-font-embed - - PCLT - - PCLT-DB - - pcre-light-extra - - pdf-slave - - pdf-slave-template - - pdf-toolbox-content - - pdf-toolbox-core - - pdf-toolbox-document - - pdf-toolbox-viewer - - pdfname - - pdfsplit - - pdftotext - - pdynload - - peakachu - - PeanoWitnesses - - pec - - pecoff - - pedersen-commitment - - pedestrian-dag - - peg - - peggy - - pell - - pencil - - penntreebank-megaparsec - - penny - - penny-bin - - penny-lib - - penrose - - peparser - - percent-encoder - - perceptron - - perceptual-hash - - peregrin - - perf - - perf-analysis - - PerfectHash - - perfecthash - - perhaps - - periodic - - periodic-client - - periodic-client-exe - - periodic-common - - periodic-server - - perm - - permutation - - permutations - - permute - - PermuteEffects - - persist2er - - Persistence - - persistent-audit - - persistent-cereal - - persistent-database-url - - persistent-equivalence - - persistent-hssqlppp - - persistent-map - - persistent-migration - - persistent-mongoDB - - persistent-mysql-haskell - - persistent-odbc - - persistent-protobuf - - persistent-ratelimit - - persistent-redis - - persistent-relational-record - - persistent-template-classy - - persistent-test - - persistent-vector - - persistent-zookeeper - - persona - - persona-idp - - pesca - - peyotls - - peyotls-codec - - pez - - pg-extras - - pg-harness - - pg-harness-server - - pg-recorder - - pg-store - - pg-transact - - pgdl - - pgf2 - - pgsql-simple - - pgstream - - phasechange - - phaser - - phoityne - - phone-numbers - - phone-push - - phonetic-languages-examples - - phonetic-languages-properties - - phonetic-languages-simplified-lists-examples - - phonetic-languages-simplified-properties-lists - - phonetic-languages-simplified-properties-lists-double - - phooey - - photoname - - phraskell - - Phsu - - phybin - - pi-calculus - - pi-forall - - pi-hoole - - pia-forward - - pianola - - picedit - - pickle - - picologic - - picoparsec - - pictikz - - pier - - pier-core - - piet - - pig - - pinboard - - pinch - - pinch-gen - - pinchot - - ping - - pinpon - - Pipe - - pipe-enumerator - - pipes-async - - pipes-attoparsec-streaming - - pipes-bgzf - - pipes-brotli - - pipes-cacophony - - pipes-cereal - - pipes-cereal-plus - - pipes-conduit - - pipes-core - - pipes-courier - - pipes-errors - - pipes-extra - - pipes-files - - pipes-illumina - - pipes-interleave - - pipes-io - - pipes-key-value-csv - - pipes-mongodb - - pipes-p2p - - pipes-p2p-examples - - pipes-protolude - - pipes-rt - - pipes-s3 - - pipes-shell - - pipes-sqlite-simple - - pipes-transduce - - pipes-vector - - pipes-zeromq4 - - pisigma - - Piso - - pit - - pitchtrack - - pivotal-tracker - - pixel-printer - - pixelated-avatar-generator - - pixiv - - pkcs10 - - pkcs7 - - pkggraph - - pkgtreediff - - plailude - - plan-applicative - - plan-b - - planar-graph - - planb-token-introspection - - planet-mitchell - - planet-mitchell-test - - plankton - - plat - - platinum-parsing - - PlayingCards - - plist - - plist-buddy - - plocketed - - plot-gtk - - plot-gtk-ui - - plot-gtk3 - - Plot-ho-matic - - plot-lab - - PlslTools - - plugins - - plugins-auto - - plugins-multistage - - plumbers - - plur - - plural - - plzwrk - - png-file - - pngload - - pngload-fixed - - pocket - - pocket-dns - - point-octree - - pointedalternative - - pointfree-fancy - - pointful - - pointless-haskell - - pointless-lenses - - pointless-rewrite - - poke - - pokemon-go-protobuf-types - - poker-eval - - pokitdok - - polar-configfile - - polar-shader - - polh-lexicon - - Pollutocracy - - poly-cont - - poly-control - - polydata - - polydata-core - - polynomial - - polysemy-chronos - - polysemy-conc - - polysemy-extra - - polysemy-fskvstore - - polysemy-http - - polysemy-kvstore-jsonfile - - polysemy-log - - polysemy-log-co - - polysemy-log-di - - polysemy-methodology - - polysemy-methodology-composite - - polysemy-optics - - polysemy-path - - polysemy-RandomFu - - polysemy-resume - - polysemy-test - - polysemy-time - - polysemy-vinyl - - polysemy-zoo - - polyseq - - polytypeable - - polytypeable-utils - - pomaps - - pomodoro - - pomohoro - - ponder - - pong-server - - pontarius-xmpp - - pool - - pool-conduit - - pop3-client - - popenhs - - popkey - - poppler - - porcupine-core - - porcupine-http - - porcupine-s3 - - portager - - porte - - PortFusion - - ports - - poseidon - - poseidon-postgis - - positron - - posix-acl - - posix-api - - posix-realtime - - posix-waitpid - - postcodes - - postgres-embedded - - postgres-tmp - - postgres-websockets - - postgresql-lo-stream - - postgresql-named - - postgresql-query - - postgresql-simple-bind - - postgresql-simple-migration - - postgresql-simple-named - - postgresql-simple-queue - - postgresql-simple-sop - - postgresql-simple-typed - - postgresql-simple-url - - postgresql-syntax - - postgresql-tx-query - - postgresql-tx-squeal - - postgresql-tx-squeal-compat-simple - - postgresql-typed-lifted - - postgrest-ws - - postie - - postmark - - postmark-streams - - postmaster - - potato-tool - - potoki - - potoki-cereal - - potoki-conduit - - potoki-core - - potoki-hasql - - potoki-zlib - - potrace-diagrams - - powermate - - powerpc - - powerqueue-levelmem - - powerqueue-sqs - - pprecord - - PPrinter - - pqc - - pqueue-mtl - - practice-room - - praglude - - preamble - - precursor - - pred-set - - pred-trie - - predicate-class - - predicate-transformers - - predicate-typed - - prednote - - prednote-test - - prefork - - pregame - - preliminaries - - Prelude - - prelude-generalize - - prelude-plus - - preprocess-haskell - - preprocessor - - preql - - presburger - - present - - press - - presto-hdbc - - pretty-ghci - - pretty-ncols - - pretty-types - - prettyprinter-lucid - - prettyprinter-vty - - preview - - prim-array - - prim-instances - - prim-ref - - primal - - primal-memory - - primes-type - - primitive-atomic - - primitive-checked - - primitive-containers - - primitive-convenience - - primitive-foreign - - primitive-indexed - - primitive-maybe - - primitive-simd - - primitive-sort - - primitive-stablename - - PrimitiveArray-Pretty - - primula-board - - primula-bot - - pringletons - - print-debugger - - printcess - - Printf-TH - - prints - - priority-queue - - PriorityChansConverger - - ProbabilityMonads - - probable - - proc - - process-conduit - - process-iterio - - process-leksah - - process-listlike - - process-progress - - process-qq - - process-streaming - - processing - - processmemory - - procrastinating-variable - - procstat - - producer - - prof-flamegraph - - prof2dot - - prof2pretty - - profunctor-monad - - progress - - progress-meter - - progress-reporting - - progressbar - - progression - - progressive - - proj4-hs-bindings - - project-m36 - - projectile - - prolens - - prolog-graph - - prologue - - prolude - - prometheus-effect - - promise - - pronounce - - proof-combinators - - propane - - Proper - - properties - - property-list - - proplang - - prosidy - - prosidyc - - prosper - - proteaaudio - - proteaaudio-sdl - - proteome - - proto-lens-arbitrary - - proto-lens-combinators - - proto-lens-descriptors - - proto-lens-optparse - - proto3-suite - - proto3-wire - - protobuf-native - - protocol - - protocol-buffers-descriptor-fork - - protocol-buffers-fork - - protolude-lifted - - proton - - proton-haskell - - prototype - - prove-everywhere-server - - provenience - - proxy-kindness - - proxy-mapping - - psc-ide - - pseudo-boolean - - pseudo-trie - - PTQ - - ptr-poker - - publicsuffixlistcreate - - publish - - pubnub - - pubsub - - puffytools - - pugixml - - Pugs - - pugs-compat - - pugs-DrIFT - - pugs-hsregex - - PUH-Project - - punkt - - Pup-Events - - Pup-Events-Demo - - Pup-Events-Server - - puppetresources - - pure-cdb - - pure-io - - pure-priority-queue - - pure-priority-queue-tests - - pure-zlib - - purescheme-wai-routing-core - - purescript - - purescript-ast - - purescript-cst - - purescript-iso - - purescript-tsd-gen - - push-notifications - - push-notify - - push-notify-apn - - push-notify-ccs - - push-notify-general - - pusher-haskell - - pusher-ws - - pushme - - putlenses - - puzzle-draw - - puzzle-draw-cmdline - - pvd - - pyffi - - pyfi - - python-pickle - - q4c12-twofinger - - qc-oi-testgenerator - - qd - - qd-vec - - qed - - qhs - - qhull-simple - - qif - - QIO - - QLearn - - qlinear - - qnap-decrypt - - qr-imager - - qr-repa - - qsem - - QuadEdge - - QuadTree - - quantfin - - quantification - - quantum-arrow - - quantum-random - - quarantimer - - qudb - - Quelea - - quenya-verb - - queryparser - - queryparser-demo - - queryparser-hive - - queryparser-presto - - queryparser-vertica - - questioner - - queuelike - - quick-schema - - QuickAnnotate - - quickbench - - quickbooks - - quickcheck-arbitrary-template - - quickcheck-poly - - quickcheck-property-comb - - quickcheck-property-monad - - quickcheck-regex - - quickcheck-relaxng - - quickcheck-rematch - - quickcheck-report - - quickcheck-state-machine - - quickcheck-state-machine-distributed - - quickcheck-string-random - - quickcheck-webdriver - - QuickCheckVariant - - quickjs-hs - - QuickPlot - - quickpull - - quickset - - Quickson - - quickspec - - quicktest - - quickwebapp - - quipper - - quipper-algorithms - - quipper-all - - quipper-cabal - - quipper-core - - quipper-demos - - quipper-language - - quipper-libraries - - quipper-rendering - - quipper-tools - - quipper-utils - - quiver - - quiver-binary - - quiver-bytestring - - quiver-cell - - quiver-csv - - quiver-enumerator - - quiver-groups - - quiver-http - - quiver-instances - - quiver-interleave - - quiver-sort - - quokka - - quoridor-hs - - qux - - R-pandoc - - raaz - - RabbitMQ - - rad - - radian - - radium - - radium-formula-parser - - radix - - rados-haskell - - raft - - rail-compiler-editor - - rails-session - - rainbow-tests - - raketka - - rakhana - - rakuten - - ralist - - rallod - - raml - - rand-vars - - randfile - - rando - - random-access-list - - random-derive - - random-eff - - random-effin - - random-hypergeometric - - random-stream - - RandomDotOrg - - Range - - range-set-list - - range-space - - rangemin - - Ranka - - rapid - - rapid-term - - rasa - - rasa-example-config - - rasa-ext-bufs - - rasa-ext-cmd - - rasa-ext-cursors - - rasa-ext-files - - rasa-ext-logger - - rasa-ext-slate - - rasa-ext-status-bar - - rasa-ext-style - - rasa-ext-views - - rasa-ext-vim - - rascal - - Rasenschach - - rating-chgk-info - - rational-list - - rattle - - rattletrap - - raven-haskell-scotty - - raw-feldspar - - rawr - - raz - - razom-text-util - - rbr - - rbst - - rc - - rclient - - rdioh - - react-flux - - react-flux-servant - - react-haskell - - react-tutorial-haskell-server - - reaction-logic - - reactive-bacon - - reactive-balsa - - reactive-banana - - reactive-banana-automation - - reactive-banana-bunch - - reactive-banana-gi-gtk - - reactive-banana-sdl - - reactive-banana-sdl2 - - reactive-banana-threepenny - - reactive-banana-wx - - reactive-fieldtrip - - reactive-glut - - reactive-jack - - reactive-midyim - - reactive-thread - - reactor - - read-bounded - - read-ctags - - read-io - - readability - - readline - - readline-statevar - - readme-lhs - - readpyc - - readshp - - really-simple-xml-parser - - reanimate - - reanimate-svg - - reasonable-lens - - record - - record-aeson - - record-encode - - record-gl - - record-preprocessor - - record-syntax - - records - - records-th - - recursion-schemes - - recursion-schemes-ext - - recursors - - red-black-record - - reddit - - redis-hs - - redis-simple - - redland - - Redmine - - reduce-equations - - reedsolomon - - reenact - - Ref - - ref - - ref-mtl - - refcount - - Referees - - references - - refh - - refined-http-api-data - - reflection-extras - - reflex-animation - - reflex-backend-socket - - reflex-backend-wai - - reflex-basic-host - - reflex-dom-retractable - - reflex-dom-svg - - reflex-dynamic-containers - - reflex-fsnotify - - reflex-gadt-api - - reflex-ghci - - reflex-gi-gtk - - reflex-gloss - - reflex-gloss-scene - - reflex-libtelnet - - reflex-localize - - reflex-localize-dom - - reflex-orphans - - reflex-process - - reflex-sdl2 - - reflex-transformers - - reflex-vty - - reformat - - refractor - - refresht - - refurb - - reg-alloc - - reg-alloc-graph-color - - regex-deriv - - regex-dfa - - regex-generator - - regex-parsec - - regex-pcre-text - - regex-pderiv - - regex-posix-unittest - - regex-tdfa-pipes - - regex-tdfa-quasiquoter - - regex-tdfa-rc - - regex-tdfa-text - - regex-tdfa-unittest - - regex-tdfa-utf8 - - regex-tre - - regex-type - - regex-wrapper - - regex-xmlschema - - regexp-tries - - regexpr-symbolic - - regexqq - - regional-pointers - - regions - - regions-monadsfd - - regions-monadstf - - regions-mtl - - register-machine-typelevel - - registry - - registry-hedgehog - - regress - - regression-simple - - regular - - regular-extras - - regular-web - - regular-xmlpickler - - reheat - - rehoo - - rei - - reified-records - - reify - - relacion - - relapse - - relational-postgresql8 - - relational-query-postgresql-pure - - relative-date - - relevant-time - - reload - - remark - - remarks - - remote - - remote-debugger - - remote-json - - remote-json-client - - remote-json-server - - remote-monad - - remotion - - render-utf8 - - reorder-expression - - repa-algorithms - - repa-array - - repa-bytestring - - repa-convert - - repa-devil - - repa-eval - - repa-examples - - repa-flow - - repa-linear-algebra - - repa-plugin - - repa-scalar - - repa-series - - repa-stream - - repa-v4l2 - - repl - - RepLib - - replica - - replicant - - ReplicateEffects - - repo-based-blog - - repr - - representable-functors - - representable-tries - - reprinter - - reproject - - req-conduit - - req-oauth2 - - req-url-extra - - reqcatcher - - request-monad - - rere - - rescue - - reserve - - reservoir - - resin - - resistor-cube - - resolve - - resolve-trivial-conflicts - - resource-effect - - resource-embed - - resource-pool-catchio - - resource-simple - - respond - - rest-client - - rest-core - - rest-example - - rest-gen - - rest-happstack - - rest-snap - - rest-stringmap - - rest-types - - rest-wai - - restartable - - restful-snap - - restricted-workers - - restyle - - rethinkdb - - rethinkdb-client-driver - - rethinkdb-model - - rethinkdb-wereHamster - - retryer - - reverse-geocoding - - reversi - - ReviewBoard - - rewrite - - rewrite-inspector - - rewriting - - rezoom - - rfc - - rfc-env - - rfc-http-client - - rfc-prelude - - rfc-psql - - rfc-redis - - rfc-servant - - rg - - rhbzquery - - rhythm-game-tutorial - - rib - - ribbit - - RichConditional - - ridley - - ridley-extras - - riemann - - riff - - ring-buffer - - ring-buffers - - rio-process-pool - - riot - - risc-v - - risc386 - - riscv-isa - - Ritt-Wu - - rivers - - rivet - - rivet-migration - - rivet-simple-deploy - - RJson - - rl-satton - - Rlang-QQ - - rlglue - - RLP - - rlwe-challenges - - rmonad - - RMP - - RNAdesign - - RNAdraw - - RNAFold - - RNAFoldProgs - - RNAlien - - RNAwolf - - rncryptor - - rob - - robin - - robots-txt - - roc-cluster - - roc-cluster-demo - - rock - - rocksdb-haskell - - rocksdb-haskell-jprupp - - rocksdb-query - - roku-api - - rollbar - - rollbar-cli - - rollbar-client - - rollbar-hs - - rollbar-wai - - rollbar-yesod - - roller - - RollingDirectory - - ron-rdt - - ron-schema - - ron-storage - - rope - - rose-trees - - rose-trie - - rosebud - - roshask - - rosmsg - - rosmsg-bin - - rosso - - rotating-log - - rounded - - rounded-hw - - rounding - - roundtrip-aeson - - roundtrip-xml - - route-planning - - rowrecord - - rpc - - rpc-framework - - rpf - - rpm - - rpmbuild-order - - rrule - - rsagl - - rsagl-frp - - rsagl-math - - rspp - - rss - - rss-conduit - - rss2irc - - rstream - - rtcm - - RtMidi - - rtnetlink - - rtorrent-rpc - - rts-loader - - ruby-marshal - - ruby-qq - - ruff - - ruin - - ruler - - ruler-core - - run-st - - rungekutta - - runhs - - runmany - - runtime-arbitrary - - rv - - rws - - RxHaskell - - s-expression - - S3 - - SableCC2Hs - - safe-buffer-monad - - safe-coerce - - safe-freeze - - safe-globals - - safe-lazy-io - - safe-length - - safe-numeric - - safe-plugins - - safe-printf - - safecopy-migrate - - safecopy-store - - safeint - - safepath - - safer-file-handles - - safer-file-handles-bytestring - - safer-file-handles-text - - saferoute - - sai-shape-syb - - sajson - - sak - - salak-toml - - Salsa - - saltine-quickcheck - - salvia - - salvia-demo - - salvia-extras - - salvia-protocol - - salvia-sessions - - salvia-websocket - - samtools - - samtools-conduit - - samtools-enumerator - - samtools-iteratee - - sandlib - - sandman - - sarasvati - - sarsi - - sasl - - sat - - sat-micro-hs - - satchmo - - satchmo-backends - - satchmo-examples - - satchmo-funsat - - satchmo-minisat - - satchmo-toysat - - Saturnin - - savage - - sax - - SBench - - sbvPlugin - - sc2-lowlevel - - sc2-proto - - sc2-support - - sc3-rdu - - scalable-server - - scaleimage - - SCalendar - - scalendar - - scalp-webhooks - - scalpel-search - - scan-metadata - - scan-vector-machine - - scanner-attoparsec - - scc - - scenegraph - - scgi - - schedevr - - schedule-planner - - schedyield - - schema - - schemas - - schematic - - scholdoc - - scholdoc-citeproc - - scholdoc-texmath - - scholdoc-types - - sci-ratio - - SciBaseTypes - - scidb-hquery - - scientific-notation - - SciFlow - - SciFlow-drmaa - - scion - - scion-browser - - scons2dot - - scope - - scope-cairo - - scottish - - scotty-binding-play - - scotty-blaze - - scotty-fay - - scotty-form - - scotty-format - - scotty-hastache - - scotty-params-parser - - scotty-resource - - scotty-rest - - scotty-session - - scotty-tls - - scotty-view - - scp-streams - - scrabble-bot - - scrapbook - - scrapbook-core - - scrape-changes - - ScratchFs - - script-monad - - SCRIPTWriter - - scrobble - - Scurry - - scythe - - scyther-proof - - sde-solver - - sdl2-cairo-image - - sdl2-compositor - - sdl2-fps - - sdr - - seakale - - seakale-postgresql - - seakale-tests - - sec - - secdh - - seclib - - second-transfer - - secp256k1 - - secp256k1-haskell - - secp256k1-legacy - - secret-santa - - secrm - - secure-sockets - - SecureHash-SHA3 - - secureUDP - - sednaDBXML - - seitz-symbol - - selectors - - SelectSequencesFromMSA - - selenium - - selenium-server - - self-extract - - selinux - - semantic-source - - Semantique - - semdoc - - semi-iso - - semialign-extras - - semibounded-lattices - - Semigroup - - semigroupoids-syntax - - semigroups-actions - - semiring - - semiring-num - - sendgrid-haskell - - sendgrid-v3 - - sensei - - sensenet - - sensu-run - - sentence-jp - - sentry - - seonbi - - seqaid - - SeqAlign - - seqloc - - seqloc-datafiles - - sequent-core - - sequor - - serialize-instances - - serialport - - serokell-util - - serpentine - - serv - - serv-wai - - servant-aeson-specs - - servant-auth-cookie - - servant-auth-docs - - servant-auth-hmac - - servant-auth-token - - servant-auth-token-acid - - servant-auth-token-api - - servant-auth-token-leveldb - - servant-auth-token-persistent - - servant-auth-token-rocksdb - - servant-auth-wordpress - - servant-avro - - servant-benchmark - - servant-cassava - - servant-checked-exceptions - - servant-checked-exceptions-core - - servant-cli - - servant-client-js - - servant-client-namedargs - - servant-csharp - - servant-db - - servant-db-postgresql - - servant-dhall - - servant-docs-simple - - servant-ede - - servant-ekg - - servant-elm - - servant-event-stream - - servant-examples - - servant-fiat-content - - servant-generate - - servant-generic - - servant-github - - servant-haxl-client - - servant-hmac-auth - - servant-http-streams - - servant-http2-client - - servant-iCalendar - - servant-jquery - - servant-js - - servant-JuicyPixels - - servant-kotlin - - servant-matrix-param - - servant-mock - - servant-multipart - - servant-namedargs - - servant-nix - - servant-pagination - - servant-pandoc - - servant-polysemy - - servant-pool - - servant-postgresql - - servant-proto-lens - - servant-purescript - - servant-pushbullet-client - - servant-py - - servant-quickcheck - - servant-rawm-client - - servant-rawm-docs - - servant-reason - - servant-reflex - - servant-router - - servant-scotty - - servant-seo - - servant-serf - - servant-server-namedargs - - servant-smsc-ru - - servant-snap - - servant-static-th - - servant-streaming - - servant-streaming-client - - servant-streaming-docs - - servant-streaming-server - - servant-swagger-tags - - servant-to-elm - - servant-waargonaut - - servant-yaml - - servant-zeppelin - - servant-zeppelin-client - - servant-zeppelin-server - - servant-zeppelin-swagger - - server-generic - - serversession - - serversession-backend-acid-state - - serversession-backend-persistent - - serversession-backend-redis - - serversession-frontend-snap - - serversession-frontend-wai - - serversession-frontend-yesod - - services - - ses-html-snaplet - - SessionLogger - - sessions - - sessiontypes - - sessiontypes-distributed - - Set - - set-of - - set-with - - setdown - - setgame - - setoid - - setters - - sexp - - sexp-grammar - - sexpr-parser - - sext - - SFML - - SFML-control - - sfmt - - sfnt2woff - - SFont - - SG - - sgd - - SGdemo - - sgf - - SGplus - - sgrep - - sh2md - - sha-streams - - sha1 - - shade - - shadower - - shake-bindist - - shake-cabal-build - - shake-dhall - - shake-extras - - shake-minify - - shake-minify-css - - shake-pack - - shake-path - - shake-persist - - shakebook - - shaker - - shakespeare-babel - - shakespeare-sass - - shapefile - - shapely-data - - shared-buffer - - shared-fields - - she - - shelduck - - shell-pipe - - Shellac - - Shellac-compatline - - Shellac-editline - - Shellac-haskeline - - Shellac-readline - - shellish - - shellmate - - shellmate-extras - - shimmer - - shine-examples - - shivers-cfg - - shoap - - shopify - - shortcut-links - - shorten-strings - - ShortestPathProblems - - show-prettyprint - - showdown - - Shpadoinkle-backend-pardiff - - Shpadoinkle-backend-snabbdom - - Shpadoinkle-backend-static - - Shpadoinkle-developer-tools - - Shpadoinkle-disembodied - - Shpadoinkle-examples - - Shpadoinkle-html - - Shpadoinkle-router - - Shpadoinkle-streaming - - Shpadoinkle-template - - Shpadoinkle-widgets - - shpider - - shuffle - - shwifty - - si-clock - - sibe - - sifflet - - sifflet-lib - - sigma-ij - - sign - - signable - - signals - - signature - - signed-multiset - - signify-hs - - silkscreen - - silvi - - simd - - simgi - - simple-actors - - simple-atom - - simple-bluetooth - - simple-c-value - - simple-conduit - - simple-config - - simple-css - - simple-download - - simple-eval - - simple-firewire - - simple-genetic-algorithm - - simple-index - - simple-log-syslog - - simple-logging - - simple-money - - simple-neural-networks - - simple-nix - - simple-pascal - - simple-pipe - - simple-rope - - simple-server - - simple-sql-parser - - simple-stacked-vm - - simple-tabular - - simple-tar - - simple-ui - - simple-units - - simple-vec3 - - simple-zipper - - simpleargs - - simpleconfig - - SimpleGL - - simpleirc - - simpleirc-lens - - SimpleLog - - simplenote - - simpleprelude - - SimpleServer - - simplesmtpclient - - simplest-sqlite - - simseq - - singleton-dict - - singleton-typelits - - singletons-base - - singletons-th - - singnal - - singular-factory - - sink - - siphon - - siren-json - - sirkel - - sitepipe - - sixfiguregroup - - sized-grid - - sized-types - - sized-vector - - sizes - - sjsp - - SJW - - skeletal-set - - skeleton - - skeletons - - skell - - skemmtun - - skews - - skulk - - skylark-client - - skylighting-lucid - - skype4hs - - slack - - slack-notify-haskell - - slack-verify - - slack-web - - slave-thread - - sliceofpy - - slidemews - - Slides - - slim - - slip32 - - sloane - - slot-lambda - - sloth - - slug - - slugify - - slynx - - small-bytearray-builder - - smallarray - - smallcheck-kind-generics - - smallcheck-laws - - smallcheck-lens - - smallpt-hs - - smallstring - - smap - - smartcheck - - smartconstructor - - smartGroup - - smartword - - smcdel - - sme - - smerdyakov - - smiles - - smith - - smith-cli - - smith-client - - Smooth - - smsaero - - smt-lib - - smt2-parser - - SmtLib - - smtlib2 - - smtlib2-debug - - smtlib2-pipe - - smtlib2-quickcheck - - smtlib2-timing - - smtp-mail-ng - - SMTPClient - - smtps-gmail - - smuggler - - smuggler2 - - snake - - snake-game - - snap-accept - - snap-auth-cli - - snap-blaze-clay - - snap-configuration-utilities - - snap-elm - - snap-error-collector - - snap-extras - - snap-routes - - snap-stream - - snap-testing - - snap-utils - - snap-web-routes - - snaplet-acid-state - - snaplet-actionlog - - snaplet-amqp - - snaplet-auth-acid - - snaplet-coffee - - snaplet-css-min - - snaplet-customauth - - snaplet-environments - - snaplet-fay - - snaplet-hasql - - snaplet-haxl - - snaplet-hdbc - - snaplet-hslogger - - snaplet-influxdb - - snaplet-lss - - snaplet-mandrill - - snaplet-mongoDB - - snaplet-mongodb-minimalistic - - snaplet-mysql-simple - - snaplet-oauth - - snaplet-persistent - - snaplet-postgresql-simple - - snaplet-postmark - - snaplet-purescript - - snaplet-recaptcha - - snaplet-redis - - snaplet-redson - - snaplet-rest - - snaplet-riak - - snaplet-sass - - snaplet-scoped-session - - snaplet-sedna - - snaplet-ses-html - - snaplet-sqlite-simple - - snaplet-sqlite-simple-jwt-auth - - snaplet-stripe - - snaplet-tasks - - snaplet-typed-sessions - - snaplet-wordpress - - snappy-conduit - - snappy-iteratee - - sndfile-enumerators - - sneakyterm - - SNet - - snipcheck - - snm - - snmp - - snorkels - - snow-white - - snowflake-core - - snowflake-server - - snowtify - - Snusmumrik - - SoccerFun - - SoccerFunGL - - socket-activation - - socket-io - - socket-sctp - - socket-unix - - socketed - - socketio - - sockets - - sockets-and-pipes - - socketson - - sodium - - soegtk - - softfloat-hs - - solga - - solga-swagger - - solr - - sonic-visualiser - - Sonnex - - SoOSiM - - sorted - - sorting - - sorty - - souffle-dsl - - souffle-haskell - - sound-collage - - sounddelay - - soundgen - - source-code-server - - SourceGraph - - sousit - - soyuz - - SpaceInvaders - - spacepart - - SpacePrivateers - - spake2 - - spanout - - sparkle - - sparrow - - spars - - sparse - - sparse-lin-alg - - sparsebit - - sparsecheck - - sparser - - spata - - special-functors - - special-keys - - specialize-th - - species - - spectral-clustering - - speculation - - speculation-transformers - - speechmatics - - spelling-suggest - - sphero - - sphinx - - sphinx-cli - - sphinxesc - - spice - - SpinCounter - - spir-v - - spiros - - splay - - splaytree - - spline3 - - splines - - splint - - split-morphism - - splitter - - Spock - - Spock-api-ghcjs - - Spock-auth - - Spock-lucid - - Spock-worker - - spoonutil - - spoty - - Sprig - - sprinkles - - spritz - - sproxy - - sproxy-web - - sproxy2 - - spsa - - spy - - sql-simple - - sql-simple-mysql - - sql-simple-pool - - sql-simple-postgresql - - sql-simple-sqlite - - sqlcipher - - sqlite - - sqlite-simple-errors - - sqlite-simple-typed - - sqlvalue-list - - sqsd-local - - squeal-postgresql - - squeeze - - sr-extra - - srcinst - - sscan - - sscgi - - ssh - - ssh-tunnel - - sshd-lint - - sssp - - sstable - - SSTG - - st2 - - stable-heap - - stable-maps - - stable-marriage - - stable-memo - - stable-tree - - stack-bump - - stack-fix - - stack-hpc-coveralls - - stack-lib - - stack-network - - stack-prism - - stack-run - - stack-run-auto - - stack-type - - stack-wrapper - - stack2cabal - - stack2nix - - stackage - - stackage-build-plan - - stackage-cabal - - stackage-cli - - stackage-curator - - stackage-metadata - - stackage-query - - stackage-sandbox - - stackage-setup - - stackage-to-hackage - - stackage-types - - stackage-upload - - stackage2nix - - stackcollapse-ghc - - staged-gg - - standalone-derive-topdown - - standalone-haddock - - starling - - stash - - Stasis - - state - - state-bag - - state-plus - - state-record - - stateful-mtl - - static-canvas - - static-closure - - static-tensor - - static-text - - statistics-dirichlet - - statistics-fusion - - statistics-hypergeometric-genvar - - stats - - statsd - - statsd-client - - statsdi - - statvfs - - stb-image-redux - - stc-lang - - stdata - - stdf - - stdio - - steambrowser - - stego-uuid - - stemmer - - stemmer-german - - stepwise - - stern-brocot - - stgi - - STL - - STLinkUSB - - stm-chunked-queues - - stm-firehose - - stm-promise - - stm-stats - - STM32-Zombie - - stmcontrol - - stochastic - - StockholmAlignment - - stocks - - Stomp - - storable - - storable-static-array - - storablevector-streamfusion - - stp - - str - - Strafunski-ATermLib - - Strafunski-Sdf2Haskell - - Strafunski-StrategyLib - - StrappedTemplates - - stratum-tool - - stratux - - stratux-demo - - stratux-http - - stratux-types - - stratux-websockets - - stream - - stream-fusion - - stream-monad - - streamdeck - - streamed - - streaming-base64 - - streaming-benchmarks - - streaming-brotli - - streaming-cassava - - streaming-concurrency - - streaming-conduit - - streaming-events - - streaming-fft - - streaming-lzma - - streaming-osm - - streaming-pcap - - streaming-png - - streaming-process - - streaming-sort - - streaming-utils - - streaming-with - - streamly-fsnotify - - streamproc - - strelka - - strict-base-types - - strict-data - - strict-ghc-plugin - - strict-tuple-lens - - StrictBench - - StrictCheck - - strictly - - string-isos - - string-quote - - string-typelits - - stringlike - - stringtable-atom - - stripe - - stripe-hs - - stripe-http-streams - - stripe-scotty - - stripe-signature - - stripe-wreq - - strongswan-sql - - structural-induction - - structural-traversal - - structured-mongoDB - - structures - - stt - - stunclient - - stunts - - stutter - - stylish-cabal - - stylist - - stylized - - suavemente - - sub-state - - subhask - - subleq-toolchain - - submark - - subsample - - substring-parser - - subwordgraph - - successors - - suffix-array - - suffixarray - - SuffixStructures - - sugarhaskell - - suitable - - summoner - - summoner-tui - - sump - - sunlight - - sunroof-compiler - - sunroof-examples - - sunroof-server - - super-user-spark - - superbubbles - - supercollider-ht - - supercollider-midi - - superconstraints - - superevent - - supermonad - - supernova - - supero - - supervisor - - supplemented - - surjective - - sv - - sv-cassava - - sv-core - - sv-svfactor - - SVD2HS - - svfactor - - svg-builder-fork - - SVG2Q - - svg2q - - svgcairo - - svgone - - svgutils - - svm-light-utils - - svm-simple - - svndump - - swagger-petstore - - swagger-test - - swapper - - swearjure - - sweet-egison - - swf - - swift-lda - - swiss-ephemeris - - switch - - sws - - syb-extras - - syb-with-class-instances-text - - SybWidget - - syfco - - sylvia - - sym - - sym-plot - - symantic - - symantic-atom - - symantic-cli - - symantic-http - - symantic-http-client - - symantic-http-demo - - symantic-http-pipes - - symantic-http-server - - symantic-http-test - - symantic-lib - - symantic-parser - - symantic-xml - - symbiote - - symbolic-link - - symengine - - symengine-hs - - symmetry-operations-symbols - - sync - - sync-mht - - syncthing-hs - - syntactic - - syntax - - syntax-attoparsec - - syntax-example - - syntax-example-json - - syntax-pretty - - syntax-printer - - syntax-trees - - syntax-trees-fork-bairyn - - SyntaxMacros - - syntaxnet-haskell - - synthesizer - - synthesizer-llvm - - sys-process - - Sysmon - - system-canonicalpath - - system-command - - system-extra - - system-inotify - - system-lifted - - system-linux-proc - - system-locale - - system-random-effect - - systemstats - - t-regex - - t3-client - - t3-server - - ta - - table - - table-layout - - table-tennis - - tableaux - - Tables - - tables - - tablestorage - - Tablify - - tabloid - - tabs - - tag-bits - - tag-stream - - tagged-exception-core - - tagged-list - - tagged-th - - tagged-timers - - taglib-api - - tagsoup-ht - - tagsoup-megaparsec - - tagsoup-navigate - - tagsoup-parsec - - tagsoup-selection - - tagstew - - tai - - tai64 - - takahashi - - Takusen - - takusen-oracle - - tal - - tamarin-prover - - tamarin-prover-term - - tamarin-prover-theory - - tamarin-prover-utils - - Tape - - tapioca - - target - - task - - task-distribution - - TaskMonad - - tasty-auto - - tasty-bdd - - tasty-checklist - - tasty-fail-fast - - tasty-grading-system - - tasty-groundhog-converters - - tasty-hedgehog-coverage - - tasty-html - - tasty-integrate - - tasty-jenkins-xml - - tasty-laws - - tasty-lens - - tasty-mgolden - - tasty-silver - - tasty-stats - - tasty-test-vector - - tateti-tateti - - Taxonomy - - TaxonomyTools - - TBC - - TBit - - tbox - - tcache-AWS - - tccli - - tcod-haskell - - tcp - - tcp-streams-openssl - - tdd-util - - tdigest-Chart - - tdlib - - tdlib-gen - - tdlib-types - - tds - - TeaHS - - teams - - techlab - - teeth - - telegram - - telegram-api - - telegram-bot - - telegram-bot-simple - - telegram-raw-api - - telegram-types - - teleport - - teleshell - - tellbot - - tempi - - template-default - - template-haskell-util - - template-hsml - - template-yj - - templateify - - templatepg - - tempodb - - temporal-csound - - tempus - - tensor - - tensor-safe - - tensorflow - - tensorflow-core-ops - - tensorflow-logging - - tensorflow-opgen - - tensorflow-ops - - term-rewriting - - termbox-banana - - termbox-bindings - - terminal-text - - termination-combinators - - termplot - - terntup - - terraform-http-backend-pass - - terrahs - - tersmu - - tesla - - test-fixture - - test-framework-doctest - - test-framework-quickcheck - - test-framework-sandbox - - test-framework-skip - - test-framework-testing-feat - - test-framework-th-prime - - test-karya - - test-pkg - - test-sandbox - - test-sandbox-compose - - test-sandbox-hunit - - test-sandbox-quickcheck - - test-shouldbe - - test-simple - - testbench - - testCom - - testcontainers - - testloop - - testpack - - testpattern - - testrunner - - TeX-my-math - - tex2txt - - texbuilder - - texrunner - - text-all - - text-and-plots - - text-ascii - - text-containers - - text-format-heavy - - text-generic-pretty - - text-icu-normalized - - text-lens - - text-lips - - text-markup - - text-normal - - text-offset - - text-plus - - text-position - - text-register-machine - - text-replace - - text-trie - - text-utf8 - - text-utils - - text-xml-qq - - text-zipper-monad - - text1 - - textmatetags - - textocat-api - - textual - - tfp-th - - tftp - - tga - - th-alpha - - th-build - - th-context - - th-dict-discovery - - th-fold - - th-format - - th-instance-reification - - th-instances - - th-kinds - - th-kinds-fork - - th-lego - - th-pprint - - th-sccs - - th-tc - - th-to-exp - - th-traced - - th-typegraph - - thank-you-stars - - theatre - - thentos-cookie-session - - Theora - - theoremquest - - theoremquest-client - - thih - - thimk - - Thingie - - thock - - thorn - - threadmanager - - threepenny-editors - - threepenny-gui-contextmenu - - threepenny-gui-flexbox - - thrift - - throttled-io-loop - - thumbnail-plus - - thumbnail-polish - - tic-tac-toe - - tickle - - TicTacToe - - tictactoe3d - - tidal-midi - - tidal-serial - - tidal-vis - - tie-knot - - tiempo - - tiger - - tightrope - - tighttp - - timberc - - time-extras - - time-exts - - time-http - - time-io-access - - time-machine - - time-qq - - time-quote - - time-recurrence - - time-series - - time-series-lib - - time-w3c - - time-warp - - timecalc - - timemap - - timeout - - timeout-with-results - - timeparsers - - TimePiece - - timeprint - - timeseries - - timeutils - - timezone-detect - - timezone-olson-th - - timezone-unix - - tini - - tintin - - tiny-scheduler - - TinyLaunchbury - - tinyMesh - - tinytemplate - - TinyURL - - tinyXml - - tip-haskell-frontend - - tip-lib - - titan - - titan-debug-yampa - - titan-record-yampa - - Titim - - tkhs - - tkyprof - - tls-extra - - tlynx - - tmp-postgres - - tn - - to-haskell - - to-string-class - - to-string-instances - - toboggan - - todo - - todos - - tofromxml - - toilet - - token-limiter - - token-search - - tokenify - - tokenizer-streaming - - tokstyle - - toktok - - tokyocabinet-haskell - - tokyotyrant-haskell - - tomato-rubato-openal - - toml - - tonatona-google-server-api - - tonatona-persistent-postgresql - - tonatona-persistent-sqlite - - tonatona-servant - - too-many-cells - - toodles - - Top - - top - - topkata - - torch - - TORCS - - total-map - - TotalMap - - touched - - Tournament - - toxcore - - toxcore-c - - toxiproxy-haskell - - toysolver - - tpar - - tpb - - tptp - - trace - - trace-call - - trace-function-call - - traced - - tracetree - - tracing - - tracing-control - - tracked-files - - tracker - - trackit - - traction - - tracy - - traildb - - trajectory - - transactional-events - - transf - - transfer-db - - transformations - - TransformeR - - transformers-compose - - transformers-convert - - transformers-lift - - transformers-runnable - - TransformersStepByStep - - transient-universe - - transient-universe-tls - - translatable-intset - - translate - - translate-cli - - trasa - - trasa-client - - trasa-extra - - trasa-form - - trasa-server - - trasa-th - - traversal-template - - travis - - travis-meta-yaml - - trawl - - traypoweroff - - treap - - tree-render-text - - tree-traversals - - TreeCounter - - treemap - - treemap-html - - treemap-html-tools - - TreeStructures - - Treiber - - trek-app - - trek-db - - tremulous-query - - TrendGraph - - trhsx - - triangulation - - TrieMap - - tries - - trigger - - trim - - trimpolya - - tripLL - - trivia - - trivial-constraint - - tropical - - tropical-geometry - - true-name - - truelevel - - trurl - - tsession - - tsession-happstack - - tsp-viz - - tsparse - - tsuntsun - - tsvsql - - tsweb - - ttask - - tttool - - tubes - - tuntap - - tuntap-simple - - tup-functor - - tuple-gen - - tuple-lenses - - tuple-morph - - tuple-ops - - tupleinstances - - turing-machines - - turing-music - - turingMachine - - turtle-options - - TV - - tweak - - twee - - tweet-hs - - twentefp-eventloop-graphics - - twentefp-eventloop-trees - - twentefp-graphs - - twentefp-rosetree - - twentefp-trees - - twentefp-websockets - - twentyseven - - twfy-api-client - - twhs - - twidge - - twilight-stm - - twilio - - twill - - twine - - twirp - - twitter - - twitter-conduit - - twitter-enumerator - - twitter-feed - - tx - - txt - - txtblk - - TYB - - tyfam-witnesses - - typalyze - - type-assertions - - type-cache - - type-cereal - - type-combinators - - type-combinators-quote - - type-combinators-singletons - - type-digits - - type-eq - - type-fun - - type-indexed-queues - - type-int - - type-interpreter - - type-level-bst - - type-level-natural-number-induction - - type-level-natural-number-operations - - type-list - - type-of-html-static - - type-ord - - type-ord-spine-cereal - - type-prelude - - type-sets - - type-settheory - - type-spine - - type-structure - - type-sub-th - - type-tree - - type-unary - - typeable-th - - TypeClass - - typed-encoding - - typed-encoding-encoding - - typed-spreadsheet - - typed-streams - - typed-wire - - typedflow - - typedquery - - typehash - - TypeIlluminator - - typelevel - - typelevel-rewrite-rules - - typelevel-tensor - - TypeNat - - typenums - - typeparams - - types-compat - - typesafe-precure - - typescript-docs - - typograffiti - - typson-beam - - typson-esqueleto - - typson-selda - - tyro - - u2f - - uber - - uberlast - - ucam-webauth - - ucam-webauth-types - - ucd - - uconv - - udp-conduit - - udp-streaming - - uhc-light - - uhc-util - - uhexdump - - uhttpc - - ui-command - - UMM - - unagi-bloomfilter - - unamb-custom - - unbound - - unbounded-delays-units - - unboxed-containers - - unboxed-references - - unbreak - - unescaping-print - - unfix-binders - - uni-events - - uni-graphs - - uni-htk - - uni-posixutil - - uni-reactor - - uni-uDrawGraph - - uni-util - - unicode-normalization - - unicode-prelude - - unicode-show - - unicode-symbols - - unicode-tricks - - uniform-io - - union - - union-map - - uniprot-kb - - uniqueid - - uniquely-represented-sets - - uniqueness-periods-vector-examples - - uniqueness-periods-vector-properties - - units-attoparsec - - unittyped - - unitym-yesod - - universal-binary - - universe - - universe-instances-base - - universe-instances-extended - - universe-instances-trans - - universe-th - - unix-fcntl - - unix-handle - - unix-process-conduit - - unix-recursive - - unix-simple - - unlifted-list - - unliftio-messagebox - - unliftio-streams - - unm-hip - - unordered-containers-rematch - - unordered-graphs - - unordered-intmap - - unpack-funcs - - unpacked-either - - unpacked-maybe - - unpacked-maybe-numeric - - unpacked-these - - unpacked-validation - - unparse-attoparsec - - unroll-ghc-plugin - - unsafely - - unscramble - - unsequential - - unused - - uom-plugin - - up - - Updater - - uploadcare - - upskirt - - urbit-airlock - - urbit-api - - urbit-hob - - ureader - - urembed - - uri - - uri-conduit - - uri-encoder - - uri-enumerator - - uri-enumerator-file - - uri-parse - - uri-template - - uri-templater - - url-bytes - - url-decoders - - url-generic - - URLb - - urlcheck - - urldecode - - UrlDisp - - urldisp-happstack - - urlencoded - - urlpath - - URLT - - urn - - urn-random - - urxml - - usb - - usb-enumerator - - usb-hid - - usb-id-database - - usb-iteratee - - usb-safe - - userid - - users-mysql-haskell - - users-persistent - - utf - - utf8-prelude - - utf8-validator - - UTFTConverter - - util-exception - - util-logict - - util-plus - - util-primitive - - util-primitive-control - - util-universe - - uu-cco - - uu-cco-examples - - uu-cco-hut-parsing - - uu-cco-uu-parsinglib - - uuagc-bootstrap - - uuagc-diagrams - - uuid-aeson - - uuid-bytes - - uuid-crypto - - uvector - - uvector-algorithms - - uxadt - - v4l2 - - v4l2-examples - - vabal - - vabal-lib - - vacuum - - vacuum-cairo - - vacuum-graphviz - - vacuum-opengl - - vacuum-ubigraph - - valid-names - - validate-input - - validated-types - - Validation - - validations - - value-supply - - vampire - - var - - varan - - variable-precision - - variables - - variation - - vault-tool-server - - vault-trans - - vaultaire-common - - vcache - - vcache-trie - - vcard - - vcatt - - vcf - - vcsgui - - vcswrapper - - Vec-Boolean - - Vec-OpenGLRaw - - Vec-Transform - - vect-floating - - vect-floating-accelerate - - vect-opengl - - vector-bytestring - - vector-clock - - vector-conduit - - vector-endian - - vector-fftw - - vector-functorlazy - - vector-heterogenous - - vector-instances-collections - - vector-random - - vector-read-instances - - vector-space-map - - vector-space-opengl - - vector-space-points - - vector-static - - vector-text - - vega-view - - venzone - - Verba - - verbalexpressions - - verdict - - verdict-json - - verifiable-expressions - - verify - - verilog - - verismith - - versioning - - versioning-servant - - vflow-types - - vfr-waypoints - - vgrep - - vhd - - vhdl - - vicinity - - ViennaRNA-extras - - viewprof - - views - - vigilance - - Villefort - - vimeta - - vimus - - vintage-basic - - vinyl-json - - vinyl-named-sugar - - vinyl-operational - - vinyl-plus - - vinyl-utils - - vinyl-vectors - - virthualenv - - visibility - - vision - - visual-graphrewrite - - visual-prof - - visualize-cbn - - vitrea - - vk-aws-route53 - - VKHS - - vocoder - - vocoder-audio - - vocoder-conduit - - vocoder-dunai - - voicebase - - vowpal-utils - - voyeur - - vpq - - VRML - - vte - - vtegtk3 - - vty-examples - - vty-menu - - vty-ui - - vty-ui-extras - - vulkan-api - - waargonaut - - wacom-daemon - - waddle - - wahsp - - wai-cli - - wai-devel - - wai-git-http - - wai-graceful - - wai-handler-devel - - wai-handler-fastcgi - - wai-handler-hal - - wai-handler-scgi - - wai-handler-snap - - wai-handler-webkit - - wai-hmac-auth - - wai-lens - - wai-lite - - wai-logger-buffered - - wai-logger-prefork - - wai-make-assets - - wai-middleware-cache - - wai-middleware-cache-redis - - wai-middleware-catch - - wai-middleware-consul - - wai-middleware-content-type - - wai-middleware-crowd - - wai-middleware-delegate - - wai-middleware-etag - - wai-middleware-headers - - wai-middleware-hmac-client - - wai-middleware-preprocessor - - wai-middleware-rollbar - - wai-middleware-route - - wai-middleware-static-caching - - wai-middleware-travisci - - wai-middleware-validation - - wai-rate-limit-redis - - wai-request-spec - - wai-responsible - - wai-router - - wai-routes - - wai-routing - - wai-secure-cookies - - wai-session-alt - - wai-session-mysql - - wai-session-postgresql - - wai-session-redis - - wai-static-cache - - wai-thrift - - wai-throttler - - waitfree - - waitra - - waldo - - wallpaper - - warc - - warp-dynamic - - warp-grpc - - warp-static - - warp-systemd - - warped - - WashNGo - - wasm - - watchdog - - watcher - - watchit - - WAVE - - WaveFront - - wavefront - - wavefront-obj - - wavesurfer - - wavy - - weak-bag - - weather-api - - web-css - - web-encodings - - web-mongrel2 - - web-output - - web-page - - web-push - - web-rep - - web-routes-quasi - - web-routes-regular - - web-routes-transformers - - web-routing - - web3 - - webapi - - webapp - - webauthn - - WebBits - - WebBits-Html - - WebBits-multiplate - - webcloud - - WebCont - - webcrank - - webcrank-dispatch - - webcrank-wai - - webdriver-angular - - webdriver-snoy - - webdriver-w3c - - WeberLogic - - webfinger-client - - webify - - webkit-javascriptcore - - webmention - - Webrexp - - webserver - - webshow - - websockets-rpc - - webwire - - WEditor - - WEditorBrick - - WEditorHyphen - - weekdaze - - weighted - - weighted-regexp - - welshy - - werewolf - - werewolf-slack - - what4 - - Wheb - - wheb-mongo - - wheb-redis - - wheb-strapped - - while-lang-parser - - whim - - whiskers - - whitespace - - whois - - why3 - - wide-word - - wide-word-instances - - WikimediaParser - - wikipedia4epub - - wild-bind-indicator - - wild-bind-task-x11 - - windns - - windowslive - - winerror - - winery - - winio - - Wired - - wires - - wiring - - witty - - wkt - - wkt-geom - - wl-pprint-ansiterm - - wl-pprint-extras - - wl-pprint-terminfo - - WL500gPControl - - WL500gPLib - - wlc-hs - - WMSigner - - wobsurv - - woe - - woffex - - wol - - wolf - - word - - word2vec-model - - WordAlignment - - wordchoice - - wordify - - wordlist - - WordNet - - WordNet-ghc74 - - wordpass - - wordpress-auth - - wordsearch - - work-time - - workdays - - Workflow - - workflow-extra - - workflow-osx - - workflow-pure - - workflow-types - - workflow-windows - - wp-archivebot - - wraxml - - wrecker - - wrecker-ui - - wreq-patchable - - wreq-sb - - wright - - writer-cps-full - - writer-cps-lens - - writer-cps-monads-tf - - writer-cps-morph - - ws - - wsdl - - wsedit - - wshterm - - wsjtx-udp - - wss-client - - wtk - - wtk-gtk - - wu-wei - - wumpus-basic - - wumpus-core - - wumpus-drawing - - wumpus-microprint - - wumpus-tree - - WURFL - - wxAsteroids - - WXDiffCtrl - - wxdirect - - wxFruit - - WxGeneric - - wxhnotepad - - wxSimpleCanvas - - wxturtle - - wyvern - - x-dsp - - X11-extras - - X11-rm - - X11-xdamage - - X11-xfixes - - xchat-plugin - - xcp - - xdcc - - xdot - - Xec - - xenstore - - xfconf - - xformat - - xhaskell-library - - xhb - - xhb-atom-cache - - xhb-ewmh - - xilinx-lava - - xine - - xing-api - - xkbcommon - - xkcd - - xleb - - xls - - xlsior - - xlsx-tabular - - xlsx-templater - - xml-catalog - - xml-conduit-decode - - xml-conduit-selectors - - xml-conduit-stylist - - xml-enumerator - - xml-enumerator-combinators - - xml-html-conduit-lens - - xml-monad - - xml-parsec - - xml-pipe - - xml-prettify - - xml-push - - xml-query - - xml-query-xml-conduit - - xml-query-xml-types - - xml-tydom-conduit - - xml-tydom-core - - xml2json - - xml2x - - XmlHtmlWriter - - xmltv - - XMMS - - xmms2-client - - xmms2-client-glib - - xmonad-bluetilebranch - - xmonad-contrib-bluetilebranch - - xmonad-contrib-gpl - - xmonad-dbus - - xmonad-eval - - xmonad-vanessa - - xmonad-windownames - - xmpipe - - XMPP - - xor - - xorshift-plus - - Xorshift128Plus - - xournal-builder - - xournal-convert - - xournal-parser - - xournal-render - - xournal-types - - xrefcheck - - xsact - - XSaiga - - xsd - - xslt - - xtc - - xxhash - - y0l0bot - - yabi-muno - - Yablog - - yackage - - YACPong - - yahoo-finance-api - - yahoo-finance-conduit - - yahoo-prices - - yahoo-web-search - - yajl - - yajl-enumerator - - yall - - yam - - yam-config - - yam-datasource - - yam-logger - - yam-redis - - yam-servant - - yam-transaction - - yam-transaction-odbc - - yam-web - - yaml-pretty-extras - - yaml-rpc - - yaml-rpc-scotty - - yaml-rpc-snap - - yaml-unscrambler - - YamlReference - - yampa-glfw - - yampa-gloss - - yampa-glut - - yampa-sdl2 - - yampa-test - - yampa2048 - - YampaSynth - - yandex-translate - - yaop - - yap - - yarr - - yarr-image-io - - yasi - - yavie - - yaya-test - - yaya-unsafe-test - - ycextra - - yeamer - - yeller - - yeshql - - yeshql-hdbc - - yeshql-postgresql-simple - - yesod-angular - - yesod-angular-ui - - yesod-articles - - yesod-auth-account - - yesod-auth-account-fork - - yesod-auth-bcrypt - - yesod-auth-bcryptdb - - yesod-auth-deskcom - - yesod-auth-hmac-keccak - - yesod-auth-kerberos - - yesod-auth-ldap - - yesod-auth-ldap-mediocre - - yesod-auth-ldap-native - - yesod-auth-lti13 - - yesod-auth-nopassword - - yesod-auth-oauth2 - - yesod-auth-pam - - yesod-auth-smbclient - - yesod-auth-zendesk - - yesod-bootstrap - - yesod-colonnade - - yesod-comments - - yesod-content-pdf - - yesod-continuations - - yesod-crud - - yesod-crud-persist - - yesod-datatables - - yesod-dsl - - yesod-examples - - yesod-fast-devel - - yesod-fay - - yesod-filter - - yesod-form-richtext - - yesod-gitrev - - yesod-goodies - - yesod-ip - - yesod-job-queue - - yesod-links - - yesod-lucid - - yesod-mangopay - - yesod-markdown - - yesod-page-cursor - - yesod-paginate - - yesod-pagination - - yesod-paypal-rest - - yesod-platform - - yesod-pnotify - - yesod-pure - - yesod-purescript - - yesod-raml - - yesod-raml-bin - - yesod-raml-docs - - yesod-raml-mock - - yesod-recaptcha - - yesod-routes - - yesod-routes-flow - - yesod-routes-typescript - - yesod-rst - - yesod-s3 - - yesod-sass - - yesod-session-redis - - yesod-static-angular - - yesod-static-remote - - yesod-test-json - - yesod-tls - - yesod-vend - - yesod-worker - - YFrob - - yggdrasil - - yhccore - - yhseq - - yi-contrib - - yi-monokai - - yi-solarized - - yi-spolsky - - yices - - yjftp - - yjftp-libs - - yoctoparsec - - yoda - - Yogurt - - Yogurt-Standalone - - yoko - - york-lava - - yql - - yst - - yu-auth - - yu-core - - yu-launch - - yu-tool - - yu-utils - - yuuko - - yx - - yxdb-utils - - Z-Data - - Z-IO - - Z-MessagePack - - Z-YAML - - z3-encoding - - z85 - - zabt - - zampolit - - zasni-gerna - - zbar - - ZEBEDDE - - zendesk-api - - zenhack-prelude - - zeno - - zephyr - - zerobin - - zeromq-haskell - - zeromq3-conduit - - zeromq3-haskell - - zeromq4-clone-pattern - - zeromq4-conduit - - zeromq4-patterns - - zeroth - - zettelkast - - ZFS - - zifter - - zifter-cabal - - zifter-git - - zifter-google-java-format - - zifter-hindent - - zifter-hlint - - zifter-stack - - zigbee-znet25 - - zip-conduit - - zipedit - - zipkin - - zipper - - zippo - - ziptastic-client - - ziptastic-core - - zlib-enum - - zm - - ZMachine - - zmcat - - zmidi-score - - zoneinfo - - zoom - - zoom-cache - - zoom-cache-pcm - - zoom-cache-sndfile - - zoom-refs - - zoovisitor - - zsdd - - zsh-battery - - zsyntax - - ztar - - zuramaru - - Zwaluw - - zxcvbn-dvorak diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index a8ccc4f3851..2fc79af79b6 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -3,120 +3,30 @@ # It is supposed to list all haskellPackages that cannot evaluate because they # depend on a dependency marked as broken. dont-distribute-packages: - - AesonBson - - HGamer3D-API - - HGamer3D-CAudio-Binding - - HGamer3D-OIS-Binding - - HipmunkPlayground - - Holumbus-Distribution - - Holumbus-MapReduce - - Holumbus-Storage - - KiCS - - KiCS-debugger - - KiCS-prophecy - - RESTng - - ViennaRNA-bindings + - ASN1 - XML - - acme-safe - - aeson-bson - - approx-rand-test - - barley - - bson-mapping - - bv-sized-lens - - clash-prelude-quickcheck - - click-clack - - cloudyfs - - cognimeta-utils - comark - - comonad-random - - containers-accelerate - - definitive-graphics - - ecdsa - - effective-aspects-mzv - - eliminators_0_8 - - fltkhs-demos - - fltkhs-fluid-demos - - fltkhs-hello-world - - fltkhs-themes - - fluent-logger-conduit - - gi-gtk_4_0_4 - - goat - - gridfs + - frame-markdown + - git-remote-ipfs - gsmenu - - gtk2hs-cast-glade - - gtk2hs-cast-gnomevfs - - gtk2hs-cast-gtkglext - - gtk2hs-cast-gtksourceview2 - - hakyll-contrib-i18n - - hascat - - hascat-lib - - hascat-setup - - hascat-system + - hails-bin + - hakyll-elm + - haskelm - haste-gapi - haste-perch - - hatexmpp3 - hplayground - - hs2dot - - hsqml-datamodel-vinyl - - hsqml-demo-morris - - hsqml-morris - - hubris - - hxt-binary - - hxt-filter - imprevu-happstack - - javaclass - - keera-posture - - lambdabot-xmpp - - leksah - - liquidhaskell-cabal-demo - - mp3decoder - - network-pgi + - ipld-cid + - multibase + - multihash-serialise - nomyx-api - nomyx-core - nomyx-language - nomyx-library - nomyx-server - - one-liner_2_0 - - openpgp-crypto-api - - patch-image - - perdure - - persistent-mysql_2_13_0_0 - - persistent-postgresql_2_13_0_0 - - persistent-sqlite_2_13_0_0 - - pontarius-mediaserver - - pontarius-xmpp-extras - - pontarius-xpmn - - procrastinating-structure - - reactive - - redHandlers - - reflex-dom-colonnade - - regex-genex - - ribosome - - ribosome-root - - ribosome-test - - ripple - - robot - - roguestar-engine - - roguestar-gl - - roguestar-glut - - route-generator - - sc2hs - - sexpresso - shine-varying - - singleton-nats_0_4_6 - - smtp2mta + - snap-elm + - snaplet-lss - sneathlane-haste - - sock2stream - - starrover2 - - text-xml-generic - - trasa-reflex - treersec - - tuple-hlist - - wai-dispatch - - wai-hastache - - wai-middleware-brotli - - wai-session-tokyocabinet - - wx - - wxc - - wxcore diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 24849b1e5ba..5e4c95a3283 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -28,8 +28,6 @@ self: { ]; description = "3D model parsers"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "4Blocks" = callPackage @@ -45,8 +43,6 @@ self: { ]; description = "A tetris-like game (works with GHC 6.8.3 and Gtk2hs 0.9.13)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AAI" = callPackage @@ -58,8 +54,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Abstract Application Interface"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ABList" = callPackage @@ -110,8 +104,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Detect which OS you're running on"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AC-Colour" = callPackage @@ -134,8 +126,6 @@ self: { libraryHaskellDepends = [ array base gtk ]; description = "GTK+ pixel plotting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AC-HalfInteger" = callPackage @@ -149,8 +139,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Efficient half-integer type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AC-MiniTest" = callPackage @@ -164,8 +152,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A simple test framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AC-PPM" = callPackage @@ -201,8 +187,6 @@ self: { libraryHaskellDepends = [ ansi-terminal base ]; description = "Trivial wrapper over ansi-terminal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AC-VanillaArray" = callPackage @@ -214,8 +198,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Immutable arrays with plain integer indicies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AC-Vector" = callPackage @@ -229,8 +211,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Efficient geometric vectors and transformations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AC-Vector-Fancy" = callPackage @@ -242,8 +222,6 @@ self: { libraryHaskellDepends = [ AC-Angle AC-Vector base ]; description = "Fancy type-system stuff for AC-Vector"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ACME" = callPackage @@ -259,8 +237,6 @@ self: { ]; description = "Essential features"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ADPfusion" = callPackage @@ -288,8 +264,6 @@ self: { ]; description = "Efficient, high-level dynamic programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ADPfusionForest" = callPackage @@ -316,8 +290,6 @@ self: { benchmarkHaskellDepends = [ base criterion ForestStructures ]; description = "Dynamic programming on tree and forest structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ADPfusionSet" = callPackage @@ -342,8 +314,6 @@ self: { ]; description = "Dynamic programming for Set data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AERN-Basics" = callPackage @@ -363,8 +333,6 @@ self: { executableHaskellDepends = [ base containers directory ]; description = "foundational type classes for approximating exact real numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AERN-Net" = callPackage @@ -380,8 +348,6 @@ self: { ]; description = "Compositional lazy dataflow networks for exact real number computation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AERN-Real" = callPackage @@ -398,8 +364,6 @@ self: { ]; description = "arbitrary precision real interval arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AERN-Real-Double" = callPackage @@ -423,8 +387,6 @@ self: { ]; description = "arbitrary precision real interval arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AERN-Real-Interval" = callPackage @@ -441,8 +403,6 @@ self: { ]; description = "arbitrary precision real interval arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AERN-RnToRm" = callPackage @@ -459,8 +419,6 @@ self: { ]; description = "polynomial function enclosures (PFEs) approximating exact real functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AERN-RnToRm-Plot" = callPackage @@ -478,8 +436,6 @@ self: { ]; description = "GL plotting of polynomial function enclosures (PFEs)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AES" = callPackage @@ -521,8 +477,6 @@ self: { ]; description = "A library for writing AGI scripts for Asterisk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ALUT" = callPackage @@ -552,8 +506,6 @@ self: { ]; description = "Low-level bindings for Asterisk Manager Interface (AMI)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ANum" = callPackage @@ -582,7 +534,6 @@ self: { description = "ASN.1 support for Haskell"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AVar" = callPackage @@ -617,8 +568,6 @@ self: { libraryHaskellDepends = [ AbortT-transformers base monads-tf ]; description = "Monads-tf instances for the AbortT monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AbortT-mtl" = callPackage @@ -630,8 +579,6 @@ self: { libraryHaskellDepends = [ AbortT-transformers base mtl ]; description = "mtl instances for the AbortT monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AbortT-transformers" = callPackage @@ -649,8 +596,6 @@ self: { ]; description = "A monad and monadic transformer providing \"abort\" functionality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ActionKid" = callPackage @@ -674,8 +619,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "An easy-to-use video game framework for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Adaptive" = callPackage @@ -691,8 +634,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Library for incremental computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Adaptive-Blaisorblade" = callPackage @@ -707,8 +648,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Library for incremental computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Advgame" = callPackage @@ -722,8 +661,6 @@ self: { executableHaskellDepends = [ base haskell98 mtl ]; description = "Lisperati's adventure game in Lisp translated to Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Advise-me" = callPackage @@ -753,8 +690,6 @@ self: { ]; description = "Assessment services for the Advise-Me project"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AesonBson" = callPackage @@ -791,8 +726,6 @@ self: { ]; description = "Generator-generator for QuickCheck"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Agda" = callPackage @@ -855,8 +788,6 @@ self: { ]; description = "Aho-Corasick string matching algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AlanDeniseEricLauren" = callPackage @@ -878,8 +809,6 @@ self: { benchmarkHaskellDepends = [ base containers criterion ]; description = "Find the minimal subset/submap satisfying some property"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AlgoRhythm" = callPackage @@ -908,8 +837,6 @@ self: { ]; description = "Algorithmic music composition"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AlgorithmW" = callPackage @@ -923,8 +850,6 @@ self: { executableHaskellDepends = [ base containers mtl pretty ]; description = "Example implementation of Algorithm W for Hindley-Milner type inference"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AlignmentAlgorithms" = callPackage @@ -941,8 +866,6 @@ self: { ]; description = "Collection of alignment algorithms"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Allure" = callPackage @@ -971,8 +894,6 @@ self: { ]; description = "Near-future Sci-Fi roguelike and tactical squad combat game"; license = lib.licenses.agpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AndroidViewHierarchyImporter" = callPackage @@ -992,8 +913,6 @@ self: { ]; description = "Android view hierarchy importer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Animas" = callPackage @@ -1005,8 +924,6 @@ self: { libraryHaskellDepends = [ base random ]; description = "Updated version of Yampa: a library for programming hybrid systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Annotations" = callPackage @@ -1019,8 +936,6 @@ self: { testHaskellDepends = [ base mtl multirec parsec ]; description = "Constructing, analyzing and destructing annotated trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Ansi2Html" = callPackage @@ -1066,8 +981,6 @@ self: { executableHaskellDepends = [ base ]; description = "Library for Apple Push Notification Service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AppleScript" = callPackage @@ -1079,8 +992,6 @@ self: { doHaddock = false; description = "Call AppleScript from Haskell, and then call back into Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ApproxFun-hs" = callPackage @@ -1092,8 +1003,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Function approximation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ArrayRef" = callPackage @@ -1105,8 +1014,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Unboxed references, dynamic arrays and more"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ArrowVHDL" = callPackage @@ -1118,8 +1025,6 @@ self: { libraryHaskellDepends = [ base process ]; description = "A library to generate Netlist code from Arrow descriptions"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AspectAG" = callPackage @@ -1155,8 +1060,6 @@ self: { ]; description = "Fast Bencode encoding and parsing library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AttoJson" = callPackage @@ -1173,8 +1076,6 @@ self: { ]; description = "Simple lightweight JSON parser, generator & manipulator based on ByteString"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Attrac" = callPackage @@ -1190,8 +1091,6 @@ self: { ]; description = "Visualisation of Strange Attractors in 3-Dimensions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Aurochs" = callPackage @@ -1205,8 +1104,6 @@ self: { executableHaskellDepends = [ base containers parsec pretty ]; description = "Yet another parser generator for C/C++"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AutoForms" = callPackage @@ -1222,8 +1119,6 @@ self: { ]; description = "GUI library based upon generic programming (SYB3)"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "AvlTree" = callPackage @@ -1235,8 +1130,6 @@ self: { libraryHaskellDepends = [ base COrdering ]; description = "Balanced binary trees using the AVL algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BASIC" = callPackage @@ -1248,8 +1141,6 @@ self: { libraryHaskellDepends = [ base containers llvm random timeit ]; description = "Embedded BASIC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BCMtools" = callPackage @@ -1276,8 +1167,6 @@ self: { ]; description = "Big Contact Map Tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BNFC" = callPackage @@ -1337,8 +1226,6 @@ self: { libraryHaskellDepends = [ base cairo containers mtl ]; description = "Tools for self-assembly"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Bang" = callPackage @@ -1354,8 +1241,6 @@ self: { ]; description = "A Drum Machine DSL for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Barracuda" = callPackage @@ -1384,8 +1269,6 @@ self: { ]; description = "An ad-hoc P2P chat program"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Befunge93" = callPackage @@ -1399,8 +1282,6 @@ self: { executableHaskellDepends = [ array base mtl random ]; description = "An interpreter for the Befunge-93 Programming Language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BenchmarkHistory" = callPackage @@ -1418,8 +1299,6 @@ self: { ]; description = "Benchmark functions with history"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BerkeleyDB" = callPackage @@ -1446,8 +1325,6 @@ self: { librarySystemDepends = [ db dbxml xercesc xqilla ]; description = "Berkeley DB XML binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) db; inherit (pkgs) dbxml; inherit (pkgs) xercesc; inherit (pkgs) xqilla;}; @@ -1460,8 +1337,6 @@ self: { libraryHaskellDepends = [ base besout ]; description = "Factorization of polynomials over finite field"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiGUL" = callPackage @@ -1476,8 +1351,6 @@ self: { ]; description = "The Bidirectional Generic Update Language"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BigPixel" = callPackage @@ -1509,8 +1382,6 @@ self: { ]; description = "Source-to-source plugin for enhancing EDSLs with static annotations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Binpack" = callPackage @@ -1539,8 +1410,6 @@ self: { ]; description = "Libary for Hidden Markov Models in HMMER3 format"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Biobase" = callPackage @@ -1562,8 +1431,6 @@ self: { ]; description = "Base library for bioinformatics"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseBlast" = callPackage @@ -1590,8 +1457,6 @@ self: { ]; description = "BLAST-related tools"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseDotP" = callPackage @@ -1603,8 +1468,6 @@ self: { libraryHaskellDepends = [ base bytestring iteratee ]; description = "Vienna / DotBracket / ExtSS parsers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseENA" = callPackage @@ -1627,8 +1490,6 @@ self: { ]; description = "European Nucleotide Archive data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseEnsembl" = callPackage @@ -1646,8 +1507,6 @@ self: { ]; description = "Ensembl related datastructures and functions"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseFR3D" = callPackage @@ -1663,8 +1522,6 @@ self: { ]; description = "Importer for FR3D resources"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseFasta" = callPackage @@ -1689,8 +1546,6 @@ self: { ]; description = "streaming FASTA parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseHTTP" = callPackage @@ -1708,8 +1563,6 @@ self: { ]; description = "Libary to interface with the Bioinformatics HTTP services - Entrez Ensembl"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseHTTPTools" = callPackage @@ -1730,8 +1583,6 @@ self: { ]; description = "Tools to query Bioinformatics HTTP services e.g. Entrez, Ensembl."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseInfernal" = callPackage @@ -1770,8 +1621,6 @@ self: { ]; description = "Infernal data structures and tools"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseMAF" = callPackage @@ -1783,8 +1632,6 @@ self: { libraryHaskellDepends = [ base bytestring containers iteratee ]; description = "Multiple Alignment Format"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseNewick" = callPackage @@ -1812,8 +1659,6 @@ self: { ]; description = "Newick file format parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseTrainingData" = callPackage @@ -1833,8 +1678,6 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "RNA folding training data"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseTurner" = callPackage @@ -1852,8 +1695,6 @@ self: { ]; description = "Import Turner RNA parameters"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseTypes" = callPackage @@ -1886,8 +1727,6 @@ self: { ]; description = "Collection of types for bioinformatics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseVienna" = callPackage @@ -1903,8 +1742,6 @@ self: { ]; description = "Import Vienna energy parameters"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BiobaseXNA" = callPackage @@ -1946,8 +1783,6 @@ self: { ]; description = "Efficient RNA/DNA/Protein Primary/Secondary Structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BirdPP" = callPackage @@ -1961,8 +1796,6 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "A preprocessor for Bird-style Literate Haskell comments with Haddock markup"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BitStringRandomMonad" = callPackage @@ -1982,8 +1815,6 @@ self: { transformers vector ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BitSyntax" = callPackage @@ -1997,8 +1828,6 @@ self: { ]; description = "A module to aid in the (de)serialisation of binary data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Bitly" = callPackage @@ -2010,8 +1839,6 @@ self: { libraryHaskellDepends = [ base HTTP json2 ]; description = "A library to access bit.ly URL shortener."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BlastHTTP" = callPackage @@ -2029,8 +1856,6 @@ self: { ]; description = "Libary to interface with the NCBI blast REST interface"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Blobs" = callPackage @@ -2052,8 +1877,6 @@ self: { ]; description = "Diagram editor"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BlogLiterately" = callPackage @@ -2078,8 +1901,6 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "A tool for posting Haskelly articles to blogs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BlogLiterately-diagrams" = callPackage @@ -2101,8 +1922,6 @@ self: { executableHaskellDepends = [ base BlogLiterately ]; description = "Include images in blog posts with inline diagrams code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Blogdown" = callPackage @@ -2131,8 +1950,6 @@ self: { ]; description = "A markdown-like markup language designed for blog posts"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BluePrintCSS" = callPackage @@ -2155,8 +1972,6 @@ self: { doHaddock = false; description = "Preview of a new build system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Bookshelf" = callPackage @@ -2177,8 +1992,6 @@ self: { testHaskellDepends = [ base process ]; description = "A simple document organizer with some wiki functionality"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Boolean" = callPackage @@ -2217,8 +2030,6 @@ self: { ]; description = "Static text template generation library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "BufferedSocket" = callPackage @@ -2230,8 +2041,6 @@ self: { libraryHaskellDepends = [ base bytestring network text ]; description = "A socker wrapper that makes the IO of sockets much cleaner"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Buster" = callPackage @@ -2256,8 +2065,6 @@ self: { ]; description = "Hits a set of urls periodically to bust caches"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "C-structs" = callPackage @@ -2296,8 +2103,6 @@ self: { ]; description = "Encode/Decode values to/from CBOR"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CC-delcont" = callPackage @@ -2327,8 +2132,6 @@ self: { doHaddock = false; description = "Three new monad transformers for multi-prompt delimited control"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CC-delcont-cxe" = callPackage @@ -2340,8 +2143,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformers for multi-prompt delimited control"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CC-delcont-exc" = callPackage @@ -2353,8 +2154,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformers for multi-prompt delimited control"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CC-delcont-ref" = callPackage @@ -2366,8 +2165,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformers for multi-prompt delimited control using refercence cells"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CC-delcont-ref-tf" = callPackage @@ -2379,8 +2176,6 @@ self: { libraryHaskellDepends = [ base ref-tf transformers ]; description = "A monad transformers for multi-prompt delimited control using refercence cells"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CCA" = callPackage @@ -2398,8 +2193,6 @@ self: { executableToolDepends = [ happy ]; description = "preprocessor and library for Causal Commutative Arrows (CCA)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CHXHtml" = callPackage @@ -2429,8 +2222,6 @@ self: { ]; description = "Cursor Library for A Structured Editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CLI" = callPackage @@ -2443,8 +2234,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "CLI tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CMCompare" = callPackage @@ -2463,8 +2252,6 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "Infernal covariance model comparison"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CMQ" = callPackage @@ -2481,8 +2268,6 @@ self: { ]; description = "cwmwl udp message queue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "COrdering" = callPackage @@ -2494,8 +2279,6 @@ self: { libraryHaskellDepends = [ base ]; description = "An algebraic data type similar to Prelude Ordering"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CPBrainfuck" = callPackage @@ -2510,8 +2293,6 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "A simple Brainfuck interpretter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CPL" = callPackage @@ -2527,8 +2308,6 @@ self: { ]; description = "An interpreter of Hagino's Categorical Programming Language (CPL)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CSPM-CoreLanguage" = callPackage @@ -2556,8 +2335,6 @@ self: { ]; description = "Firing rules semantic of CSPM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CSPM-Frontend" = callPackage @@ -2575,8 +2352,6 @@ self: { libraryToolDepends = [ alex ]; description = "A CSP-M parser compatible with FDR-2.91"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CSPM-Interpreter" = callPackage @@ -2593,8 +2368,6 @@ self: { ]; description = "An interpreter for CSPM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CSPM-ToProlog" = callPackage @@ -2608,8 +2381,6 @@ self: { ]; description = "some modules specific for the ProB tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CSPM-cspm" = callPackage @@ -2635,8 +2406,6 @@ self: { ]; description = "cspm command line tool for analyzing CSPM specifications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CTRex" = callPackage @@ -2681,8 +2450,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "OpenCV based machine vision library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {opencv_calib3d = null; opencv_contrib = null; opencv_core = null; opencv_features2d = null; opencv_flann = null; opencv_gpu = null; opencv_highgui = null; opencv_imgproc = null; @@ -2832,8 +2599,6 @@ self: { ]; description = "A framework for packaging Haskell software"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CabalSearch" = callPackage @@ -2851,8 +2616,6 @@ self: { ]; description = "Search cabal packages by name"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Capabilities" = callPackage @@ -2864,8 +2627,6 @@ self: { libraryHaskellDepends = [ base compdata directory free unix ]; description = "Separate and contain effects of IO monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Cardinality" = callPackage @@ -2888,8 +2649,6 @@ self: { libraryHaskellDepends = [ base containers fgl parsec ]; description = "An implementation and DSL for the Carneades argumentation model"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CarneadesIntoDung" = callPackage @@ -2906,8 +2665,6 @@ self: { ]; description = "A translation from the Carneades argumentation model into Dung's AFs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Cartesian" = callPackage @@ -2919,8 +2676,6 @@ self: { libraryHaskellDepends = [ base lens linear template-haskell ]; description = "Coordinate systems"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Cascade" = callPackage @@ -2932,8 +2687,6 @@ self: { libraryHaskellDepends = [ base comonad ghc-prim mtl void ]; description = "Playing with reified categorical composition"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Cassava" = callPackage @@ -2960,8 +2713,6 @@ self: { ]; description = "A CSV parsing and encoding library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Catana" = callPackage @@ -2973,8 +2724,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad for complex manipulation of a stream"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ChannelT" = callPackage @@ -3063,8 +2812,6 @@ self: { ]; description = "A backend for the Chart library for FLTKHS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Chart-gtk" = callPackage @@ -3113,8 +2860,6 @@ self: { ]; description = "A wrapper for the chart library to assist with basic plots (Deprecated - use the Easy module instead)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Chart-tests" = callPackage @@ -3184,8 +2929,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "Inbuilt checking for ultra reliable computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Chitra" = callPackage @@ -3199,8 +2942,6 @@ self: { executableHaskellDepends = [ base binary bytestring mtl network ]; description = "A platform independent mechanism to render graphics using vnc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ChristmasTree" = callPackage @@ -3216,8 +2957,6 @@ self: { ]; description = "Alternative approach of 'read' that composes grammars instead of parsers"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CirruParser" = callPackage @@ -3251,8 +2990,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ClassLaws" = callPackage @@ -3264,8 +3001,6 @@ self: { libraryHaskellDepends = [ base ChasingBottoms mtl QuickCheck ]; description = "Stating and checking laws for type class methods"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ClassyPrelude" = callPackage @@ -3277,8 +3012,6 @@ self: { libraryHaskellDepends = [ base strict ]; description = "Prelude replacement using classes instead of concrete types where reasonable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Clean" = callPackage @@ -3290,8 +3023,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A light, clean and powerful utility library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Clipboard" = callPackage @@ -3323,8 +3054,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Libary for parsing Clustal tools output"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Coadjute" = callPackage @@ -3342,8 +3071,6 @@ self: { ]; description = "A generic build tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Codec-Compression-LZF" = callPackage @@ -3411,8 +3138,6 @@ self: { ]; description = "A concurrent bittorrent client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Command" = callPackage @@ -3424,8 +3149,6 @@ self: { libraryHaskellDepends = [ base directory process ]; description = "A replacement for System.Exit and System.Process"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Commando" = callPackage @@ -3448,8 +3171,6 @@ self: { ]; description = "Watch some files; Rerun a command"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ComonadSheet" = callPackage @@ -3467,8 +3188,6 @@ self: { ]; description = "A library for expressing spreadsheet-like computations as the fixed-points of comonads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Compactable" = callPackage @@ -3480,8 +3199,6 @@ self: { libraryHaskellDepends = [ base containers transformers vector ]; description = "A generalization for containers that can be stripped of Nothing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ConClusion" = callPackage @@ -3504,8 +3221,6 @@ self: { ]; description = "Cluster algorithms, PCA, and chemical conformere analysis"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Concurrent-Cache" = callPackage @@ -3517,8 +3232,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A Cached variable for IO functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Concurrential" = callPackage @@ -3530,8 +3243,6 @@ self: { libraryHaskellDepends = [ async base ]; description = "Mix concurrent and sequential computation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Condor" = callPackage @@ -3553,8 +3264,6 @@ self: { ]; description = "Information retrieval library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ConfigFile" = callPackage @@ -3581,8 +3290,6 @@ self: { ]; description = "Template haskell for reading ConfigFiles"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Configger" = callPackage @@ -3594,8 +3301,6 @@ self: { libraryHaskellDepends = [ base Dangerous MissingH mtl parsec ]; description = "Parse config files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Configurable" = callPackage @@ -3607,8 +3312,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Declare types as Configurable then specialize them all in one place"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ConsStream" = callPackage @@ -3633,8 +3336,6 @@ self: { executableHaskellDepends = [ base process ]; description = "Restart a command on STDIN activity"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ConstraintKinds" = callPackage @@ -3646,8 +3347,6 @@ self: { libraryHaskellDepends = [ base dlist ghc-prim vector ]; description = "Repackages standard type classes with the ConstraintKinds extension"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Consumer" = callPackage @@ -3659,8 +3358,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad and monad transformer for consuming streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ContArrow" = callPackage @@ -3672,8 +3369,6 @@ self: { libraryHaskellDepends = [ arrows base ]; description = "Control.Arrow.Transformer.Cont"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ContextAlgebra" = callPackage @@ -3691,8 +3386,6 @@ self: { ]; description = "Implementation of the context algebra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Contract" = callPackage @@ -3704,8 +3397,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Practical typed lazy contracts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Control-Engine" = callPackage @@ -3737,8 +3428,6 @@ self: { ]; description = "A Library for Writing Multi-Pass Algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Control-Monad-ST2" = callPackage @@ -3756,8 +3445,6 @@ self: { ]; description = "A variation on the ST monad with two type parameters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CoreDump" = callPackage @@ -3769,8 +3456,6 @@ self: { libraryHaskellDepends = [ base ghc pretty pretty-show ]; description = "A GHC plugin for printing GHC's internal Core data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CoreErlang" = callPackage @@ -3782,8 +3467,6 @@ self: { libraryHaskellDepends = [ base parsec pretty ]; description = "Manipulating Core Erlang source code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CoreFoundation" = callPackage @@ -3802,8 +3485,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to Mac OSX's CoreFoundation framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Coroutine" = callPackage @@ -3815,8 +3496,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Type-safe coroutines using lightweight session types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "CouchDB" = callPackage @@ -3837,8 +3516,6 @@ self: { ]; description = "CouchDB interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Craft3e" = callPackage @@ -3855,8 +3532,6 @@ self: { doHaddock = false; description = "Code for Haskell: the Craft of Functional Programming, 3rd ed"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Crypto" = callPackage @@ -3911,8 +3586,6 @@ self: { ]; description = "CurryDB: In-memory Key/Value Database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DAG-Tournament" = callPackage @@ -3930,8 +3603,6 @@ self: { ]; description = "Real-Time Game Tournament Evaluator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DAV" = callPackage @@ -3988,8 +3659,6 @@ self: { ]; description = "DBFunctor - Functional Data Management => ETL/ELT Data Processing in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DBlimited" = callPackage @@ -4003,8 +3672,6 @@ self: { executableHaskellDepends = [ base containers parsec ]; description = "A command-line SQL interface for flat files (tdf,csv,etc.)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DBus" = callPackage @@ -4016,8 +3683,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "D-Bus bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DCFL" = callPackage @@ -4042,8 +3707,6 @@ self: { executableHaskellDepends = [ base MuCheck ]; description = "Distributed Mutation Analysis framework for MuCheck"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DOH" = callPackage @@ -4080,8 +3743,6 @@ self: { libraryHaskellDepends = [ base mtl WebBits ]; description = "DOM Level 2 bindings for the WebBits package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DP" = callPackage @@ -4097,8 +3758,6 @@ self: { ]; description = "Pragmatic framework for dynamic programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DPM" = callPackage @@ -4122,8 +3781,6 @@ self: { executableHaskellDepends = [ base ]; description = "Darcs Patch Manager"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DPutils" = callPackage @@ -4208,8 +3865,6 @@ self: { ]; description = "Implementation of DSA, based on the description of FIPS 186-4"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DSH" = callPackage @@ -4238,8 +3893,6 @@ self: { ]; description = "Database Supported Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DSTM" = callPackage @@ -4261,8 +3914,6 @@ self: { ]; description = "A framework for using STM within distributed systems"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DTC" = callPackage @@ -4274,8 +3925,6 @@ self: { libraryHaskellDepends = [ base haskell-src-exts ]; description = "Data To Class transformation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dangerous" = callPackage @@ -4287,8 +3936,6 @@ self: { libraryHaskellDepends = [ base MaybeT mtl ]; description = "Monads for operations that can exit early and produce warnings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dao" = callPackage @@ -4319,8 +3966,6 @@ self: { ]; description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DarcsHelpers" = callPackage @@ -4332,8 +3977,6 @@ self: { libraryHaskellDepends = [ base HaXml mtl parsec safe xml-parsec ]; description = "Code used by Patch-Shack that seemed sensible to open for reusability"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Data-Angle" = callPackage @@ -4371,8 +4014,6 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "Ropes, an alternative to (Byte)Strings"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DataIndex" = callPackage @@ -4406,8 +4047,6 @@ self: { ]; description = "A GTK widget for displaying arbitrary Data.Data.Data instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DataVersion" = callPackage @@ -4421,8 +4060,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Type safe data migrations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Deadpan-DDP" = callPackage @@ -4451,8 +4088,6 @@ self: { testHaskellDepends = [ base doctest filemanip QuickCheck ]; description = "Write clients for Meteor's DDP Protocol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DebugTraceHelpers" = callPackage @@ -4492,8 +4127,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A very simple implementation of decision trees for discrete attributes"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DeepArrow" = callPackage @@ -4505,8 +4138,6 @@ self: { libraryHaskellDepends = [ base haskell-src mtl TypeCompose ]; description = "Arrows for \"deep application\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DeepDarkFantasy" = callPackage @@ -4524,8 +4155,6 @@ self: { testHaskellDepends = [ base constraints mtl QuickCheck random ]; description = "A DSL for creating neural network"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DefendTheKing" = callPackage @@ -4545,8 +4174,6 @@ self: { ]; description = "A simple RTS game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Delta-Lambda" = callPackage @@ -4569,8 +4196,6 @@ self: { ]; description = "A demonstration interpreter for type system delta-lambda (of N.G. De-bruijn)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DescriptiveKeys" = callPackage @@ -4599,8 +4224,6 @@ self: { ]; description = "Processing Real-time event streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Diff_0_3_4" = callPackage @@ -4649,8 +4272,6 @@ self: { ]; description = "A theory solver for conjunctions of literals in difference logic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DifferentialEvolution" = callPackage @@ -4666,8 +4287,6 @@ self: { ]; description = "Global optimization using Differential Evolution"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Digit" = callPackage @@ -4702,8 +4321,6 @@ self: { testHaskellDepends = [ base hspec lens mtl text ]; description = "A client library for the DigitalOcean API"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DimensionalHash" = callPackage @@ -4715,8 +4332,6 @@ self: { libraryHaskellDepends = [ base ]; description = "An n-dimensional hash using Morton numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DirectSound" = callPackage @@ -4750,8 +4365,6 @@ self: { ]; description = "Distributed Bug Tracking System"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DiscussionSupportSystem" = callPackage @@ -4768,8 +4381,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Discussion support system"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dish" = callPackage @@ -4784,8 +4395,6 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Hash modules (currently Murmur3)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dist" = callPackage @@ -4798,8 +4407,6 @@ self: { testHaskellDepends = [ base containers MonadRandom ]; description = "A Haskell library for probability distributions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DistanceTransform" = callPackage @@ -4853,8 +4460,6 @@ self: { ]; description = "Frameshift-aware alignment of protein sequences with DNA sequences"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DocTest" = callPackage @@ -4872,8 +4477,6 @@ self: { ]; description = "Test interactive Haskell examples"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Docs" = callPackage @@ -4903,8 +4506,6 @@ self: { executableHaskellDepends = [ array base containers pretty ]; description = "A tool for deriving hylomorphisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DrIFT" = callPackage @@ -4922,8 +4523,6 @@ self: { ]; description = "Program to derive type class instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DrIFT-cabalized" = callPackage @@ -4938,8 +4537,6 @@ self: { executableHaskellDepends = [ base old-time process random ]; description = "Program to derive type class instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dung" = callPackage @@ -4953,8 +4550,6 @@ self: { libraryHaskellDepends = [ base cmdargs containers parsec ]; description = "An implementation of the Dung argumentation frameworks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dust" = callPackage @@ -4980,8 +4575,6 @@ self: { ]; description = "Polymorphic protocol engine"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dust-crypto" = callPackage @@ -5008,8 +4601,6 @@ self: { ]; description = "Cryptographic operations"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "Dust-tools" = callPackage @@ -5034,8 +4625,6 @@ self: { ]; description = "Network filtering exploration tools"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Dust-tools-pcap" = callPackage @@ -5057,8 +4646,6 @@ self: { ]; description = "Network filtering exploration tools that rely on pcap"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DynamicTimeWarp" = callPackage @@ -5076,8 +4663,6 @@ self: { ]; description = "Dynamic time warping of sequences"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DysFRP" = callPackage @@ -5091,8 +4676,6 @@ self: { ]; description = "dysFunctional Reactive Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DysFRP-Cairo" = callPackage @@ -5104,8 +4687,6 @@ self: { libraryHaskellDepends = [ base cairo DysFRP gtk mtl ]; description = "dysFunctional Reactive Programming on Cairo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "DysFRP-Craftwerk" = callPackage @@ -5122,8 +4703,6 @@ self: { ]; description = "dysFunctional Reactive Programming on Craftwerk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "EEConfig" = callPackage @@ -5237,8 +4816,6 @@ self: { ]; description = "Query language and report generator for edit logs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Eight-Ball-Pool-Hack-Cheats" = callPackage @@ -5261,8 +4838,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "EitherT" = callPackage @@ -5280,8 +4855,6 @@ self: { ]; description = "EitherT monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Elm" = callPackage @@ -5337,8 +4910,6 @@ self: { ]; description = "derives heuristic rules from nominal data"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Empty" = callPackage @@ -5350,8 +4921,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A type class for empty containers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Encode" = callPackage @@ -5382,8 +4951,6 @@ self: { ]; description = "Libary to interface with the NCBI Entrez REST service"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Enum" = callPackage @@ -5407,8 +4974,6 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "Simple Enum-class-based int containers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "EnumMap" = callPackage @@ -5420,8 +4985,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "More general IntMap replacement"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Eq" = callPackage @@ -5440,8 +5003,6 @@ self: { ]; description = "Render math formula in ASCII, and perform some simplifications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "EqualitySolver" = callPackage @@ -5455,8 +5016,6 @@ self: { ]; description = "A theory solver for conjunctions of literals in the theory of uninterpreted functions with equality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "EsounD" = callPackage @@ -5476,8 +5035,6 @@ self: { ]; description = "Type-safe bindings to EsounD (ESD; Enlightened Sound Daemon)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "EstProgress" = callPackage @@ -5489,8 +5046,6 @@ self: { libraryHaskellDepends = [ ansi-terminal base mtl ]; description = "Methods for estimating the progress of functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "EtaMOO" = callPackage @@ -5515,8 +5070,6 @@ self: { executablePkgconfigDepends = [ pcre ]; description = "A new implementation of the LambdaMOO server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) pcre;}; "Etage" = callPackage @@ -5532,8 +5085,6 @@ self: { ]; description = "A general data-flow framework"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Etage-Graph" = callPackage @@ -5552,8 +5103,6 @@ self: { ]; description = "Data-flow based graph algorithms"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Eternal10Seconds" = callPackage @@ -5568,8 +5117,6 @@ self: { executableHaskellDepends = [ base haskell98 SDL SDL-mixer ]; description = "A 2-D shooting game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Etherbunny" = callPackage @@ -5591,8 +5138,6 @@ self: { executableSystemDepends = [ libpcap ]; description = "A network analysis toolkit for Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libpcap;}; "EuroIT" = callPackage @@ -5638,8 +5183,6 @@ self: { ]; description = "Interfaces with FreeSwitch Event Socket"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Extra" = callPackage @@ -5659,8 +5202,6 @@ self: { ]; description = "A grab bag of modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FAI" = callPackage @@ -5698,8 +5239,6 @@ self: { ]; description = "Compose music"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FM-SBLEX" = callPackage @@ -5713,8 +5252,6 @@ self: { executableHaskellDepends = [ array base containers haskell98 ]; description = "A set of computational morphology tools for Swedish diachronic lexicons"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FModExRaw" = callPackage @@ -5727,8 +5264,6 @@ self: { librarySystemDepends = [ fmodex64 ]; description = "The Haskell FModEx raw API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {fmodex64 = null;}; "FPretty" = callPackage @@ -5742,8 +5277,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Efficient simple pretty printing combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FSM" = callPackage @@ -5786,8 +5319,6 @@ self: { librarySystemDepends = [ ftgl ]; description = "Portable TrueType font rendering for OpenGL using the Freetype2 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ftgl;}; "FTPLine" = callPackage @@ -5806,8 +5337,6 @@ self: { ]; description = "A command-line FTP client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Facebook-Password-Hacker-Online-Latest-Version" = callPackage @@ -5832,8 +5361,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Facts" = callPackage @@ -5849,8 +5376,6 @@ self: { ]; description = "A collection of facts about the real world"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FailureT" = callPackage @@ -5862,8 +5387,6 @@ self: { libraryHaskellDepends = [ base base-unicode-symbols mmtl ]; description = "Failure Monad Transformer"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FastPush" = callPackage @@ -5875,8 +5398,6 @@ self: { libraryHaskellDepends = [ base STMonadTrans vector ]; description = "A monad and monad transformer for pushing things onto a stack very fast"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FastxPipe" = callPackage @@ -5893,8 +5414,6 @@ self: { ]; description = "Fasta and Fastq streaming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FenwickTree" = callPackage @@ -5927,8 +5446,6 @@ self: { ]; description = "Annotate ps and pdf documents"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FerryCore" = callPackage @@ -5945,8 +5462,6 @@ self: { ]; description = "Ferry Core Components"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Feval" = callPackage @@ -5960,8 +5475,6 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Evaluation using F-Algebras"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FieldTrip" = callPackage @@ -5978,8 +5491,6 @@ self: { ]; description = "Functional 3D"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FileManip" = callPackage @@ -5995,8 +5506,6 @@ self: { ]; description = "Expressive file and directory manipulation for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FileManipCompat" = callPackage @@ -6012,8 +5521,6 @@ self: { ]; description = "Expressive file and directory manipulation for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FilePather" = callPackage @@ -6030,8 +5537,6 @@ self: { ]; description = "Functions on System.FilePath"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FileSystem" = callPackage @@ -6047,8 +5552,6 @@ self: { ]; description = "File system data structure and monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Files" = callPackage @@ -6065,8 +5568,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "File content extraction/rearrangement"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Fin" = callPackage @@ -6084,8 +5585,6 @@ self: { ]; description = "Finite totally-ordered sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Finance-Quote-Yahoo" = callPackage @@ -6101,8 +5600,6 @@ self: { ]; description = "Obtain quote data from finance.yahoo.com"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Finance-Treasury" = callPackage @@ -6119,8 +5616,6 @@ self: { ]; description = "Obtain Treasury yield curve data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FindBin" = callPackage @@ -6143,8 +5638,6 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "A finite map implementation, derived from the paper: Efficient sets: a balancing act, S. Adams, Journal of functional programming 3(4) Oct 1993, pp553-562"; license = lib.licenses.bsdOriginal; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FirstOrderTheory" = callPackage @@ -6156,8 +5649,6 @@ self: { libraryHaskellDepends = [ base containers Proper ]; description = "Grammar and typeclass for first order theories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FixedPoint-simple" = callPackage @@ -6187,8 +5678,6 @@ self: { ]; description = "Wiki"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FloatingHex" = callPackage @@ -6262,8 +5751,6 @@ self: { ]; description = "ForSyDe's Haskell-embedded Domain Specific Language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ForestStructures" = callPackage @@ -6311,8 +5798,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Comparison of trees and forests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ForkableT" = callPackage @@ -6324,8 +5809,6 @@ self: { libraryHaskellDepends = [ base monad-control mtl resourcet ]; description = "Forkable monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FormalGrammars" = callPackage @@ -6350,8 +5833,6 @@ self: { ]; description = "(Context-free) grammars in formal language theory"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Fortnite-Hack-Cheats-Free-V-Bucks-Generator" = callPackage @@ -6374,8 +5855,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Foster" = callPackage @@ -6396,8 +5875,6 @@ self: { ]; description = "Utilities to generate and solve puzzles"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FpMLv53" = callPackage @@ -6444,8 +5921,6 @@ self: { base FTGL GLFW-b OpenGLRaw parallel random time ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Frames" = callPackage @@ -6500,8 +5975,6 @@ self: { ]; description = "A library for accessing Postgres tables as in-memory data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Frames-dsv" = callPackage @@ -6519,8 +5992,6 @@ self: { testHaskellDepends = [ base Frames hspec pipes ]; description = "Alternative CSV parser for the Frames package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Frames-map-reduce" = callPackage @@ -6541,8 +6012,6 @@ self: { ]; description = "Frames wrapper for map-reduce-folds and some extra folds helpers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Frames-streamly" = callPackage @@ -6579,8 +6048,6 @@ self: { executableHaskellDepends = [ base mtl newtype she void ]; description = "An experimental programming language with typed algebraic effects"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FreeTypeGL" = callPackage @@ -6595,8 +6062,6 @@ self: { libraryHaskellDepends = [ base freetype2 OpenGL ]; description = "Loadable texture fonts for OpenGL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "FunGEn" = callPackage @@ -6633,8 +6098,6 @@ self: { ]; description = "Funge-98 interpreter written in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GA" = callPackage @@ -6659,8 +6122,6 @@ self: { executableHaskellDepends = [ base bimap ]; description = "GGg cipher"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GHood" = callPackage @@ -6685,8 +6146,6 @@ self: { librarySystemDepends = [ libGL libX11 libXext libXfixes ]; description = "A Haskell binding for GLFW"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libGL; inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXfixes;}; @@ -6701,8 +6160,6 @@ self: { librarySystemDepends = [ libX11 libXrandr ]; description = "A binding for GLFW (OGL)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXrandr;}; "GLFW-b" = callPackage @@ -6737,8 +6194,6 @@ self: { ]; description = "GLFW-b demo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GLFW-task" = callPackage @@ -6752,8 +6207,6 @@ self: { ]; description = "GLFW utility functions to use together with monad-task"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GLHUI" = callPackage @@ -6805,8 +6258,6 @@ self: { libraryHaskellDepends = [ base OpenGLRaw ]; description = "Utilities for working with OpenGL matrices"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GLURaw" = callPackage @@ -6872,8 +6323,6 @@ self: { ]; description = "Parse GPX files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GPipe" = callPackage @@ -6891,8 +6340,6 @@ self: { ]; description = "Typesafe functional GPU graphics programming"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GPipe-Collada" = callPackage @@ -6906,8 +6353,6 @@ self: { ]; description = "Load GPipe meshes from Collada files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GPipe-Core" = callPackage @@ -6929,8 +6374,6 @@ self: { benchmarkHaskellDepends = [ base criterion lens ]; description = "Typesafe functional GPU graphics programming"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GPipe-Examples" = callPackage @@ -6948,8 +6391,6 @@ self: { ]; description = "Examples for the GPipes package"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GPipe-GLFW" = callPackage @@ -6962,8 +6403,6 @@ self: { libraryHaskellDepends = [ async base containers GLFW-b GPipe stm ]; description = "GLFW OpenGL context creation for GPipe"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GPipe-GLFW4" = callPackage @@ -6993,8 +6432,6 @@ self: { ]; description = "GLFW OpenGL context creation for GPipe"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GPipe-TextureLoad" = callPackage @@ -7006,8 +6443,6 @@ self: { libraryHaskellDepends = [ base bitmap GPipe stb-image ]; description = "Load GPipe textures from filesystem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GTALib" = callPackage @@ -7026,8 +6461,6 @@ self: { ]; description = "A library for GTA programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Gamgine" = callPackage @@ -7049,8 +6482,6 @@ self: { libraryToolDepends = [ cpphs ]; description = "Some kind of game library or set of utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Ganymede" = callPackage @@ -7068,8 +6499,6 @@ self: { ]; description = "An Io interpreter in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GaussQuadIntegration" = callPackage @@ -7097,8 +6526,6 @@ self: { ]; description = "Several games"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GenI" = callPackage @@ -7132,8 +6559,6 @@ self: { ]; description = "A natural language generator (specifically, an FB-LTAG surface realiser)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GenSmsPdu" = callPackage @@ -7147,8 +6572,6 @@ self: { executableHaskellDepends = [ base haskell98 QuickCheck random ]; description = "Automatic SMS message generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Genbank" = callPackage @@ -7167,8 +6590,6 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "Libary for processing the NCBI genbank format"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Gene-CluEDO" = callPackage @@ -7194,8 +6615,6 @@ self: { ]; description = "Hox gene clustering"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GeneralTicTacToe" = callPackage @@ -7209,8 +6628,6 @@ self: { executableHaskellDepends = [ base ]; description = "A general TicTacToe game implementation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GenericPretty" = callPackage @@ -7249,8 +6666,6 @@ self: { ]; description = "MCFGs for Genus-1 RNA Pseudoknots"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GeoIp" = callPackage @@ -7275,8 +6690,6 @@ self: { libraryHaskellDepends = [ aeson base bytestring HTTP text ]; description = "Geocoder and Reverse Geocoding Service Wrapper"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Geodetic" = callPackage @@ -7310,8 +6723,6 @@ self: { libraryHaskellDepends = [ base GeomPredicates ]; description = "Geometric predicates (Intel SSE)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Get" = callPackage @@ -7324,8 +6735,6 @@ self: { testHaskellDepends = [ base constraints singletons ]; description = "get stuff out of stuff"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GiST" = callPackage @@ -7337,8 +6746,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "A Haskell implementation of a Generalized Search Tree (GiST)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Gifcurry" = callPackage @@ -7364,8 +6771,6 @@ self: { ]; description = "GIF creation utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GiveYouAHead" = callPackage @@ -7388,8 +6793,6 @@ self: { libraryHaskellDepends = [ base mtl split threepenny-gui ]; description = "HTML Canvas graphics, animations and simulations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Glob" = callPackage @@ -7423,8 +6826,6 @@ self: { libraryHaskellDepends = [ array base GlomeVec ]; description = "Ray Tracing Library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GlomeVec" = callPackage @@ -7454,8 +6855,6 @@ self: { ]; description = "SDL Frontend for Glome ray tracer"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GoogleChart" = callPackage @@ -7482,8 +6881,6 @@ self: { ]; description = "A monad for flexible parsing of Google Code Jam input files with automatic parallelization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GoogleDirections" = callPackage @@ -7499,8 +6896,6 @@ self: { ]; description = "Haskell Interface to Google Directions API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GoogleSB" = callPackage @@ -7516,8 +6911,6 @@ self: { ]; description = "Interface to Google Safe Browsing API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GoogleSuggest" = callPackage @@ -7545,8 +6938,6 @@ self: { ]; description = "Interface to Google Translate API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GotoT-transformers" = callPackage @@ -7558,8 +6949,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A monad and monadic transformer providing \"goto\" functionality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Grafos" = callPackage @@ -7571,8 +6960,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Grafos Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GrammarProducts" = callPackage @@ -7595,8 +6982,6 @@ self: { testHaskellDepends = [ base ]; description = "Grammar products and higher-dimensional grammars"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Graph500" = callPackage @@ -7615,8 +7000,6 @@ self: { executableHaskellDepends = [ array base mtl ]; description = "Graph500 benchmark-related definitions and data set generator"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GraphHammer" = callPackage @@ -7631,8 +7014,6 @@ self: { ]; description = "GraphHammer Haskell graph analyses framework inspired by STINGER"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GraphHammer-examples" = callPackage @@ -7650,8 +7031,6 @@ self: { ]; description = "Test harness for TriangleCount analysis"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GraphSCC" = callPackage @@ -7695,8 +7074,6 @@ self: { ]; description = "Embedded grammar DSL and LALR parser generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GroteTrap" = callPackage @@ -7714,8 +7091,6 @@ self: { ]; description = "Parser and selection library for expression languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Grow" = callPackage @@ -7758,8 +7133,6 @@ self: { ]; description = "Notification utility for Growl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Gtk2hsGenerics" = callPackage @@ -7775,8 +7148,6 @@ self: { ]; description = "Convenience functions to extend Gtk2hs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GtkGLTV" = callPackage @@ -7792,8 +7163,6 @@ self: { ]; description = "OpenGL support for Gtk-based GUIs for Tangible Values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GtkTV" = callPackage @@ -7807,8 +7176,6 @@ self: { ]; description = "Gtk-based GUIs for Tangible Values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GuiHaskell" = callPackage @@ -7827,8 +7194,6 @@ self: { ]; description = "A graphical REPL and development environment for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "GuiTV" = callPackage @@ -7840,8 +7205,6 @@ self: { libraryHaskellDepends = [ base DeepArrow phooey TV TypeCompose ]; description = "GUIs for Tangible Values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "H" = callPackage @@ -7886,8 +7249,6 @@ self: { ]; description = "Hierarchical adaptive Bayesian quantum tomography for quantum bits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HARM" = callPackage @@ -7919,8 +7280,6 @@ self: { ]; description = "HAppS data manipulation libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HAppS-IxSet" = callPackage @@ -7936,8 +7295,6 @@ self: { syb-with-class template-haskell ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HAppS-Server" = callPackage @@ -7958,8 +7315,6 @@ self: { ]; description = "Web related tools and services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HAppS-State" = callPackage @@ -7979,8 +7334,6 @@ self: { ]; description = "Event-based distributed state"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HAppS-Util" = callPackage @@ -7997,8 +7350,6 @@ self: { ]; description = "Web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HAppSHelpers" = callPackage @@ -8031,8 +7382,6 @@ self: { ]; description = "High-level library for building command line interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HCard" = callPackage @@ -8046,8 +7395,6 @@ self: { ]; description = "A library for implementing a Deck of Cards"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HCodecs" = callPackage @@ -8099,8 +7446,6 @@ self: { librarySystemDepends = [ mysqlclient openssl zlib ]; description = "MySQL driver for HDBC"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {mysqlclient = null; inherit (pkgs) openssl; inherit (pkgs) zlib;}; @@ -8151,8 +7496,6 @@ self: { libraryHaskellDepends = [ attoparsec base containers HDBC text ]; description = "Manipulate data in PostgreSQL \"hstore\" columns"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HDBC-session" = callPackage @@ -8193,8 +7536,6 @@ self: { librarySystemDepends = [ pfstools ]; description = "Utilities for reading, manipulating, and writing HDR images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) pfstools;}; "HERA" = callPackage @@ -8206,8 +7547,6 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ mpfr ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) mpfr;}; "HExcel" = callPackage @@ -8224,8 +7563,6 @@ self: { librarySystemDepends = [ xlsxwriter zlib ]; description = "Create Excel files with Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {xlsxwriter = null; inherit (pkgs) zlib;}; "HFitUI" = callPackage @@ -8247,8 +7584,6 @@ self: { testHaskellDepends = [ base ]; description = "The library for generating a graphical interface on the web"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HFrequencyQueue" = callPackage @@ -8260,8 +7595,6 @@ self: { libraryHaskellDepends = [ base c-storable-deriving ]; description = "A Queue with a random (weighted) pick function"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HFuse" = callPackage @@ -8298,8 +7631,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "2D game engine written in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HGL" = callPackage @@ -8658,8 +7989,6 @@ self: { ]; description = "Graph database stored on disk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HHDL" = callPackage @@ -8671,8 +8000,6 @@ self: { libraryHaskellDepends = [ base containers mtl template-haskell ]; description = "Hardware Description Language embedded in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HJScript" = callPackage @@ -8684,8 +8011,6 @@ self: { libraryHaskellDepends = [ base HJavaScript hsp mtl text ]; description = "HJScript is a Haskell EDSL for writing JavaScript programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HJVM" = callPackage @@ -8708,8 +8033,6 @@ self: { ]; description = "A library to create a Java Virtual Machine and manipulate Java objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) jdk;}; "HJavaScript" = callPackage @@ -8723,8 +8046,6 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "HJavaScript is an abstract syntax for a typed subset of JavaScript"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HLearn-algebra" = callPackage @@ -8744,8 +8065,6 @@ self: { ]; description = "Algebraic foundation for homomorphic learning"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HLearn-approximation" = callPackage @@ -8764,8 +8083,6 @@ self: { HLearn-datastructures HLearn-distributions list-extras vector ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HLearn-classification" = callPackage @@ -8788,8 +8105,6 @@ self: { QuickCheck statistics vector vector-th-unbox ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HLearn-datastructures" = callPackage @@ -8805,8 +8120,6 @@ self: { MonadRandom QuickCheck vector ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HLearn-distributions" = callPackage @@ -8830,8 +8143,6 @@ self: { ]; description = "Distributions for use with the HLearn library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HList" = callPackage @@ -8857,8 +8168,6 @@ self: { ]; description = "Heterogeneous lists"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HListPP" = callPackage @@ -8886,8 +8195,6 @@ self: { executableHaskellDepends = [ base old-locale time ]; description = "Simple, concurrent and easy-to-use logging library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HMM" = callPackage @@ -8898,8 +8205,6 @@ self: { sha256 = "01y8l76c56gysynbilp32yq0wfc129hl24siw8s9fmpn98qa71s6"; description = "A hidden markov model library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HMap" = callPackage @@ -8955,8 +8260,6 @@ self: { ]; description = "Happy Network Manager"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HNumeric" = callPackage @@ -8987,8 +8290,6 @@ self: { librarySystemDepends = [ ode ]; description = "Binding to libODE"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ode;}; "HOpenCV" = callPackage @@ -9005,8 +8306,6 @@ self: { executablePkgconfigDepends = [ opencv ]; description = "A binding for the OpenCV computer vision library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) opencv;}; "HPDF" = callPackage @@ -9031,8 +8330,6 @@ self: { testHaskellDepends = [ base HTF ]; description = "Generation of PDF documents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HPath" = callPackage @@ -9055,8 +8352,6 @@ self: { ]; description = "Extract Haskell declarations by name"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HPhone" = callPackage @@ -9086,8 +8381,6 @@ self: { librarySystemDepends = [ bcm2835 ]; description = "GPIO, I2C and SPI functions for the Raspberry Pi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {bcm2835 = null;}; "HPlot" = callPackage @@ -9105,8 +8398,6 @@ self: { executablePkgconfigDepends = [ plplotd-gnome2 ]; description = "A minimal monadic PLplot interface for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {plplotd-gnome2 = null;}; "HPong" = callPackage @@ -9125,8 +8416,6 @@ self: { ]; description = "A simple OpenGL Pong game based on GLFW"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HROOT" = callPackage @@ -9144,8 +8433,6 @@ self: { ]; description = "Haskell binding to the ROOT data analysis framework"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HROOT-core" = callPackage @@ -9159,8 +8446,6 @@ self: { ]; description = "Haskell binding to ROOT Core modules"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HROOT-graf" = callPackage @@ -9176,8 +8461,6 @@ self: { ]; description = "Haskell binding to ROOT Graf modules"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HROOT-hist" = callPackage @@ -9193,8 +8476,6 @@ self: { ]; description = "Haskell binding to ROOT Hist modules"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HROOT-io" = callPackage @@ -9210,8 +8491,6 @@ self: { ]; description = "Haskell binding to ROOT IO modules"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HROOT-math" = callPackage @@ -9227,8 +8506,6 @@ self: { ]; description = "Haskell binding to ROOT Math modules"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HROOT-tree" = callPackage @@ -9244,8 +8521,6 @@ self: { ]; description = "Haskell binding to ROOT Tree modules"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HRay" = callPackage @@ -9260,8 +8535,6 @@ self: { executableHaskellDepends = [ array base directory haskell98 ]; description = "Haskell raytracer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HSFFIG" = callPackage @@ -9282,8 +8555,6 @@ self: { ]; description = "Generate FFI import declarations from C include files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HSGEP" = callPackage @@ -9302,8 +8573,6 @@ self: { executableHaskellDepends = [ csv ]; description = "Gene Expression Programming evolutionary algorithm in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HSH" = callPackage @@ -9340,8 +8609,6 @@ self: { ]; description = "Convenience functions that use HSH, instances for HSH"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HSet" = callPackage @@ -9353,8 +8620,6 @@ self: { libraryHaskellDepends = [ base containers hashable hashtables ]; description = "Faux heterogeneous sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HSlippyMap" = callPackage @@ -9385,8 +8650,6 @@ self: { testHaskellDepends = [ aeson attoparsec base HTF text ]; description = "Small template engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HSoM" = callPackage @@ -9421,8 +8684,6 @@ self: { ]; description = "Audio file reading/writing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HStringTemplate" = callPackage @@ -9459,8 +8720,6 @@ self: { ]; description = "Convenience functions and instances for HStringTemplate"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HSvm" = callPackage @@ -9557,8 +8816,6 @@ self: { ]; description = "Tableau based theorem prover for hybrid logics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HTicTacToe" = callPackage @@ -9576,8 +8833,6 @@ self: { ]; description = "An SDL tic-tac-toe game"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HUnit" = callPackage @@ -9601,8 +8856,6 @@ self: { libraryHaskellDepends = [ ansi-terminal base Diff groom HUnit ]; description = "Assertions for HUnit with difference reporting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HUnit-Plus" = callPackage @@ -9662,8 +8915,6 @@ self: { ]; description = "A (prototyped) easy to use XMPP library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HXQ" = callPackage @@ -9681,8 +8932,6 @@ self: { ]; description = "A Compiler from XQuery to Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaLeX" = callPackage @@ -9697,8 +8946,6 @@ self: { libraryHaskellDepends = [ base HUnit mtl QuickCheck ]; description = "HaLeX enables modelling, manipulation and visualization of regular languages"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaMinitel" = callPackage @@ -9710,8 +8957,6 @@ self: { libraryHaskellDepends = [ base bytestring serialport stm ]; description = "An Haskell library to drive the french Minitel through a serial port"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaPy" = callPackage @@ -9723,8 +8968,6 @@ self: { libraryHaskellDepends = [ base template-haskell th-lift ]; description = "Haskell bindings for Python"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaRe" = callPackage @@ -9759,8 +9002,6 @@ self: { ]; description = "the Haskell Refactorer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaTeX" = callPackage @@ -9799,8 +9040,6 @@ self: { ]; description = "This package is deprecated. From version 3, HaTeX does not need this anymore."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaTeX-qq" = callPackage @@ -9816,8 +9055,6 @@ self: { ]; description = "Quasiquoters for HaTeX"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaVSA" = callPackage @@ -9837,8 +9074,6 @@ self: { ]; description = "An implementation of the Version Space Algebra learning framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaXml" = callPackage @@ -9875,8 +9110,6 @@ self: { executableHaskellDepends = [ text time vty vty-ui ]; description = "Simple chat"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HackMail" = callPackage @@ -9897,8 +9130,6 @@ self: { ]; description = "A Procmail Replacement as Haskell EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Haggressive" = callPackage @@ -9916,8 +9147,6 @@ self: { testHaskellDepends = [ base Cabal containers HUnit tuple vector ]; description = "Aggression analysis for Tweets on Twitter"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HandlerSocketClient" = callPackage @@ -9929,8 +9158,6 @@ self: { libraryHaskellDepends = [ base bytestring network ]; description = "Haskell implementation of a HandlerSocket client (API)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HandsomeSoup" = callPackage @@ -9965,8 +9192,6 @@ self: { testHaskellDepends = [ base hspec transformers ]; description = "The classic game of Hangman"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HappyTree" = callPackage @@ -9984,8 +9209,6 @@ self: { ]; description = "Type Safe and End to End Decision Tree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HarmTrace" = callPackage @@ -10009,8 +9232,6 @@ self: { ]; description = "Harmony Analysis and Retrieval of Music"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HarmTrace-Base" = callPackage @@ -10060,8 +9281,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Haskell bindings for CacBDD"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {CacBDD = null;}; "HasGP" = callPackage @@ -10078,8 +9297,6 @@ self: { ]; description = "A Haskell library for inference using Gaussian processes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Haschoo" = callPackage @@ -10098,8 +9315,6 @@ self: { ]; description = "Minimalist R5RS Scheme interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hashell" = callPackage @@ -10118,8 +9333,6 @@ self: { ]; description = "Simple shell written in Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskRel" = callPackage @@ -10136,8 +9349,6 @@ self: { ]; description = "HaskRel, Haskell as a DBMS with support for the relational algebra"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskellAnalysisProgram" = callPackage @@ -10161,8 +9372,6 @@ self: { ]; description = "Haskell source code analysis program"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskellForMaths" = callPackage @@ -10185,8 +9394,6 @@ self: { libraryHaskellDepends = [ base hmatrix ]; description = "Pure Haskell implementation of the Levenberg-Marquardt algorithm"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskellNN" = callPackage @@ -10198,8 +9405,6 @@ self: { libraryHaskellDepends = [ base hmatrix random ]; description = "High Performance Neural Network in Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskellNet" = callPackage @@ -10216,8 +9421,6 @@ self: { ]; description = "Client support for POP3, SMTP, and IMAP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskellNet-SSL" = callPackage @@ -10234,8 +9437,6 @@ self: { ]; description = "Helpers to connect to SSL/TLS mail servers with HaskellNet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskellTorrent" = callPackage @@ -10259,8 +9460,6 @@ self: { ]; description = "A concurrent bittorrent client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HaskellTutorials" = callPackage @@ -10274,8 +9473,6 @@ self: { executableHaskellDepends = [ base cmdargs text ]; description = "Haskell Tutorials by Evgeny Ukhanov"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Haskelloids" = callPackage @@ -10293,8 +9490,6 @@ self: { ]; description = "A reproduction of the Atari 1979 classic \"Asteroids\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hastodon" = callPackage @@ -10336,8 +9531,6 @@ self: { ]; description = "A small 2D game framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hawk" = callPackage @@ -10359,8 +9552,6 @@ self: { ]; description = "Haskell Web Application Kit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hayoo" = callPackage @@ -10387,8 +9578,6 @@ self: { ]; description = "The Hayoo! search engine for Haskell API search on hackage"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hclip" = callPackage @@ -10421,8 +9610,6 @@ self: { ]; description = "Line oriented editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HerbiePlugin" = callPackage @@ -10441,8 +9628,6 @@ self: { testHaskellDepends = [ base linear subhask ]; description = "automatically improve your code's numeric stability"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hermes" = callPackage @@ -10461,8 +9646,6 @@ self: { ]; description = "Message-based middleware layer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hieroglyph" = callPackage @@ -10480,8 +9663,6 @@ self: { ]; description = "Purely functional 2D graphics for visualization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HiggsSet" = callPackage @@ -10498,8 +9679,6 @@ self: { ]; description = "A multi-index set with advanced query capabilites"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hipmunk" = callPackage @@ -10526,8 +9705,6 @@ self: { testHaskellDepends = [ base ]; description = "Useful functions for Hipmunk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HipmunkPlayground" = callPackage @@ -10565,8 +9742,6 @@ self: { base directory MissingH process regex-tdfa time ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Histogram" = callPackage @@ -10594,8 +9769,6 @@ self: { ]; description = "An MPD client designed for a Home Theatre PC"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hoed" = callPackage @@ -10620,8 +9793,6 @@ self: { testHaskellDepends = [ base process QuickCheck ]; description = "Lightweight algorithmic debugging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HoleyMonoid" = callPackage @@ -10695,8 +9866,6 @@ self: { ]; description = "A search and indexing engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Holumbus-Storage" = callPackage @@ -10747,8 +9916,6 @@ self: { testHaskellDepends = [ base process random ]; description = "A Simple Key Value Store"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HostAndPort" = callPackage @@ -10775,8 +9942,6 @@ self: { executableHaskellDepends = [ base containers ]; description = "A Cricket scoring application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hs2lib" = callPackage @@ -10804,8 +9969,6 @@ self: { testHaskellDepends = [ base directory filepath process ]; description = "A Library and Preprocessor that makes it easier to create shared libs from Haskell programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HsASA" = callPackage @@ -10837,8 +10000,6 @@ self: { ]; description = "Bindings to htslib"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zlib;}; "HsHaruPDF" = callPackage @@ -10850,8 +10011,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell binding to libharu (http://libharu.sourceforge.net/)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HsHyperEstraier" = callPackage @@ -10868,8 +10027,6 @@ self: { libraryPkgconfigDepends = [ hyperestraier qdbm ]; description = "HyperEstraier binding for Haskell"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {hyperestraier = null; qdbm = null;}; "HsJudy" = callPackage @@ -10883,8 +10040,6 @@ self: { librarySystemDepends = [ Judy ]; description = "Judy bindings, and some nice APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {Judy = null;}; "HsOpenSSL" = callPackage @@ -10924,8 +10079,6 @@ self: { ]; description = "Haskell integration with Parrot virtual machine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HsPerl5" = callPackage @@ -10937,8 +10090,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell interface to embedded Perl 5 interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HsSVN" = callPackage @@ -10950,8 +10101,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl stm ]; description = "Partial Subversion (SVN) binding for Haskell"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HsSyck" = callPackage @@ -11000,8 +10149,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Webots bindings for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {Controller = null; driver = null;}; "HsYAML" = callPackage @@ -11066,8 +10213,6 @@ self: { ]; description = "Stream Editor in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hsmtlib" = callPackage @@ -11085,8 +10230,6 @@ self: { ]; description = "Haskell library for easy interaction with SMT-LIB 2 compliant solvers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HueAPI" = callPackage @@ -11102,8 +10245,6 @@ self: { ]; description = "API for controlling Philips Hue lights"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "HulkImport" = callPackage @@ -11121,8 +10262,6 @@ self: { testHaskellDepends = [ base tasty tasty-golden ]; description = "Easily bulk import CSV data to SQL Server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Hungarian-Munkres" = callPackage @@ -11160,8 +10299,6 @@ self: { testHaskellDepends = [ base ]; description = "The library for generating a WebGL scene for the web"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "I1M" = callPackage @@ -11176,8 +10313,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ]; description = "Code for the Haskell course taught at the University of Seville"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IDynamic" = callPackage @@ -11189,8 +10324,6 @@ self: { libraryHaskellDepends = [ base containers directory ]; description = "Indexable, serializable form of Data.Dynamic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IFS" = callPackage @@ -11206,8 +10339,6 @@ self: { ]; description = "Iterated Function System generation for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "INblobs" = callPackage @@ -11227,8 +10358,6 @@ self: { ]; description = "Editor and interpreter for Interaction Nets"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IOR" = callPackage @@ -11241,8 +10370,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Region based resource management for the IO monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IORefCAS" = callPackage @@ -11261,8 +10388,6 @@ self: { ]; description = "Atomic compare and swap for IORefs and STRefs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IOSpec" = callPackage @@ -11320,8 +10445,6 @@ self: { ]; description = "A RESTful microService for IPv6-related data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IcoGrid" = callPackage @@ -11333,8 +10456,6 @@ self: { libraryHaskellDepends = [ array base GlomeVec ]; description = "Library for generating grids of hexagons and pentagons mapped to a sphere"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IfElse" = callPackage @@ -11368,8 +10489,6 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "A library for writing Imperative style haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IndentParser" = callPackage @@ -11392,8 +10511,6 @@ self: { libraryHaskellDepends = [ base PeanoWitnesses ]; description = "Length- and element-indexed lists sitting somewhere between homogeneous and fully heterogeneous"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "InfixApplicative" = callPackage @@ -11405,8 +10522,6 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "liftA2 for infix operators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IntFormats" = callPackage @@ -11419,8 +10534,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Convert integers in various bases to and from strings"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IntGraph" = callPackage @@ -11519,8 +10632,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "DSL for IRC bots"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "IrrHaskell" = callPackage @@ -11552,8 +10663,6 @@ self: { ]; description = "A typeclass to determine if a given value is null"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JSON-Combinator" = callPackage @@ -11571,8 +10680,6 @@ self: { ]; description = "A combinator library on top of a generalised JSON type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JSON-Combinator-Examples" = callPackage @@ -11586,8 +10693,6 @@ self: { ]; description = "Example uses of the JSON-Combinator library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JSONParser" = callPackage @@ -11619,8 +10724,6 @@ self: { ]; description = "JSON parser that uses byte strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JYU-Utils" = callPackage @@ -11640,8 +10743,6 @@ self: { ]; description = "Some utility functions for JYU projects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JackMiniMix" = callPackage @@ -11653,8 +10754,6 @@ self: { libraryHaskellDepends = [ base hosc ]; description = "control JackMiniMix"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Javasf" = callPackage @@ -11671,8 +10770,6 @@ self: { ]; description = "A utility to print the SourceFile attribute of one or more Java class files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Javav" = callPackage @@ -11686,8 +10783,6 @@ self: { executableHaskellDepends = [ base ]; description = "A utility to print the target version of Java class files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Jazzkell" = callPackage @@ -11711,8 +10806,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A Json implementation for Haskell, with JavaScript Values and Encoding/Decoding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JsContracts" = callPackage @@ -11735,8 +10828,6 @@ self: { ]; description = "Design-by-contract for JavaScript"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JsonGrammar" = callPackage @@ -11758,8 +10849,6 @@ self: { ]; description = "Combinators for bidirectional JSON parsing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JuPyTer-notebook" = callPackage @@ -11776,8 +10865,6 @@ self: { ]; description = "JuPyTer notebook parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JuicyPixels" = callPackage @@ -11817,8 +10904,6 @@ self: { ]; description = "BLP format decoder/encoder over JuicyPixels library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JuicyPixels-blurhash" = callPackage @@ -11859,8 +10944,6 @@ self: { libraryHaskellDepends = [ base containers JuicyPixels ]; description = "Functions for drawing lines, squares and so on pixel by pixel"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JuicyPixels-extra" = callPackage @@ -11952,8 +11035,6 @@ self: { filepath mtl network resourcet ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JunkDB-driver-gdbm" = callPackage @@ -11968,8 +11049,6 @@ self: { base bytestring conduit directory filepath JunkDB mtl resourcet ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JunkDB-driver-hashtables" = callPackage @@ -11984,8 +11063,6 @@ self: { base bytestring conduit hashable hashtables JunkDB mtl resourcet ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "JustParse" = callPackage @@ -11997,8 +11074,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple and comprehensive Haskell parsing library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "KMP" = callPackage @@ -12022,8 +11097,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A library with the kerbal space program universe and demo code"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Kalman" = callPackage @@ -12035,8 +11108,6 @@ self: { libraryHaskellDepends = [ base hmatrix ]; description = "A slightly extended Kalman filter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Kawaii-Parser" = callPackage @@ -12075,8 +11146,6 @@ self: { ]; description = "A super small web framework for those who don't like big and fancy codebases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "KiCS" = callPackage @@ -12175,8 +11244,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Category for Continuation Passing Style"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Kulitta" = callPackage @@ -12207,8 +11274,6 @@ self: { librarySystemDepends = [ kyotocabinet ]; description = "Kyoto Cabinet DB bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) kyotocabinet;}; "L-seed" = callPackage @@ -12226,8 +11291,6 @@ self: { ]; description = "Plant growing programming game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LATS" = callPackage @@ -12244,8 +11307,6 @@ self: { librarySystemDepends = [ openblasCompat ]; description = "Linear Algebra on Typed Spaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openblasCompat;}; "LC3" = callPackage @@ -12300,8 +11361,6 @@ self: { ]; description = "Lightweight Directory Access Protocol (LDAP) version 3"; license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LParse" = callPackage @@ -12325,8 +11384,6 @@ self: { libraryHaskellDepends = [ base containers QuickCheck ]; description = "Implements an LRU data structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LTS" = callPackage @@ -12347,8 +11404,6 @@ self: { benchmarkHaskellDepends = [ base criterion time ]; description = "LTS: Labelled Transition System"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LTree" = callPackage @@ -12409,8 +11464,6 @@ self: { ]; description = "A type-safe EDSL for TouchDesigner written in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LambdaHack" = callPackage @@ -12446,8 +11499,6 @@ self: { ]; description = "A game engine library for tactical squad ASCII roguelike dungeon crawlers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LambdaINet" = callPackage @@ -12467,8 +11518,6 @@ self: { ]; description = "Graphical Interaction Net Evaluator for Optimal Evaluation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LambdaNet" = callPackage @@ -12484,8 +11533,6 @@ self: { ]; description = "A configurable and extensible neural network library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LambdaPrettyQuote" = callPackage @@ -12510,8 +11557,6 @@ self: { ]; description = "Quasiquoter, and Arbitrary helpers for the lambda calculus"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LambdaShell" = callPackage @@ -12529,8 +11574,6 @@ self: { ]; description = "Simple shell for evaluating lambda expressions"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Lambdajudge" = callPackage @@ -12543,8 +11586,6 @@ self: { testHaskellDepends = [ base filepath hspec mtl process text ]; description = "A library to easily host Haskell based programming competitions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Lambdaya" = callPackage @@ -12561,8 +11602,6 @@ self: { ]; description = "Library for RedPitaya"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LargeCardinalHierarchy" = callPackage @@ -12591,8 +11630,6 @@ self: { ]; description = "A library for compiling programs in a variety of languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Lattices" = callPackage @@ -12642,8 +11679,6 @@ self: { executableHaskellDepends = [ base directory filepath unix ]; description = "A simple sandboxing tool for Haskell packages"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Learning" = callPackage @@ -12659,8 +11694,6 @@ self: { testHaskellDepends = [ base containers hmatrix vector ]; description = "The most frequently used machine learning tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Level0" = callPackage @@ -12674,8 +11707,6 @@ self: { executableHaskellDepends = [ base directory random SDL SDL-ttf ]; description = "A Snake II clone written using SDL"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LibClang" = callPackage @@ -12696,8 +11727,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell bindings for libclang (a C++ parsing library)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (self.llvmPackages) clang; inherit (pkgs) ncurses;}; "LibZip" = callPackage @@ -12728,8 +11757,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Wrapper for data that can be unbounded"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LinearSplit" = callPackage @@ -12744,8 +11771,6 @@ self: { ]; description = "Partition the sequence of items to the subsequences in the order given"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LinguisticsTypes" = callPackage @@ -12790,8 +11815,6 @@ self: { ]; description = "Check a bunch of local html files for broken links"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Liquorice" = callPackage @@ -12804,8 +11827,6 @@ self: { testHaskellDepends = [ base binary bytestring HTF mtl ]; description = "Algorithmic Doom map generation"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "List" = callPackage @@ -12858,8 +11879,6 @@ self: { ]; description = "List transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ListTree" = callPackage @@ -12912,8 +11931,6 @@ self: { doHaddock = false; description = "Converter to convert from .lhs to .md and vice versa."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Logic" = callPackage @@ -12925,8 +11942,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Logic"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LogicGrowsOnTrees" = callPackage @@ -12963,8 +11978,6 @@ self: { benchmarkHaskellDepends = [ base cereal criterion deepseq ]; description = "a parallel implementation of logic programming using distributed tree exploration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LogicGrowsOnTrees-MPI" = callPackage @@ -12986,8 +11999,6 @@ self: { librarySystemDepends = [ openmpi ]; description = "an adapter for LogicGrowsOnTrees that uses MPI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {openmpi = null;}; "LogicGrowsOnTrees-network" = callPackage @@ -13013,8 +12024,6 @@ self: { ]; description = "an adapter for LogicGrowsOnTrees that uses multiple processes running in a network"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LogicGrowsOnTrees-processes" = callPackage @@ -13041,8 +12050,6 @@ self: { benchmarkHaskellDepends = [ base criterion LogicGrowsOnTrees ]; description = "an adapter for LogicGrowsOnTrees that uses multiple processes for parallelism"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "LslPlus" = callPackage @@ -13063,8 +12070,6 @@ self: { ]; description = "An execution and testing framework for the Linden Scripting Language (LSL)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Lucu" = callPackage @@ -13085,8 +12090,6 @@ self: { ]; description = "HTTP Daemonic Library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Lykah" = callPackage @@ -13115,8 +12118,6 @@ self: { ]; description = "A static website and blog generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MASMGen" = callPackage @@ -13129,8 +12130,6 @@ self: { testHaskellDepends = [ base containers mtl ]; description = "Generate MASM code from haskell"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MBot" = callPackage @@ -13142,8 +12141,6 @@ self: { libraryHaskellDepends = [ base bytestring hidapi mtl ]; description = "Haskell interface for controlling the mBot educational robot"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MC-Fold-DP" = callPackage @@ -13162,8 +12159,6 @@ self: { executableHaskellDepends = [ cmdargs split ]; description = "Folding algorithm based on nucleotide cyclic motifs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MFlow" = callPackage @@ -13189,8 +12184,6 @@ self: { libraryToolDepends = [ cpphs ]; description = "stateful, RESTful web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MHask" = callPackage @@ -13202,8 +12195,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "The category of monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MIP" = callPackage @@ -13231,8 +12222,6 @@ self: { ]; description = "Library for using Mixed Integer Programming (MIP)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MIP-glpk" = callPackage @@ -13257,8 +12246,6 @@ self: { ]; description = "A GLPK backend to the MIP library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) glpk;}; "MSQueue" = callPackage @@ -13270,8 +12257,6 @@ self: { libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ]; description = "Michael-Scott queue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MTGBuilder" = callPackage @@ -13285,8 +12270,6 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Builds decks out of a meta"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MagicHaskeller" = callPackage @@ -13316,8 +12299,6 @@ self: { ]; description = "Automatic inductive functional programmer by systematic search"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MailchimpSimple" = callPackage @@ -13336,8 +12317,6 @@ self: { ]; description = "Haskell library to interact with Mailchimp JSON API Version 3.0"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Map" = callPackage @@ -13354,8 +12333,6 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Class of key-value maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MapWith" = callPackage @@ -13380,8 +12357,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Mapping"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MaybeT" = callPackage @@ -13395,8 +12370,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "MaybeT monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MaybeT-monads-tf" = callPackage @@ -13408,8 +12381,6 @@ self: { libraryHaskellDepends = [ base monads-tf transformers ]; description = "MaybeT monad transformer compatible with monads-tf (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MaybeT-transformers" = callPackage @@ -13421,8 +12392,6 @@ self: { libraryHaskellDepends = [ base monads-fd transformers ]; description = "MaybeT monad transformer using transformers instead of mtl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MazesOfMonad" = callPackage @@ -13442,8 +12411,6 @@ self: { ]; description = "Console-based Role Playing Game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MeanShift" = callPackage @@ -13455,8 +12422,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Mean shift algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Measure" = callPackage @@ -13468,8 +12433,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for units of measurement"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Mecha" = callPackage @@ -13481,8 +12444,6 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Mechs" = callPackage @@ -13494,8 +12455,6 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MemoTrie" = callPackage @@ -13524,8 +12483,6 @@ self: { ]; description = "Statically checked database access"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MetaObject" = callPackage @@ -13537,8 +12494,6 @@ self: { libraryHaskellDepends = [ base containers stringtable-atom ]; description = "A meta-object system for Haskell based on Perl 6"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Metrics" = callPackage @@ -13550,8 +12505,6 @@ self: { libraryHaskellDepends = [ base hstats ]; description = "Evaluation metrics commonly used in supervised machine learning"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Mhailist" = callPackage @@ -13570,8 +12523,6 @@ self: { ]; description = "Haskell mailing list manager"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Michelangelo" = callPackage @@ -13588,8 +12539,6 @@ self: { ]; description = "OpenGL for dummies"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MicrosoftTranslator" = callPackage @@ -13606,8 +12555,6 @@ self: { ]; description = "Interface for Microsoft Translator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MiniAgda" = callPackage @@ -13690,8 +12637,6 @@ self: { libraryHaskellDepends = [ anydbm base MissingH ]; description = "Haskell interface to Python"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Mobile-Legends-Hack-Cheats" = callPackage @@ -13714,8 +12659,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Modulo" = callPackage @@ -13741,8 +12684,6 @@ self: { executableHaskellDepends = [ base GLUT random ]; description = "A FRP library based on signal functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MoeDict" = callPackage @@ -13758,8 +12699,6 @@ self: { ]; description = "Utilities working with MoeDict.tw JSON dataset"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MonadCatchIO-mtl" = callPackage @@ -13775,8 +12714,6 @@ self: { ]; description = "Monad-transformer version of the Control.Exception module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MonadCatchIO-mtl-foreign" = callPackage @@ -13788,8 +12725,6 @@ self: { libraryHaskellDepends = [ base MonadCatchIO-mtl mtl primitive ]; description = "Polymorphic combinators for working with foreign functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MonadCatchIO-transformers" = callPackage @@ -13805,8 +12740,6 @@ self: { ]; description = "Monad-transformer compatible version of the Control.Exception module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MonadCatchIO-transformers-foreign" = callPackage @@ -13822,8 +12755,6 @@ self: { ]; description = "Polymorphic combinators for working with foreign functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MonadCompose" = callPackage @@ -13835,8 +12766,6 @@ self: { libraryHaskellDepends = [ base free mmorph mtl transformers ]; description = "Methods for composing monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MonadLab" = callPackage @@ -13853,8 +12782,6 @@ self: { executableHaskellDepends = [ base haskell98 process ]; description = "Automatically generate layered monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MonadPrompt" = callPackage @@ -13905,8 +12832,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Generalizing lift to monad stacks"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Monadius" = callPackage @@ -13921,8 +12846,6 @@ self: { executableHaskellDepends = [ array base directory GLUT OpenGL ]; description = "2-D arcade scroller"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Monadoro" = callPackage @@ -13938,8 +12861,6 @@ self: { testHaskellDepends = [ ansi-terminal base doctest process time ]; description = "A minimalistic CLI Pomodoro timer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Monaris" = callPackage @@ -13958,8 +12879,6 @@ self: { ]; description = "A simple tetris clone"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Monatron" = callPackage @@ -13971,8 +12890,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Monad transformer library with uniform liftings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Monatron-IO" = callPackage @@ -13984,8 +12901,6 @@ self: { libraryHaskellDepends = [ base Monatron transformers ]; description = "MonadIO instances for the Monatron transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Monocle" = callPackage @@ -13997,8 +12912,6 @@ self: { libraryHaskellDepends = [ base containers haskell98 mtl ]; description = "Symbolic computations in strict monoidal categories with LaTeX output"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MorseCode" = callPackage @@ -14030,8 +12943,6 @@ self: { ]; description = "Automated Mutation Testing"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MuCheck-HUnit" = callPackage @@ -14046,8 +12957,6 @@ self: { executableHaskellDepends = [ base HUnit MuCheck ]; description = "Automated Mutation Testing for HUnit tests"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MuCheck-Hspec" = callPackage @@ -14062,8 +12971,6 @@ self: { executableHaskellDepends = [ base hspec hspec-core MuCheck ]; description = "Automated Mutation Testing for Hspec tests"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MuCheck-QuickCheck" = callPackage @@ -14078,8 +12985,6 @@ self: { executableHaskellDepends = [ base MuCheck QuickCheck ]; description = "Automated Mutation Testing for QuickCheck tests"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MuCheck-SmallCheck" = callPackage @@ -14094,8 +12999,6 @@ self: { executableHaskellDepends = [ base MuCheck smallcheck ]; description = "Automated Mutation Testing for SmallCheck tests"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Munkres" = callPackage @@ -14118,8 +13021,6 @@ self: { libraryHaskellDepends = [ array base bimap containers Munkres ]; description = "Simple and typesafe layer over the Munkres package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MusicBrainz" = callPackage @@ -14186,8 +13087,6 @@ self: { ]; description = "Most likely order of mutation events in RNA"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "MyPrimes" = callPackage @@ -14203,8 +13102,6 @@ self: { benchmarkHaskellDepends = [ base time ]; description = "Generate all primes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NGrams" = callPackage @@ -14218,8 +13115,6 @@ self: { executableHaskellDepends = [ base HCL HTTP network regex-compat ]; description = "Simple application for calculating n-grams using Google"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NMap" = callPackage @@ -14231,8 +13126,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A transparent nested Map structure"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NTRU" = callPackage @@ -14273,8 +13166,6 @@ self: { ]; description = "A Haskell interface to Lego Mindstorms NXT"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {bluetooth = null;}; "NXTDSL" = callPackage @@ -14293,8 +13184,6 @@ self: { ]; description = "Generate NXC Code from DSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NaCl" = callPackage @@ -14343,8 +13232,6 @@ self: { executableHaskellDepends = [ base uu-parsinglib ]; description = "Very small interpreter for a Prolog-like language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Naperian" = callPackage @@ -14371,8 +13258,6 @@ self: { executableHaskellDepends = [ base hnetcdf Naperian split ]; description = "Instances of NcStore for hypercuboids"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NaturalLanguageAlphabets" = callPackage @@ -14402,8 +13287,6 @@ self: { ]; description = "Simple scoring schemes for word alignments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NaturalSort" = callPackage @@ -14417,8 +13300,6 @@ self: { libraryHaskellDepends = [ base bytestring strict ]; description = "Natural sorting for strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NearContextAlgebra" = callPackage @@ -14436,8 +13317,6 @@ self: { ]; description = "Context Algebra of near"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Neks" = callPackage @@ -14460,8 +13339,6 @@ self: { ]; description = "Simple networked key/value store"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NestedFunctor" = callPackage @@ -14473,8 +13350,6 @@ self: { libraryHaskellDepends = [ base comonad distributive ]; description = "Nested composition of functors with a type index tracking nesting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NestedSampling" = callPackage @@ -14499,8 +13374,6 @@ self: { testHaskellDepends = [ base bytestring HUnit process ]; description = "Bindings for net-snmp's C API for clients"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {net_snmp = null;}; "Network-NineP" = callPackage @@ -14564,8 +13437,6 @@ self: { ]; description = "Ninja game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NoHoed" = callPackage @@ -14596,8 +13467,6 @@ self: { ]; description = "Microbenchmarks for various array libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NoTrace" = callPackage @@ -14610,8 +13479,6 @@ self: { testHaskellDepends = [ base ]; description = "Remove all the functions come from Debug.Trace after debugging"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Noise" = callPackage @@ -14642,8 +13509,6 @@ self: { ]; description = "A Nomic game in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Nomyx-Core" = callPackage @@ -14670,8 +13535,6 @@ self: { ]; description = "A Nomic game in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Nomyx-Language" = callPackage @@ -14691,8 +13554,6 @@ self: { ]; description = "Language to express rules for Nomic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Nomyx-Rules" = callPackage @@ -14710,8 +13571,6 @@ self: { ]; description = "Language to express rules for Nomic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Nomyx-Web" = callPackage @@ -14736,8 +13595,6 @@ self: { ]; description = "Web gui for Nomyx"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NonEmpty" = callPackage @@ -14749,8 +13606,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Library providing a non-empty list datatype, and total functions operating on it"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NonEmptyList" = callPackage @@ -14767,8 +13622,6 @@ self: { ]; description = "A list with a length of at least one"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NumInstances" = callPackage @@ -14802,8 +13655,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Number Theoretic Sieves: primes, factorization, and Euler's Totient"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "NumberTheory" = callPackage @@ -14816,8 +13667,6 @@ self: { testHaskellDepends = [ base containers HUnit primes ]; description = "A library for number theoretic computations, written in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Numbers" = callPackage @@ -14846,8 +13695,6 @@ self: { ]; description = "Nussinov78 using the ADPfusion library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Nutri" = callPackage @@ -14859,8 +13706,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A little library to calculate nutrition values of food items"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OGL" = callPackage @@ -14872,8 +13717,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A context aware binding for the OpenGL graphics system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ONC-RPC" = callPackage @@ -14898,8 +13741,6 @@ self: { executableHaskellDepends = [ base filepath ]; description = "ONC RPC (aka Sun RPC) and XDR library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OSM" = callPackage @@ -14915,8 +13756,6 @@ self: { ]; description = "Parse OpenStreetMap files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OTP" = callPackage @@ -14936,8 +13775,6 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hunit time ]; description = "HMAC-Based and Time-Based One-Time Passwords (HOTP & TOTP)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Object" = callPackage @@ -14949,8 +13786,6 @@ self: { libraryHaskellDepends = [ base containers ghc template-haskell ]; description = "Object oriented programming for haskell using multiparameter typeclasses"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ObjectIO" = callPackage @@ -14966,8 +13801,6 @@ self: { winspool ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {comctl32 = null; comdlg32 = null; gdi32 = null; kernel32 = null; ole32 = null; shell32 = null; user32 = null; winmm = null; winspool = null;}; @@ -15016,8 +13849,6 @@ self: { ]; description = "Simple unbalanced Octree for storing data about 3D points"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OddWord" = callPackage @@ -15031,8 +13862,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Provides a wrapper for deriving word types with fewer bits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Omega" = callPackage @@ -15045,8 +13874,6 @@ self: { testHaskellDepends = [ base containers HUnit ]; description = "Integer sets and relations using Presburger arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OnRmt" = callPackage @@ -15083,8 +13910,6 @@ self: { ]; description = "Text UI library for performing parallel remote SSH operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OneTuple" = callPackage @@ -15127,8 +13952,6 @@ self: { ]; description = "IBM AFP document format parser and generator"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OpenAFP-Utils" = callPackage @@ -15149,8 +13972,6 @@ self: { ]; description = "Assorted utilities to work with AFP data streams"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OpenAL" = callPackage @@ -15183,8 +14004,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Haskell high-level wrapper for OpenCL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {OpenCL = null;}; "OpenCLRaw" = callPackage @@ -15196,8 +14015,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "The OpenCL Standard for heterogenous data-parallel computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OpenCLWrappers" = callPackage @@ -15209,8 +14026,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "The OpenCL Standard for heterogenous data-parallel computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OpenGL" = callPackage @@ -15242,8 +14057,6 @@ self: { ]; description = "Quickcheck instances for various data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OpenGLRaw" = callPackage @@ -15291,8 +14104,6 @@ self: { ]; description = "ADT wrapper and renderer for OpenSCAD models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OpenVG" = callPackage @@ -15304,8 +14115,6 @@ self: { libraryHaskellDepends = [ base GLUT OpenGL OpenGLRaw OpenVGRaw ]; description = "OpenVG (ShivaVG-0.2.1) binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OpenVGRaw" = callPackage @@ -15317,8 +14126,6 @@ self: { libraryHaskellDepends = [ base OpenGLRaw ]; description = "Raw binding to OpenVG (ShivaVG-0.2.1 implementation)."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Operads" = callPackage @@ -15330,8 +14137,6 @@ self: { libraryHaskellDepends = [ array base containers mtl ]; description = "Groebner basis computation for Operads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OptDir" = callPackage @@ -15359,8 +14164,6 @@ self: { ]; description = "A quasiquoter for or-patterns"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OrchestrateDB" = callPackage @@ -15380,8 +14183,6 @@ self: { ]; description = "Unofficial Haskell Client Library for the Orchestrate.io API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "OrderedBits" = callPackage @@ -15427,8 +14228,6 @@ self: { testHaskellDepends = [ base safe threepenny-gui ]; description = "A Programming Language in Construction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Oslo-Vectize" = callPackage @@ -15444,8 +14243,6 @@ self: { executableHaskellDepends = [ base ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PArrows" = callPackage @@ -15470,8 +14267,6 @@ self: { libraryHaskellDepends = [ base binary bytestring Crypto random ]; description = "Make password-based security schemes more secure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PCLT" = callPackage @@ -15485,8 +14280,6 @@ self: { ]; description = "Extension to Show: templating, catalogizing, languages, parameters, etc"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PCLT-DB" = callPackage @@ -15503,8 +14296,6 @@ self: { ]; description = "An addon to PCLT package: enchance PCLT catalog with PostgreSQL powers"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PDBtools" = callPackage @@ -15529,8 +14320,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A generic derivable Haskell pretty printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PSQueue" = callPackage @@ -15561,8 +14350,6 @@ self: { ]; description = "An implementation of Montague's PTQ"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PUH-Project" = callPackage @@ -15582,8 +14369,6 @@ self: { ]; description = "This is a package which includes Assignments, Email, User and Reviews modules for Programming in Haskell course"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PageIO" = callPackage @@ -15610,8 +14395,6 @@ self: { ]; description = "Page-oriented extraction and composition library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Paillier" = callPackage @@ -15630,8 +14413,6 @@ self: { ]; description = "a simple Paillier cryptosystem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PandocAgda" = callPackage @@ -15652,8 +14433,6 @@ self: { executableHaskellDepends = [ base ]; description = "Pandoc support for literate Agda"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Paraiso" = callPackage @@ -15678,8 +14457,6 @@ self: { ]; description = "a code generator for partial differential equations solvers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Parallel-Arrows-BaseSpec" = callPackage @@ -15729,8 +14506,6 @@ self: { ]; description = "Eden based backend for @Parallel-Arrows-Definition@"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Parallel-Arrows-Multicore" = callPackage @@ -15786,8 +14561,6 @@ self: { ]; description = "A proven synchronization server for high performance computing"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ParsecTools" = callPackage @@ -15832,8 +14605,6 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Simple library for generating passwords"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PastePipe" = callPackage @@ -15864,8 +14635,6 @@ self: { ]; description = "A tree used to merge and maintain paths"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Pathfinder" = callPackage @@ -15878,8 +14647,6 @@ self: { librarySystemDepends = [ libxml2 ]; description = "Relational optimiser and code generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libxml2;}; "Peano" = callPackage @@ -15902,8 +14669,6 @@ self: { libraryHaskellDepends = [ base ]; description = "GADT type witnesses for Peano-style natural numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PerfectHash" = callPackage @@ -15920,8 +14685,6 @@ self: { librarySystemDepends = [ cmph ]; description = "A perfect hashing library for mapping bytestrings to values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {cmph = null;}; "PermuteEffects" = callPackage @@ -15933,8 +14696,6 @@ self: { libraryHaskellDepends = [ base ReplicateEffects ]; description = "Permutations of effectful computations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Persistence" = callPackage @@ -15953,8 +14714,6 @@ self: { ]; description = "A versatile library for topological data analysis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Phsu" = callPackage @@ -15979,8 +14738,6 @@ self: { ]; description = "Personal Happstack Server Utils"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Pipe" = callPackage @@ -15992,8 +14749,6 @@ self: { libraryHaskellDepends = [ base filepath process unix ]; description = "Process piping library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Piso" = callPackage @@ -16005,8 +14760,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Partial isomorphisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PlayHangmanGame" = callPackage @@ -16040,8 +14793,6 @@ self: { ]; description = "Playing cards api"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Plot-ho-matic" = callPackage @@ -16063,8 +14814,6 @@ self: { ]; description = "Real-time line plotter for generic data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PlslTools" = callPackage @@ -16084,8 +14833,6 @@ self: { ]; description = "So far just a lint like program for PL/SQL. Diff and refactoring tools are planned"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Plural" = callPackage @@ -16110,8 +14857,6 @@ self: { executableHaskellDepends = [ array base clock GLUT random ]; description = "An imaginary world"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PortFusion" = callPackage @@ -16125,8 +14870,6 @@ self: { executableHaskellDepends = [ base bytestring network splice ]; description = "high-performance distributed reverse / forward proxy & tunneling for TCP"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PortMidi" = callPackage @@ -16186,8 +14929,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A Prelude module replacement"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PrimitiveArray" = callPackage @@ -16243,8 +14984,6 @@ self: { ]; description = "Pretty-printing for primitive arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Printf-TH" = callPackage @@ -16255,8 +14994,6 @@ self: { sha256 = "0n1gva510p69vy25zvjkzwqqz2gilbns1wnrzz2p22rjkkbrinvx"; libraryHaskellDepends = [ base haskell98 pretty template-haskell ]; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PriorityChansConverger" = callPackage @@ -16268,8 +15005,6 @@ self: { libraryHaskellDepends = [ base containers stm ]; description = "Read single output from an array of inputs - channels with priorities"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ProbabilityMonads" = callPackage @@ -16281,8 +15016,6 @@ self: { libraryHaskellDepends = [ base MaybeT MonadRandom mtl ]; description = "Probability distribution monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Probnet" = callPackage @@ -16322,8 +15055,6 @@ self: { executableHaskellDepends = [ base containers HUnit parsec syb ]; description = "An implementation of propositional logic in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ProxN" = callPackage @@ -16359,8 +15090,6 @@ self: { ]; description = "A Perl 6 Implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Pup-Events" = callPackage @@ -16380,8 +15109,6 @@ self: { doHaddock = false; description = "A networked event handling framework for hooking into other programs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Pup-Events-Client" = callPackage @@ -16415,8 +15142,6 @@ self: { ]; description = "A networked event handling framework for hooking into other programs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Pup-Events-PQueue" = callPackage @@ -16443,8 +15168,6 @@ self: { ]; description = "A networked event handling framework for hooking into other programs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "PyF" = callPackage @@ -16478,8 +15201,6 @@ self: { libraryHaskellDepends = [ base containers mtl old-time random ]; description = "The Quantum IO Monad is a library for defining quantum computations in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "QLearn" = callPackage @@ -16491,8 +15212,6 @@ self: { libraryHaskellDepends = [ base random vector ]; description = "A library for fast, easy-to-use Q-learning"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "QuadEdge" = callPackage @@ -16504,8 +15223,6 @@ self: { libraryHaskellDepends = [ base random vector ]; description = "QuadEdge structure for representing triangulations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "QuadTree" = callPackage @@ -16518,8 +15235,6 @@ self: { testHaskellDepends = [ base composition lens QuickCheck ]; description = "QuadTree library for Haskell, with lens support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "QuasiText" = callPackage @@ -16555,8 +15270,6 @@ self: { ]; description = "Programming with Eventual Consistency over Cassandra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "QuickAnnotate" = callPackage @@ -16571,8 +15284,6 @@ self: { executableHaskellDepends = [ base haskell-src-exts ]; description = "Annotation Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "QuickCheck" = callPackage @@ -16626,8 +15337,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Generator of \"valid\" and \"invalid\" data in a type class"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "QuickPlot" = callPackage @@ -16651,8 +15360,6 @@ self: { ]; description = "Quick and easy data visualization with Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Quickson" = callPackage @@ -16667,8 +15374,6 @@ self: { ]; description = "Quick JSON extractions with Aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "R-pandoc" = callPackage @@ -16686,8 +15391,6 @@ self: { ]; executableHaskellDepends = [ base pandoc-types ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RANSAC" = callPackage @@ -16763,8 +15466,6 @@ self: { ]; description = "A reflective JSON serializer/parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RLP" = callPackage @@ -16777,8 +15478,6 @@ self: { testHaskellDepends = [ base binary bytestring hspec ]; description = "RLP serialization as defined in Ethereum Yellow Paper"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RMP" = callPackage @@ -16799,8 +15498,6 @@ self: { executableSystemDepends = [ canlib ftd2xx ]; description = "Binding to code that controls a Segway RMP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {canlib = null; ftd2xx = null;}; "RNAFold" = callPackage @@ -16823,8 +15520,6 @@ self: { ]; description = "RNA secondary structure prediction"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RNAFoldProgs" = callPackage @@ -16844,8 +15539,6 @@ self: { ]; description = "RNA secondary structure folding"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RNAdesign" = callPackage @@ -16871,8 +15564,6 @@ self: { executableHaskellDepends = [ bytestring cmdargs file-embed ]; description = "Multi-target RNA sequence design"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RNAdraw" = callPackage @@ -16892,8 +15583,6 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "Draw RNA secondary structures"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RNAlien" = callPackage @@ -16926,8 +15615,6 @@ self: { ]; description = "Unsupervized construction of RNA family models"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RNAwolf" = callPackage @@ -16948,8 +15635,6 @@ self: { executableHaskellDepends = [ cmdargs split ]; description = "RNA folding with non-canonical basepairs and base-triplets"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RSA" = callPackage @@ -17004,8 +15689,6 @@ self: { ]; description = "AMQP 0-9-1 client library for RabbitMQ servers"; license = "BSD-3-Clause AND GPL-3.0-or-later"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Raincat" = callPackage @@ -17058,8 +15741,6 @@ self: { libraryHaskellDepends = [ base HTTP-Simple network ]; description = "Interface to random.org"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Randometer" = callPackage @@ -17084,8 +15765,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Data structure for managing ranges"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Ranged-sets" = callPackage @@ -17116,8 +15795,6 @@ self: { ]; description = "HTTP to XMPP omegle chats gate"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Rasenschach" = callPackage @@ -17138,8 +15815,6 @@ self: { ]; description = "Soccer simulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Rasterific" = callPackage @@ -17212,8 +15887,6 @@ self: { ]; description = "Library to access Redmine's REST services"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Ref" = callPackage @@ -17225,8 +15898,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Generic Mutable Ref Abstraction Layer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RefSerialize" = callPackage @@ -17262,8 +15933,6 @@ self: { ]; description = "A utility for computing distributions of material to review among reviewers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RepLib" = callPackage @@ -17279,8 +15948,6 @@ self: { ]; description = "Generic programming library with representation types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ReplicateEffects" = callPackage @@ -17292,8 +15959,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Composable replication schemes of applicative functors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ReviewBoard" = callPackage @@ -17312,8 +15977,6 @@ self: { ]; description = "Haskell bindings to ReviewBoard"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RichConditional" = callPackage @@ -17325,8 +15988,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Tiny library to replace classic if/else"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Ritt-Wu" = callPackage @@ -17355,8 +16016,6 @@ self: { ]; description = "Parallel implementation of Ritt-Wu's algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Rlang-QQ" = callPackage @@ -17380,8 +16039,6 @@ self: { testHaskellDepends = [ base directory doctest hspec lens vector ]; description = "quasiquoter for inline-R code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RollingDirectory" = callPackage @@ -17406,8 +16063,6 @@ self: { ]; description = "Limits the size of a directory's contents"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "RoyalMonad" = callPackage @@ -17437,8 +16092,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit vector ]; description = "Haskell wrapper for RtMidi, the lightweight, cross-platform MIDI I/O library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) alsaLib;}; "RxHaskell" = callPackage @@ -17450,8 +16103,6 @@ self: { libraryHaskellDepends = [ base containers stm transformers ]; description = "Reactive Extensions for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "S3" = callPackage @@ -17472,8 +16123,6 @@ self: { ]; description = "Library for accessing S3 compatible storage services"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SBench" = callPackage @@ -17491,8 +16140,6 @@ self: { ]; description = "A benchmark suite for runtime and heap measurements over a series of inputs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SCRIPTWriter" = callPackage @@ -17512,8 +16159,6 @@ self: { executableHaskellDepends = [ base ]; description = "ESCRIPT: a human friendly language for programming Bitcoin scripts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SCalendar" = callPackage @@ -17530,8 +16175,6 @@ self: { ]; description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SDL" = callPackage @@ -17647,8 +16290,6 @@ self: { ]; description = "SFML bindings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {csfml-audio = null; csfml-graphics = null; csfml-network = null; csfml-system = null; csfml-window = null; sfml-audio = null; sfml-graphics = null; sfml-network = null; @@ -17663,8 +16304,6 @@ self: { libraryHaskellDepends = [ base mtl SFML template-haskell ]; description = "Higher level library on top of SFML"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SFont" = callPackage @@ -17676,8 +16315,6 @@ self: { libraryHaskellDepends = [ array base SDL Sprig ]; description = "SFont SDL Bitmap Fonts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SG" = callPackage @@ -17689,8 +16326,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Small geometry library for dealing with vectors and collision detection"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SGdemo" = callPackage @@ -17704,8 +16339,6 @@ self: { executableHaskellDepends = [ base GLUT OpenGL SG ]; description = "An example of using the SG and OpenGL libraries"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SGplus" = callPackage @@ -17717,8 +16350,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "(updated) Small geometry library for dealing with vectors and collision detection"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SHA" = callPackage @@ -17774,8 +16405,6 @@ self: { benchmarkHaskellDepends = [ base directory filepath random time ]; description = "The Simple Javascript Wrench"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SMTPClient" = callPackage @@ -17792,8 +16421,6 @@ self: { ]; description = "A simple SMTP client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SNet" = callPackage @@ -17810,8 +16437,6 @@ self: { libraryToolDepends = [ c2hsc ]; description = "Declarative coördination language for streaming networks"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SQLDeps" = callPackage @@ -17842,8 +16467,6 @@ self: { testHaskellDepends = [ base containers ]; description = "STG Symbolic Execution"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "STL" = callPackage @@ -17855,8 +16478,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring cereal text ]; description = "STL 3D geometry format parsing and pretty-printing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "STLinkUSB" = callPackage @@ -17872,8 +16493,6 @@ self: { ]; description = "STLink USB interface in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "STM32-Zombie" = callPackage @@ -17890,8 +16509,6 @@ self: { ]; description = "control a STM32F103 microcontroller"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "STM32F103xx-SVD" = callPackage @@ -17934,8 +16551,6 @@ self: { ]; description = "translate a SVD of a Microcontroller to Haskell tables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SVG2Q" = callPackage @@ -17953,8 +16568,6 @@ self: { ]; description = "Code generation tool for Quartz code from a SVG"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SVGFonts" = callPackage @@ -18021,8 +16634,6 @@ self: { ]; description = "Generate a parser (in Haskell) with the SableCC parser generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Safe" = callPackage @@ -18060,8 +16671,6 @@ self: { librarySystemDepends = [ glib mono ]; description = "A .NET Bridge for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) glib; inherit (pkgs) mono;}; "Saturnin" = callPackage @@ -18085,8 +16694,6 @@ self: { testHaskellDepends = [ base data-default either hlint hspec mtl ]; description = "Saturnin CI / Job System"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SciBaseTypes" = callPackage @@ -18115,8 +16722,6 @@ self: { ]; description = "Base types and classes for statistics, sciences and humanities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SciFlow" = callPackage @@ -18141,8 +16746,6 @@ self: { ]; description = "Scientific workflow management system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SciFlow-drmaa" = callPackage @@ -18159,8 +16762,6 @@ self: { ]; description = "Scientific workflow management system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ScratchFs" = callPackage @@ -18179,8 +16780,6 @@ self: { ]; description = "Size limited temp filesystem based on fuse"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Scurry" = callPackage @@ -18199,8 +16798,6 @@ self: { ]; description = "A cross platform P2P VPN application built using Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SecureHash-SHA3" = callPackage @@ -18214,8 +16811,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "simple static linked SHA3 using private symbols and the ref impl"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SegmentTree" = callPackage @@ -18253,8 +16848,6 @@ self: { ]; description = "Selects a representative subset of sequences from multiple sequence alignment"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Semantique" = callPackage @@ -18273,8 +16866,6 @@ self: { ]; description = "Command-line tool for maintaining the Semantique database"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Semigroup" = callPackage @@ -18286,8 +16877,6 @@ self: { libraryHaskellDepends = [ base bytestring containers mtl ]; description = "A semigroup"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SeqAlign" = callPackage @@ -18299,8 +16888,6 @@ self: { libraryHaskellDepends = [ base bytestring vector ]; description = "Sequence Alignment"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SessionLogger" = callPackage @@ -18316,8 +16903,6 @@ self: { ]; description = "Easy Loggingframework"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Set" = callPackage @@ -18331,8 +16916,6 @@ self: { benchmarkHaskellDepends = [ base containers gauge util ]; description = "See README for more info"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ShellCheck" = callPackage @@ -18373,8 +16956,6 @@ self: { libraryHaskellDepends = [ base directory mtl unix ]; description = "A framework for creating shell envinronments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shellac-compatline" = callPackage @@ -18388,8 +16969,6 @@ self: { libraryHaskellDepends = [ base Shellac Shellac-readline ]; description = "\"compatline\" backend module for Shellac"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shellac-editline" = callPackage @@ -18403,8 +16982,6 @@ self: { libraryHaskellDepends = [ base editline Shellac ]; description = "Editline backend module for Shellac"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shellac-haskeline" = callPackage @@ -18416,8 +16993,6 @@ self: { libraryHaskellDepends = [ base haskeline mtl Shellac ]; description = "Haskeline backend module for Shellac"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shellac-readline" = callPackage @@ -18431,8 +17006,6 @@ self: { libraryHaskellDepends = [ base readline Shellac ]; description = "Readline backend module for Shellac"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ShortestPathProblems" = callPackage @@ -18453,8 +17026,6 @@ self: { ]; description = "grammars for TSP and SHP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ShowF" = callPackage @@ -18501,8 +17072,6 @@ self: { ]; description = "A Virtual Dom in pure Haskell, based on Html as an Alignable Functor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-backend-snabbdom" = callPackage @@ -18520,8 +17089,6 @@ self: { ]; description = "Use the high-performance Snabbdom virtual dom library written in JavaScript"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-backend-static" = callPackage @@ -18533,8 +17100,6 @@ self: { libraryHaskellDepends = [ base compactable Shpadoinkle text ]; description = "A backend for rendering Shpadoinkle as Text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-console" = callPackage @@ -18580,8 +17145,6 @@ self: { ]; description = "Chrome extension to aide in development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-disembodied" = callPackage @@ -18600,8 +17163,6 @@ self: { ]; description = "Shpadoinkle as a static site"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-examples" = callPackage @@ -18633,8 +17194,6 @@ self: { ]; description = "Example usages of Shpadoinkle"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-html" = callPackage @@ -18653,8 +17212,6 @@ self: { ]; description = "A typed, template generated Html DSL, and helpers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-lens" = callPackage @@ -18689,8 +17246,6 @@ self: { ]; description = "A single page application rounter for Shpadoinkle based on Servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-streaming" = callPackage @@ -18702,8 +17257,6 @@ self: { libraryHaskellDepends = [ base lens Shpadoinkle streaming text ]; description = "Integration of the streaming library with Shpadoinkle continuations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-template" = callPackage @@ -18724,8 +17277,6 @@ self: { ]; description = "Read standard file formats into Shpadoinkle with Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shpadoinkle-widgets" = callPackage @@ -18749,8 +17300,6 @@ self: { ]; description = "A collection of common reusable types and components"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Shrub" = callPackage @@ -18813,8 +17362,6 @@ self: { ]; description = "A Simple Graphics Library from the SimpleH framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SimpleH" = callPackage @@ -18851,8 +17398,6 @@ self: { ]; description = "Simple, configurable logging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SimpleServer" = callPackage @@ -18873,8 +17418,6 @@ self: { ]; description = "A simple static file server, for when apache is overkill"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SimpleTableGenerator" = callPackage @@ -18935,8 +17478,6 @@ self: { testHaskellDepends = [ base file-embed ]; description = "Generate slides from Haskell code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Smooth" = callPackage @@ -18952,8 +17493,6 @@ self: { ]; description = "A tiny, lazy SMT solver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SmtLib" = callPackage @@ -18965,8 +17504,6 @@ self: { libraryHaskellDepends = [ base parsec transformers ]; description = "Library for parsing SMTLIB2"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Snusmumrik" = callPackage @@ -18989,8 +17526,6 @@ self: { executableToolDepends = [ cpphs ]; description = "E-library directory based on FUSE virtual file system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zip;}; "SoOSiM" = callPackage @@ -19007,8 +17542,6 @@ self: { ]; description = "Abstract full system simulator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SoccerFun" = callPackage @@ -19028,8 +17561,6 @@ self: { ]; description = "Football simulation framework for teaching functional programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SoccerFunGL" = callPackage @@ -19049,8 +17580,6 @@ self: { ]; description = "OpenGL UI for the SoccerFun framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Sonnex" = callPackage @@ -19063,8 +17592,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Sonnex is an alternative to Soundex for french language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SourceGraph" = callPackage @@ -19083,8 +17610,6 @@ self: { ]; description = "Static code analysis using graph-theoretic techniques"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Southpaw" = callPackage @@ -19117,8 +17642,6 @@ self: { executableHaskellDepends = [ array base HGL random Yampa ]; description = "Video game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SpacePrivateers" = callPackage @@ -19140,8 +17663,6 @@ self: { ]; description = "Simple space pirate roguelike"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SpinCounter" = callPackage @@ -19153,8 +17674,6 @@ self: { libraryHaskellDepends = [ base monad-loops ref-mtl stm ]; description = "Lock free Spin Counter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Spintax" = callPackage @@ -19193,8 +17712,6 @@ self: { ]; description = "Another Haskell web framework for rapid development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Spock-api" = callPackage @@ -19221,8 +17738,6 @@ self: { ]; description = "Another Haskell web framework for rapid development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Spock-api-server" = callPackage @@ -19245,8 +17760,6 @@ self: { libraryHaskellDepends = [ base http-types Spock text time ]; description = "Provides authentification helpers for Spock"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Spock-core" = callPackage @@ -19302,8 +17815,6 @@ self: { libraryHaskellDepends = [ base lucid Spock transformers ]; description = "Lucid support for Spock"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Spock-worker" = callPackage @@ -19321,8 +17832,6 @@ self: { testHaskellDepends = [ base containers HTF stm vector ]; description = "Background workers for Spock"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SpreadsheetML" = callPackage @@ -19345,8 +17854,6 @@ self: { libraryHaskellDepends = [ base SDL ]; description = "Binding to Sprig"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Stack" = callPackage @@ -19374,8 +17881,6 @@ self: { executableHaskellDepends = [ base ]; description = "A simple MVCC like library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "StateVar" = callPackage @@ -19425,8 +17930,6 @@ self: { ]; description = "Libary for Stockholm aligmnent format"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Stomp" = callPackage @@ -19442,8 +17945,6 @@ self: { ]; description = "Client library for Stomp brokers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Strafunski-ATermLib" = callPackage @@ -19455,8 +17956,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "An abstract data type designed for the exchange of tree-like data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Strafunski-Sdf2Haskell" = callPackage @@ -19476,8 +17975,6 @@ self: { ]; description = "Converts SDF to Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Strafunski-StrategyLib" = callPackage @@ -19491,8 +17988,6 @@ self: { libraryHaskellDepends = [ base directory mtl syb transformers ]; description = "Library for strategic programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "StrappedTemplates" = callPackage @@ -19510,8 +18005,6 @@ self: { testHaskellDepends = [ base blaze-builder bytestring hspec text ]; description = "General purpose templates in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "StrategyLib" = callPackage @@ -19546,8 +18039,6 @@ self: { libraryHaskellDepends = [ base benchpress parallel ]; description = "Benchmarking code through strict evaluation"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "StrictCheck" = callPackage @@ -19566,8 +18057,6 @@ self: { ]; description = "StrictCheck: Keep Your Laziness In Check"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "StringUtils" = callPackage @@ -19605,8 +18094,6 @@ self: { ]; description = "Suffix array construction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SybWidget" = callPackage @@ -19622,8 +18109,6 @@ self: { ]; description = "Library which aids constructing generic (SYB3-based) widgets"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "SyntaxMacros" = callPackage @@ -19640,8 +18125,6 @@ self: { ]; description = "Syntax Macros in the form of an EDSL"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Sysmon" = callPackage @@ -19662,8 +18145,6 @@ self: { ]; description = "Sybase 15 sysmon reports processor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TBC" = callPackage @@ -19684,8 +18165,6 @@ self: { ]; description = "Testing By Convention"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TBit" = callPackage @@ -19702,8 +18181,6 @@ self: { ]; description = "Utilities for condensed matter physics tight binding calculations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TCache" = callPackage @@ -19752,8 +18229,6 @@ self: { executableHaskellDepends = [ base bytestring Yampa ]; description = "Bindings to the TORCS vehicle simulator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TTTAS" = callPackage @@ -19776,8 +18251,6 @@ self: { libraryHaskellDepends = [ base DeepArrow TypeCompose ]; description = "Tangible Values -- composable interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TYB" = callPackage @@ -19793,8 +18266,6 @@ self: { ]; description = "Template Your Boilerplate - a Template Haskell version of SYB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TableAlgebra" = callPackage @@ -19823,8 +18294,6 @@ self: { executableHaskellDepends = [ base cookbook ]; description = "A client for Quill databases"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Tablify" = callPackage @@ -19838,8 +18307,6 @@ self: { executableHaskellDepends = [ base parsec xhtml ]; description = "Tool to render CSV into tables of various formats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Tahin" = callPackage @@ -19883,8 +18350,6 @@ self: { libraryHaskellDepends = [ base mtl old-time time ]; description = "Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Tape" = callPackage @@ -19896,8 +18361,6 @@ self: { libraryHaskellDepends = [ base comonad distributive Stream ]; description = "Bidirectionally infinite streams, akin to the tape of a Turing machine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TaskMonad" = callPackage @@ -19916,8 +18379,6 @@ self: { ]; description = "A collection of tools which can be used to access taskwarrior from xmonad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Taxonomy" = callPackage @@ -19933,8 +18394,6 @@ self: { ]; description = "Libary for parsing, processing and vizualization of taxonomy data"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TaxonomyTools" = callPackage @@ -19954,8 +18413,6 @@ self: { ]; description = "Tool for parsing, processing, comparing and visualizing taxonomy data"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TeX-my-math" = callPackage @@ -19984,8 +18441,6 @@ self: { ]; description = "Render general Haskell math to LaTeX. Or: math typesetting with high signal-to-noise–ratio."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TeaHS" = callPackage @@ -20001,8 +18456,6 @@ self: { ]; description = "TeaHS Game Creation Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Tensor" = callPackage @@ -20057,8 +18510,6 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ ogg theora ]; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ogg = null; theora = null;}; "Thingie" = callPackage @@ -20070,8 +18521,6 @@ self: { libraryHaskellDepends = [ base cairo gtk mtl ]; description = "Purely functional 2D drawing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ThreadObjects" = callPackage @@ -20129,8 +18578,6 @@ self: { ]; description = "A sub-project (exercise) for a functional programming course"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TigerHash" = callPackage @@ -20165,8 +18612,6 @@ self: { ]; description = "A simple tile-based digital clock screen saver"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TinyLaunchbury" = callPackage @@ -20178,8 +18623,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Simple implementation of call-by-need using Launchbury's semantics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TinyURL" = callPackage @@ -20191,8 +18634,6 @@ self: { libraryHaskellDepends = [ base HTTP network ]; description = "Use TinyURL to compress URLs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Titim" = callPackage @@ -20206,8 +18647,6 @@ self: { executableHaskellDepends = [ base containers matrix random ]; description = "Game for Lounge Marmelade"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Top" = callPackage @@ -20222,8 +18661,6 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Constraint solving framework employed by the Helium Compiler"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TotalMap" = callPackage @@ -20243,8 +18680,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "A total map datatype"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Tournament" = callPackage @@ -20262,8 +18697,6 @@ self: { ]; description = "Tournament related algorithms"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TraceUtils" = callPackage @@ -20292,8 +18725,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "eDSL in R for Safe Variable Transformarion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TransformersStepByStep" = callPackage @@ -20307,8 +18738,6 @@ self: { executableHaskellDepends = [ base containers mtl ]; description = "Tutorial on monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Transhare" = callPackage @@ -20331,8 +18760,6 @@ self: { libraryHaskellDepends = [ base ref-mtl stm ]; description = "Wait-free Tree Counter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TreeStructures" = callPackage @@ -20344,8 +18771,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A collection of heaps and search trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TreeT" = callPackage @@ -20368,8 +18793,6 @@ self: { libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ]; description = "Lock free Treiber stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TrendGraph" = callPackage @@ -20386,8 +18809,6 @@ self: { ]; description = "A simple trend Graph script"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TrieMap" = callPackage @@ -20405,8 +18826,6 @@ self: { ]; description = "Automatic type inference of generalized tries with Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Twofish" = callPackage @@ -20445,8 +18864,6 @@ self: { ]; description = "Typing speed game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TypeCompose" = callPackage @@ -20473,8 +18890,6 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "TypeIlluminator is a prototype tool exploring debugging of type errors/"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TypeNat" = callPackage @@ -20486,8 +18901,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Some Nat-indexed types for GHC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "TypingTester" = callPackage @@ -20533,8 +18946,6 @@ self: { ]; description = "A small command-line accounting tool"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "URLT" = callPackage @@ -20552,8 +18963,6 @@ self: { ]; description = "Library for maintaining correctness of URLs within an application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "URLb" = callPackage @@ -20565,8 +18974,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring containers ]; description = "DEPRECATED A simple, liberal URL parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "UTFTConverter" = callPackage @@ -20590,8 +18997,6 @@ self: { ]; description = "Processing popular picture formats into .c or .raw format in RGB565"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Unique" = callPackage @@ -20651,8 +19056,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Monadic FRP library based on stm"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "UrlDisp" = callPackage @@ -20664,8 +19067,6 @@ self: { libraryHaskellDepends = [ base cgi MaybeT mtl ]; description = "Url dispatcher. Helps to retain friendly URLs in web applications."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Useful" = callPackage @@ -20718,8 +19119,6 @@ self: { ]; description = "Provides access to Vkontakte social network via public API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "VRML" = callPackage @@ -20743,8 +19142,6 @@ self: { ]; description = "VRML parser and generator for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Validation" = callPackage @@ -20758,8 +19155,6 @@ self: { ]; description = "A data-type like Either but with an accumulating Applicative"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Vec" = callPackage @@ -20782,8 +19177,6 @@ self: { libraryHaskellDepends = [ base Boolean Vec ]; description = "Provides Boolean instances for the Vec package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Vec-OpenGLRaw" = callPackage @@ -20795,8 +19188,6 @@ self: { libraryHaskellDepends = [ base OpenGLRaw Vec ]; description = "Instances and functions to interoperate Vec and OpenGL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Vec-Transform" = callPackage @@ -20808,8 +19199,6 @@ self: { doHaddock = false; description = "This package is obsolete"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "VecN" = callPackage @@ -20835,8 +19224,6 @@ self: { executableHaskellDepends = [ base containers matrix ]; description = "A solver for the WordBrain game"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ViennaRNA-bindings" = callPackage @@ -20880,8 +19267,6 @@ self: { ]; description = "ViennaRNA v2 extensions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ViennaRNAParser" = callPackage @@ -20928,8 +19313,6 @@ self: { ]; description = "Villefort is a task manager and time tracker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Vulkan" = callPackage @@ -20971,8 +19354,6 @@ self: { ]; description = "WAVE audio file IO library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WEditor" = callPackage @@ -20986,8 +19367,6 @@ self: { doHaddock = false; description = "Generic text-editor logic for use with fixed-width fonts"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WEditorBrick" = callPackage @@ -21002,8 +19381,6 @@ self: { executableHaskellDepends = [ base brick vty WEditor ]; description = "Text-editor widget with dynamic line-wrapping for use with Brick"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WEditorHyphen" = callPackage @@ -21016,8 +19393,6 @@ self: { testHaskellDepends = [ base directory hyphenation WEditor ]; description = "Language-specific hyphenation policies for WEditor"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WL500gPControl" = callPackage @@ -21034,8 +19409,6 @@ self: { ]; description = "A simple command line tools to control the Asus WL500gP router"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WL500gPLib" = callPackage @@ -21050,8 +19423,6 @@ self: { executableHaskellDepends = [ base ]; description = "A simple library to access to the WL 500gP router from the Haskell code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WMSigner" = callPackage @@ -21071,8 +19442,6 @@ self: { ]; description = "WebMoney authentication module"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WURFL" = callPackage @@ -21084,8 +19453,6 @@ self: { libraryHaskellDepends = [ base haskell98 parsec ]; description = "Convert the WURFL file into a Parsec parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WXDiffCtrl" = callPackage @@ -21098,8 +19465,6 @@ self: { libraryHaskellDepends = [ base containers wx wxcore ]; description = "WXDiffCtrl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WashNGo" = callPackage @@ -21118,8 +19483,6 @@ self: { executableHaskellDepends = [ directory ghc-paths process ]; description = "WASH is a family of EDSLs for programming Web applications in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WaveFront" = callPackage @@ -21136,8 +19499,6 @@ self: { ]; description = "Parsers and utilities for the OBJ WaveFront 3D model format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Weather" = callPackage @@ -21164,8 +19525,6 @@ self: { libraryHaskellDepends = [ base containers mtl parsec pretty syb ]; description = "JavaScript analysis tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WebBits-Html" = callPackage @@ -21181,8 +19540,6 @@ self: { ]; description = "JavaScript analysis tools"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WebBits-multiplate" = callPackage @@ -21199,8 +19556,6 @@ self: { ]; description = "A Multiplate instance for JavaScript"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WebCont" = callPackage @@ -21219,8 +19574,6 @@ self: { ]; description = "Continuation based web programming for Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WeberLogic" = callPackage @@ -21235,8 +19588,6 @@ self: { executableHaskellDepends = [ base parsec ]; description = "Logic interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Webrexp" = callPackage @@ -21263,8 +19614,6 @@ self: { ]; description = "Regexp-like engine to scrap web data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Wheb" = callPackage @@ -21289,8 +19638,6 @@ self: { ]; description = "The frictionless WAI Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WikimediaParser" = callPackage @@ -21302,8 +19649,6 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "A parser for wikimedia style article markup"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Win32" = callPackage @@ -21484,8 +19829,6 @@ self: { ]; description = "Wire-aware hardware description"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WordAlignment" = callPackage @@ -21525,8 +19868,6 @@ self: { ]; description = "Bigram word pair alignments"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WordNet" = callPackage @@ -21540,8 +19881,6 @@ self: { libraryHaskellDepends = [ array base containers filepath ]; description = "Haskell interface to the WordNet database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WordNet-ghc74" = callPackage @@ -21555,8 +19894,6 @@ self: { libraryHaskellDepends = [ array base containers filepath ]; description = "Haskell interface to the WordNet database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Wordlint" = callPackage @@ -21591,8 +19928,6 @@ self: { ]; description = "Workflow patterns over a monad for thread state logging & recovery"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "WxGeneric" = callPackage @@ -21607,8 +19942,6 @@ self: { ]; description = "Generic (SYB3) construction of wxHaskell widgets"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "X" = callPackage @@ -21656,8 +19989,6 @@ self: { librarySystemDepends = [ libX11 ]; description = "Missing bindings to the X11 graphics library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs.xorg) libX11;}; "X11-rm" = callPackage @@ -21669,8 +20000,6 @@ self: { libraryHaskellDepends = [ base X11 ]; description = "A binding to the resource management functions missing from X11"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "X11-xdamage" = callPackage @@ -21683,8 +20012,6 @@ self: { librarySystemDepends = [ Xdamage ]; description = "A binding to the Xdamage X11 extension library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {Xdamage = null;}; "X11-xfixes" = callPackage @@ -21697,8 +20024,6 @@ self: { librarySystemDepends = [ Xfixes ]; description = "A binding to the Xfixes X11 extension library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {Xfixes = null;}; "X11-xft" = callPackage @@ -21790,8 +20115,6 @@ self: { librarySystemDepends = [ xmmsclient xmmsclient-glib ]; description = "XMMS2 client library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {xmmsclient = null; xmmsclient-glib = null;}; "XMPP" = callPackage @@ -21808,8 +20131,6 @@ self: { ]; description = "XMPP library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "XSaiga" = callPackage @@ -21836,8 +20157,6 @@ self: { ]; description = "An implementation of a polynomial-time top-down parser suitable for NLP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Xauth" = callPackage @@ -21868,8 +20187,6 @@ self: { ]; description = "Gtk command launcher with identicon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "XmlHtmlWriter" = callPackage @@ -21881,8 +20198,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "A library for writing XML and HTML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Xorshift128Plus" = callPackage @@ -21894,8 +20209,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Pure haskell implementation of xorshift128plus random number generator"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "YACPong" = callPackage @@ -21916,8 +20229,6 @@ self: { ]; description = "Yet Another Pong Clone using SDL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "YFrob" = callPackage @@ -21929,8 +20240,6 @@ self: { libraryHaskellDepends = [ array base HGL Yampa ]; description = "Yampa-based library for programming robots"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Yablog" = callPackage @@ -21965,8 +20274,6 @@ self: { ]; description = "A simple blog engine powered by Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "YamlReference" = callPackage @@ -21994,8 +20301,6 @@ self: { ]; description = "YAML reference implementation"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Yampa" = callPackage @@ -22043,8 +20348,6 @@ self: { ]; description = "Software synthesizer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Yocto" = callPackage @@ -22072,8 +20375,6 @@ self: { ]; description = "A MUD client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Yogurt-Standalone" = callPackage @@ -22093,8 +20394,6 @@ self: { executableSystemDepends = [ readline ]; description = "A functional MUD client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) readline;}; "Z-Data" = callPackage @@ -22121,8 +20420,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Array, vector and text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Z-IO" = callPackage @@ -22149,8 +20446,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Simple and high performance IO toolkit for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Z-MessagePack" = callPackage @@ -22175,8 +20470,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "MessagePack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Z-YAML" = callPackage @@ -22194,8 +20487,6 @@ self: { testHaskellDepends = [ base hspec Z-Data ]; description = "YAML tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ZEBEDDE" = callPackage @@ -22209,8 +20500,6 @@ self: { libraryHaskellDepends = [ base vect ]; description = "Polymer growth simulation method"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ZFS" = callPackage @@ -22226,8 +20515,6 @@ self: { ]; description = "Oleg's Zipper FS"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ZMachine" = callPackage @@ -22242,8 +20529,6 @@ self: { executableHaskellDepends = [ array base gtk mtl random ]; description = "A Z-machine interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ZipFold" = callPackage @@ -22294,8 +20579,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinators for bidirectional URL routing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "a50" = callPackage @@ -22314,8 +20597,6 @@ self: { ]; description = "Compare genome assemblies"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "abacate" = callPackage @@ -22369,8 +20650,6 @@ self: { ]; description = "Bindings for ABC, A System for Sequential Synthesis and Verification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {abc = null;}; "abcnotation" = callPackage @@ -22384,8 +20663,6 @@ self: { ]; description = "Haskell representation and parser for ABC notation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "abeson" = callPackage @@ -22405,8 +20682,6 @@ self: { ]; description = "interconversion between aeson and bson"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "abides" = callPackage @@ -22419,8 +20694,6 @@ self: { testHaskellDepends = [ base comonad tasty tasty-quickcheck ]; description = "Simple boolean tests to see if a value abides by certain properties"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "abnf" = callPackage @@ -22440,8 +20713,6 @@ self: { ]; description = "Parse ABNF and generate parsers for the specified document"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "abstract-deque" = callPackage @@ -22497,8 +20768,6 @@ self: { ]; description = "Provides the class ParAccelerate, nothing more"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "abt" = callPackage @@ -22514,8 +20783,6 @@ self: { ]; description = "Abstract binding trees for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ac-machine" = callPackage @@ -22529,8 +20796,6 @@ self: { ]; description = "Aho-Corasick string matching algorithm in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ac-machine-conduit" = callPackage @@ -22542,8 +20807,6 @@ self: { libraryHaskellDepends = [ ac-machine base conduit text ]; description = "Drive Aho-Corasick machines in Conduit pipelines"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acc" = callPackage @@ -22563,8 +20826,6 @@ self: { benchmarkHaskellDepends = [ criterion rerebase ]; description = "Sequence optimized for monoidal construction and folding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accelerate" = callPackage @@ -22610,8 +20871,6 @@ self: { ]; description = "Linear algebra and interpolation using the Accelerate framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accelerate-bignum" = callPackage @@ -22823,8 +21082,6 @@ self: { ]; description = "Accelerate frontend to the FFTW library (Fourier transform)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accelerate-fourier" = callPackage @@ -22850,8 +21107,6 @@ self: { ]; description = "Fast Fourier transform and convolution using the Accelerate framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accelerate-fourier-benchmark" = callPackage @@ -23069,8 +21324,6 @@ self: { testHaskellDepends = [ accelerate base ]; description = "Accelerate backend for multicore CPUs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accelerate-llvm-ptx" = callPackage @@ -23104,8 +21357,6 @@ self: { libraryHaskellDepends = [ accelerate base mwc-random ]; description = "Generate Accelerate arrays filled with high quality pseudorandom numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accelerate-typelits" = callPackage @@ -23128,8 +21379,6 @@ self: { ]; description = "a typesafe way encode accelerate matrices and vectors"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accelerate-utility" = callPackage @@ -23141,8 +21390,6 @@ self: { libraryHaskellDepends = [ accelerate base utility-ht ]; description = "Utility functions for the Accelerate framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accentuateus" = callPackage @@ -23154,8 +21401,6 @@ self: { libraryHaskellDepends = [ base bytestring HTTP json network text ]; description = "A Haskell implementation of the Accentuate.us API."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "access-time" = callPackage @@ -23167,8 +21412,6 @@ self: { libraryHaskellDepends = [ base filepath old-time time unix ]; description = "Cross-platform support for retrieving file access times"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "access-token-provider" = callPackage @@ -23195,8 +21438,6 @@ self: { ]; description = "Provides Access Token for Services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "accuerr" = callPackage @@ -23249,8 +21490,6 @@ self: { ]; description = "A library for building static site generators"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acid-state" = callPackage @@ -23307,8 +21546,6 @@ self: { ]; description = "A replication backend for acid-state"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acid-state-tls" = callPackage @@ -23324,8 +21561,6 @@ self: { ]; description = "Add TLS support for Data.Acid.Remote"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acl2" = callPackage @@ -23348,8 +21583,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A monad which is powerful enough to interpret any action"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-box" = callPackage @@ -23427,8 +21660,6 @@ self: { libraryHaskellDepends = [ base comonad ]; description = "A more efficient dualization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-cuteboy" = callPackage @@ -23480,8 +21711,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "A \"don't\" construct"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-flipping-tables" = callPackage @@ -23493,8 +21722,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Stop execution with rage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-functors" = callPackage @@ -23528,8 +21755,6 @@ self: { libraryHaskellDepends = [ base ]; description = "An embedded DSL for the HQ9+ programming language"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-http" = callPackage @@ -23547,8 +21772,6 @@ self: { ]; description = "fastest Haskell PONG server in the world"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-inator" = callPackage @@ -23563,8 +21786,6 @@ self: { executableHaskellDepends = [ base ]; description = "Evil inventions in the Tri-State area"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-io" = callPackage @@ -23599,8 +21820,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A place for dumping that does-not-feel-right code while you improve it"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-left-pad" = callPackage @@ -23612,8 +21831,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "free your haskell from the tyranny of npm!"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-lolcat" = callPackage @@ -23669,8 +21886,6 @@ self: { libraryHaskellDepends = [ base random ]; description = "Miscellaneous newtypes for orderings of discutable use"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-missiles" = callPackage @@ -23696,8 +21911,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A mutable package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-now" = callPackage @@ -23709,8 +21922,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "An interface to the philosophical and metaphysical \"now\""; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-numbersystem" = callPackage @@ -23722,8 +21933,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Define the less than and add and subtract for nats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-omitted" = callPackage @@ -23758,8 +21967,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Operators of base, all in one place!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-php" = callPackage @@ -23771,8 +21978,6 @@ self: { libraryHaskellDepends = [ acme-left-pad base ]; description = "The flexibility of Haskell and the safety of PHP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-pointful-numbers" = callPackage @@ -23824,8 +22029,6 @@ self: { ]; description = "Proper names for curry and uncurry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-smuggler" = callPackage @@ -23849,8 +22052,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A binding to the glibc strfry function"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-stringly-typed" = callPackage @@ -23864,8 +22065,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Stringly Typed Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-strtok" = callPackage @@ -23890,8 +22089,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "import This"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acme-timemachine" = callPackage @@ -23940,8 +22137,6 @@ self: { doHaddock = false; description = "The absorbing element of package dependencies"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acousticbrainz-client" = callPackage @@ -23965,8 +22160,6 @@ self: { ]; description = "AcousticBrainz API client"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acquire" = callPackage @@ -24037,8 +22230,6 @@ self: { ]; description = "Haskell code presentation tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "activehs-base" = callPackage @@ -24052,8 +22243,6 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Basic definitions for activehs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "activitypub" = callPackage @@ -24065,8 +22254,6 @@ self: { libraryHaskellDepends = [ aeson base network-uri text time ]; description = "ActivityPub Haskell Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "activitystreams-aeson" = callPackage @@ -24080,8 +22267,6 @@ self: { ]; description = "An interface to the ActivityStreams specification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "actor" = callPackage @@ -24094,8 +22279,6 @@ self: { libraryHaskellDepends = [ base haskell98 stm time ]; description = "Actors with multi-headed receive clauses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "acts" = callPackage @@ -24113,8 +22296,6 @@ self: { doHaddock = false; description = "Semigroup actions and torsors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ad" = callPackage @@ -24148,8 +22329,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Self optimizing container types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adaptive-tuple" = callPackage @@ -24161,8 +22340,6 @@ self: { libraryHaskellDepends = [ base template-haskell type-level ]; description = "Self-optimizing tuple types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adb" = callPackage @@ -24177,8 +22354,6 @@ self: { ]; description = "Android Debug Bridge (ADB) protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adblock2privoxy" = callPackage @@ -24234,8 +22409,6 @@ self: { ]; description = "A full-featured library for parsing, validating, and rendering email addresses"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adhoc-network" = callPackage @@ -24253,8 +22426,6 @@ self: { ]; description = "Ad-hoc P2P network protocol"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adict" = callPackage @@ -24276,8 +22447,6 @@ self: { ]; description = "Approximate dictionary searching"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adjunction" = callPackage @@ -24293,8 +22462,6 @@ self: { benchmarkHaskellDepends = [ base gauge hs-functors ]; description = "See README for more info"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adjunctions" = callPackage @@ -24351,8 +22518,6 @@ self: { ]; description = "parse Adobe Swatch Exchange files and (optionally) output .css files with the colors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adp-multi" = callPackage @@ -24373,8 +22538,6 @@ self: { ]; description = "ADP for multiple context-free languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adp-multi-monadiccp" = callPackage @@ -24394,8 +22557,6 @@ self: { ]; description = "Subword construction in adp-multi using monadiccp"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "adtrees" = callPackage @@ -24407,8 +22568,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Modelling, rendering and quantitative analysis on attack defense trees"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "advent-of-code-api" = callPackage @@ -24431,8 +22590,6 @@ self: { testHaskellDepends = [ base directory filepath HUnit text ]; description = "Advent of Code REST API bindings and servant API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "advent-of-code-ocr" = callPackage @@ -24482,8 +22639,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Multi-precision ball (interval) arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aern2-real" = callPackage @@ -24507,8 +22662,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Exact real numbers via Cauchy sequences and MPFR"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson" = callPackage @@ -24554,8 +22707,6 @@ self: { libraryHaskellDepends = [ aeson base text unordered-containers ]; description = "make To/From JSOn instances from an applicative description"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-attoparsec" = callPackage @@ -24714,8 +22865,6 @@ self: { ]; description = "Easy functions for converting from Aeson.Value"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-default" = callPackage @@ -24792,8 +22941,6 @@ self: { ]; description = "Apply a json-patch to any haskell datatype"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-extra" = callPackage @@ -24823,8 +22970,6 @@ self: { ]; description = "Extra goodies for aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-filthy" = callPackage @@ -24843,8 +22988,6 @@ self: { ]; description = "Several newtypes and combinators for dealing with less-than-cleanly JSON input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-flat" = callPackage @@ -24894,8 +23037,6 @@ self: { ]; description = "Create Flow type definitions from Haskell data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-gadt-th" = callPackage @@ -24969,8 +23110,6 @@ self: { ]; description = "Injecting fields into aeson values"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-iproute" = callPackage @@ -25034,8 +23173,6 @@ self: { ]; description = "Declarative JSON matchers"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-native" = callPackage @@ -25056,8 +23193,6 @@ self: { ]; description = "Fast JSON parsing and encoding (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-optics" = callPackage @@ -25090,8 +23225,6 @@ self: { libraryHaskellDepends = [ aeson base ]; description = "Options to derive FromJSON/ToJSON instances"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-parsec-picky" = callPackage @@ -25135,8 +23268,6 @@ self: { testHaskellDepends = [ aeson base bytestring hspec mtl text ]; description = "Hiearchical prefixing for aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-pretty" = callPackage @@ -25239,8 +23370,6 @@ self: { ]; description = "Haskell JSON schema validator and parser generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-schemas" = callPackage @@ -25270,8 +23399,6 @@ self: { ]; description = "Easily consume JSON data on-demand with type-safety"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-serialize" = callPackage @@ -25300,8 +23427,6 @@ self: { ]; description = "Smart derivation of Aeson instances"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-streams" = callPackage @@ -25317,8 +23442,6 @@ self: { ]; description = "An HTTP client library for JSON-based APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-t" = callPackage @@ -25338,8 +23461,6 @@ self: { ]; description = "Transform JSON"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-tiled" = callPackage @@ -25359,8 +23480,6 @@ self: { testHaskellDepends = [ aeson base hspec ]; description = "Aeson instances for the Tiled map editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-toolkit" = callPackage @@ -25395,8 +23514,6 @@ self: { ]; description = "Generate TypeScript definition files from your ADTs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-utils" = callPackage @@ -25414,8 +23531,6 @@ self: { ]; description = "Utilities for working with Aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-value-parser" = callPackage @@ -25451,8 +23566,6 @@ self: { ]; description = "Wrappers to derive-via Aeson ToJSON/FromJSON typeclasses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aeson-with" = callPackage @@ -25524,8 +23637,6 @@ self: { ]; description = "A simple Game Engine using SDL"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "affine" = callPackage @@ -25554,8 +23665,6 @@ self: { ]; description = "General-purpose sampling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "affinely-extended" = callPackage @@ -25605,8 +23714,6 @@ self: { ]; description = "Infinite state model checking of iterative C programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ag-pictgen" = callPackage @@ -25620,8 +23727,6 @@ self: { executableHaskellDepends = [ base containers uuagc uulib ]; description = "Attribute Grammar picture generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "agda-language-server" = callPackage @@ -25648,8 +23753,6 @@ self: { ]; description = "LSP server for Agda"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "agda-server" = callPackage @@ -25670,8 +23773,6 @@ self: { ]; description = "Http server for Agda (prototype)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "agda-snippets" = callPackage @@ -25692,8 +23793,6 @@ self: { executableHaskellDepends = [ Agda base network-uri transformers ]; description = "Render just the Agda snippets of a literate Agda file to HTML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "agda-snippets-hakyll" = callPackage @@ -25710,8 +23809,6 @@ self: { ]; description = "Literate Agda support using agda-snippets, for Hakyll pages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "agda-unused" = callPackage @@ -25734,8 +23831,6 @@ self: { testHaskellDepends = [ base containers filepath hspec text ]; description = "Check for unused code in an Agda project"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "agda2lagda" = callPackage @@ -25772,8 +23867,6 @@ self: { ]; description = "AgentX protocol for write SNMP subagents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "agum" = callPackage @@ -25806,8 +23899,6 @@ self: { ]; description = "And-inverter graphs in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aip" = callPackage @@ -25836,8 +23927,6 @@ self: { ]; description = "Aeronautical Information Package (AIP)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "air" = callPackage @@ -25892,8 +23981,6 @@ self: { libraryHaskellDepends = [ air base template-haskell ]; description = "air"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "airbrake" = callPackage @@ -25913,8 +24000,6 @@ self: { ]; description = "An Airbrake notifier for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "airship" = callPackage @@ -25944,8 +24029,6 @@ self: { ]; description = "A Webmachine-inspired HTTP library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "airtable-api" = callPackage @@ -25963,8 +24046,6 @@ self: { testHaskellDepends = [ base ]; description = "Requesting and introspecting Tables within an Airtable project"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aivika" = callPackage @@ -26013,8 +24094,6 @@ self: { ]; description = "Parallel distributed discrete event simulation module for the Aivika library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aivika-experiment" = callPackage @@ -26080,8 +24159,6 @@ self: { ]; description = "Diagrams-based charting backend for the Aivika simulation library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aivika-gpss" = callPackage @@ -26173,8 +24250,6 @@ self: { ]; description = "Haskell compiler that produce binary through C language"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "al" = callPackage @@ -26240,8 +24315,6 @@ self: { ]; description = "Bindings to the alerta REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alerts" = callPackage @@ -26297,8 +24370,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "Collection of useful functions for writing console applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alex-tools" = callPackage @@ -26331,8 +24402,6 @@ self: { ]; description = "utility library for Alfred version 2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alfred-margaret" = callPackage @@ -26399,8 +24468,6 @@ self: { ]; description = "Algorithmic automation for various DAWs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algebra" = callPackage @@ -26436,8 +24503,6 @@ self: { ]; description = "Model and test API surfaces algebraically"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algebra-dag" = callPackage @@ -26453,8 +24518,6 @@ self: { ]; description = "Infrastructure for DAG-shaped relational algebra plans"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algebra-driven-design" = callPackage @@ -26473,8 +24536,6 @@ self: { ]; description = "Companion library for the book Algebra-Driven Design by Sandy Maguire"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algebra-sql" = callPackage @@ -26501,8 +24562,6 @@ self: { ]; description = "Relational Algebra and SQL Code Generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algebraic" = callPackage @@ -26514,8 +24573,6 @@ self: { libraryHaskellDepends = [ accelerate base ]; description = "General linear algebra structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algebraic-classes" = callPackage @@ -26589,8 +24646,6 @@ self: { ]; description = "Algebraically structured Prelude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algo-s" = callPackage @@ -26616,8 +24671,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "An implementation of Knuth's algorithm S"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algolia" = callPackage @@ -26643,8 +24696,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A client implementing the Algolia search API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "algorithmic-composition-additional" = callPackage @@ -26763,8 +24814,6 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "A simple unix filter to align text on specified substrings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aligned-foreignptr" = callPackage @@ -26840,8 +24889,6 @@ self: { ]; description = "Ally Invest integration library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "almost-fix" = callPackage @@ -26875,8 +24922,6 @@ self: { ]; description = "a practical affine language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alpaca-netcode" = callPackage @@ -26914,8 +24959,6 @@ self: { ]; description = "A compiler for the Alpha language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alphachar" = callPackage @@ -26936,8 +24979,6 @@ self: { ]; description = "A character between a-z"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alpino-tools" = callPackage @@ -26977,8 +25018,6 @@ self: { librarySystemDepends = [ alsaLib ]; description = "Binding to the ALSA Library API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) alsaLib;}; "alsa-core" = callPackage @@ -27011,8 +25050,6 @@ self: { ]; description = "Some simple interactive programs for sending MIDI control messages via ALSA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alsa-midi" = callPackage @@ -27033,8 +25070,6 @@ self: { executableSystemDepends = [ alsaLib ]; description = "Bindings for the ALSA sequencer API (MIDI stuff)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) alsaLib;}; "alsa-mixer" = callPackage @@ -27086,8 +25121,6 @@ self: { executableHaskellDepends = [ alsa base ]; description = "Tests for the ALSA audio signal library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alsa-seq" = callPackage @@ -27124,8 +25157,6 @@ self: { executableHaskellDepends = [ alsa base ]; description = "Tests for the ALSA sequencer library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "altcomposition" = callPackage @@ -27137,8 +25168,6 @@ self: { libraryHaskellDepends = [ base composition ]; description = "Alternative combinators for unorthodox function composition"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alternative-extra" = callPackage @@ -27150,8 +25179,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Extra utilities for alternatives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alternative-io" = callPackage @@ -27169,8 +25196,6 @@ self: { ]; description = "IO as Alternative instance (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "alternative-vector" = callPackage @@ -27233,8 +25258,6 @@ self: { executableHaskellDepends = [ base warp ]; description = "Implement a menu experience fit for web users"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "altsvc" = callPackage @@ -27263,8 +25286,6 @@ self: { librarySystemDepends = [ alure ]; description = "A Haskell binding for ALURE"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) alure;}; "always" = callPackage @@ -27294,8 +25315,6 @@ self: { ]; description = "A queue daemon for Amazon's SES with a PostgreSQL table as a queue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amazon-emailer-client-snap" = callPackage @@ -27310,8 +25329,6 @@ self: { ]; description = "Client library for amazon-emailer daemon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amazon-products" = callPackage @@ -27337,8 +25354,6 @@ self: { ]; description = "Connector for Amazon Products API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amazonka" = callPackage @@ -28194,8 +26209,6 @@ self: { ]; description = "Amazon Elastic Compute Cloud SDK"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amazonka-ecr" = callPackage @@ -29307,8 +27320,6 @@ self: { ]; description = "Provides conduits to upload data to S3 using the Multipart API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amazonka-sagemaker" = callPackage @@ -29797,8 +27808,6 @@ self: { benchmarkHaskellDepends = [ base statistics ]; description = "Statistical data visualization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ampersand" = callPackage @@ -29829,8 +27838,6 @@ self: { ]; description = "Toolsuite for automated design of business processes"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amqp" = callPackage @@ -29878,8 +27885,6 @@ self: { ]; description = "Conduit bindings for AMQP (see amqp package)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amqp-streamly" = callPackage @@ -29896,8 +27901,6 @@ self: { ]; description = "A simple streamly wrapper for amqp"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "amqp-utils" = callPackage @@ -30003,8 +28006,6 @@ self: { ]; description = "making data science easy and safe with data frames"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "analyze-client" = callPackage @@ -30021,8 +28022,6 @@ self: { ]; description = "Client for analyze service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "anansi" = callPackage @@ -30075,8 +28074,6 @@ self: { ]; description = "Looms which use Pandoc to parse and produce a variety of formats"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "anatomy" = callPackage @@ -30103,8 +28100,6 @@ self: { ]; description = "Anatomy: Atomo documentation system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "android" = callPackage @@ -30116,8 +28111,6 @@ self: { libraryHaskellDepends = [ base process ]; description = "Android methods exposed to Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "android-activity" = callPackage @@ -30129,8 +28122,6 @@ self: { libraryHaskellDepends = [ base data-default ]; description = "Turn regular Haskell programs into Android Activities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "android-lint-summary" = callPackage @@ -30157,8 +28148,6 @@ self: { ]; description = "A pretty printer for Android Lint errors"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "angel" = callPackage @@ -30186,8 +28175,6 @@ self: { ]; description = "Process management and supervision daemon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "angle" = callPackage @@ -30216,8 +28203,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A small, general-purpose programming language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "animalcase" = callPackage @@ -30250,8 +28235,6 @@ self: { testHaskellDepends = [ ansi-terminal-game base hspec parsec ]; description = "text-file based ASCII animator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "animate" = callPackage @@ -30268,8 +28251,6 @@ self: { testHaskellDepends = [ aeson base containers hspec vector ]; description = "Animation for sprites"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "animate-example" = callPackage @@ -30288,8 +28269,6 @@ self: { ]; description = "Animation for sprites"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "animate-frames" = callPackage @@ -30311,8 +28290,6 @@ self: { testHaskellDepends = [ base tasty tasty-hspec ]; description = "Convert sprite frames to animate files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "animate-preview" = callPackage @@ -30338,8 +28315,6 @@ self: { executableHaskellDepends = [ base ]; description = "Preview tool for sprite animation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "animate-sdl2" = callPackage @@ -30351,8 +28326,6 @@ self: { libraryHaskellDepends = [ aeson animate base sdl2 sdl2-image ]; description = "sdl2 + animate auxiliary library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "anki-tools" = callPackage @@ -30396,8 +28369,6 @@ self: { ]; description = "Medium-level language that desugars to Morte"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "annihilator" = callPackage @@ -30420,8 +28391,6 @@ self: { libraryHaskellDepends = [ base recursion-schemes ]; description = "A fixpoint of a functor that can be annotated"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "annotated-wl-pprint" = callPackage @@ -30446,8 +28415,6 @@ self: { libraryHaskellDepends = [ base lens template-haskell ]; description = "Anonymous sum types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "anonymous-sums-tests" = callPackage @@ -30459,8 +28426,6 @@ self: { libraryHaskellDepends = [ anonymous-sums base QuickCheck ]; description = "QuickCheck functions to accompany the anonymous-sums package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ansi-escape-codes" = callPackage @@ -30530,8 +28495,6 @@ self: { ]; description = "sdl-like functions for terminal applications, based on ansi-terminal"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ansi-wl-pprint" = callPackage @@ -30561,8 +28524,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Terminal-based graphing via ANSI and Unicode"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antagonist" = callPackage @@ -30588,8 +28549,6 @@ self: { ]; description = "A web interface to Antisplice dungeons"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antfarm" = callPackage @@ -30612,8 +28571,6 @@ self: { ]; description = "Referring expressions for definitions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "anticiv" = callPackage @@ -30639,8 +28596,6 @@ self: { ]; description = "This is an IRC bot for Mafia and Resistance"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antigate" = callPackage @@ -30658,8 +28613,6 @@ self: { ]; description = "Interface for antigate.com captcha recognition API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antimirov" = callPackage @@ -30674,8 +28627,6 @@ self: { executableHaskellDepends = [ base containers QuickCheck ]; description = "Define the language containment (=subtyping) relation on regulare expressions"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-athena" = callPackage @@ -30697,8 +28648,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-contract" = callPackage @@ -30712,8 +28661,6 @@ self: { ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-core" = callPackage @@ -30740,8 +28687,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-dynamodb" = callPackage @@ -30764,8 +28709,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-es" = callPackage @@ -30785,8 +28728,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-messages" = callPackage @@ -30811,8 +28752,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-optparse-applicative" = callPackage @@ -30834,8 +28773,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-s3" = callPackage @@ -30864,8 +28801,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-shell" = callPackage @@ -30895,8 +28830,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-sns" = callPackage @@ -30920,8 +28853,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-sqs" = callPackage @@ -30948,8 +28879,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antiope-swf" = callPackage @@ -30988,8 +28917,6 @@ self: { libraryHaskellDepends = [ base syb template-haskell ]; description = "Combinator library for quasi- and anti-quoting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antisplice" = callPackage @@ -31006,8 +28933,6 @@ self: { ]; description = "An engine for text-based dungeons"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antlr-haskell" = callPackage @@ -31032,8 +28957,6 @@ self: { ]; description = "A Haskell implementation of the ANTLR top-down parser generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "antlrc" = callPackage @@ -31054,8 +28977,6 @@ self: { ]; description = "Haskell binding to the ANTLR parser generator C runtime library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {antlr3c = null;}; "anydbm" = callPackage @@ -31071,8 +28992,6 @@ self: { libraryHaskellDepends = [ base containers MissingH mtl ]; description = "Interface for DBM-like database systems"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aop-prelude" = callPackage @@ -31085,8 +29004,6 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "prelude for Algebra of Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aos-signature" = callPackage @@ -31107,8 +29024,6 @@ self: { ]; description = "An implementation of the AOS signatures"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aosd" = callPackage @@ -31129,8 +29044,6 @@ self: { ]; description = "Bindings to libaosd, a library for Cairo-based on-screen displays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libaosd;}; "ap-normalize" = callPackage @@ -31203,8 +29116,6 @@ self: { ]; description = "Get all your structure and rip it apart"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apecs" = callPackage @@ -31280,8 +29191,6 @@ self: { ]; description = "STM stores for apecs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apelsin" = callPackage @@ -31303,8 +29212,6 @@ self: { ]; description = "Server and community browser for the game Tremulous"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "api-builder" = callPackage @@ -31326,8 +29233,6 @@ self: { ]; description = "Library for easily building REST API wrappers in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "api-field-json-th" = callPackage @@ -31431,8 +29336,6 @@ self: { testHaskellDepends = [ base bytestring ]; description = "RPC API client for Factom"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "api-rpc-pegnet" = callPackage @@ -31456,8 +29359,6 @@ self: { ]; description = "simple json-rpc client for PegNet"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "api-tools" = callPackage @@ -31492,8 +29393,6 @@ self: { benchmarkHaskellDepends = [ base criterion text time ]; description = "DSL for generating API boilerplate and docs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "api-yoti" = callPackage @@ -31514,8 +29413,6 @@ self: { testHaskellDepends = [ base bytestring text ]; description = "Api bindings for Yoti services"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary" = callPackage @@ -31548,8 +29445,6 @@ self: { ]; description = "Simple and type safe web framework that generate web API documentation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-authenticate" = callPackage @@ -31569,8 +29464,6 @@ self: { ]; description = "authenticate support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-clientsession" = callPackage @@ -31588,8 +29481,6 @@ self: { ]; description = "clientsession support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-cookie" = callPackage @@ -31605,8 +29496,6 @@ self: { ]; description = "Cookie support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-eventsource" = callPackage @@ -31618,8 +29507,6 @@ self: { libraryHaskellDepends = [ apiary base blaze-builder wai-extra ]; description = "eventsource support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-helics" = callPackage @@ -31639,8 +29526,6 @@ self: { ]; description = "helics support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-http-client" = callPackage @@ -31657,8 +29542,6 @@ self: { ]; description = "A http client for Apiary"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-logger" = callPackage @@ -31676,8 +29559,6 @@ self: { ]; description = "fast-logger support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-memcached" = callPackage @@ -31696,8 +29577,6 @@ self: { ]; description = "memcached client for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-mongoDB" = callPackage @@ -31715,8 +29594,6 @@ self: { ]; description = "mongoDB support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-persistent" = callPackage @@ -31734,8 +29611,6 @@ self: { ]; description = "persistent support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-purescript" = callPackage @@ -31755,8 +29630,6 @@ self: { ]; description = "purescript compiler for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-redis" = callPackage @@ -31768,8 +29641,6 @@ self: { libraryHaskellDepends = [ apiary base hedis transformers ]; description = "redis support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-session" = callPackage @@ -31781,8 +29652,6 @@ self: { libraryHaskellDepends = [ apiary base wai ]; description = "session support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apiary-websockets" = callPackage @@ -31794,8 +29663,6 @@ self: { libraryHaskellDepends = [ apiary base wai-websockets websockets ]; description = "websockets support for apiary web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apioiaf-client" = callPackage @@ -31828,8 +29695,6 @@ self: { ]; description = "A Template Haskell library for generating type safe API calls"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apns-http2" = callPackage @@ -31858,8 +29723,6 @@ self: { ]; description = "Apple Push Notification service HTTP/2 integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apotiki" = callPackage @@ -31889,8 +29752,6 @@ self: { ]; description = "a faster debian repository"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "app-lens" = callPackage @@ -31905,8 +29766,6 @@ self: { ]; description = "applicative (functional) bidirectional programming beyond composition chains"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "app-settings" = callPackage @@ -31961,8 +29820,6 @@ self: { ]; description = "app container types and tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "appendmap" = callPackage @@ -32004,8 +29861,6 @@ self: { ]; description = "Applicative functor and monad which collects all your fails"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "applicative-numbers" = callPackage @@ -32033,8 +29888,6 @@ self: { ]; description = "An applicative parser combinator library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "applicative-quoters" = callPackage @@ -32048,8 +29901,6 @@ self: { libraryHaskellDepends = [ base haskell-src-meta template-haskell ]; description = "Quasiquoters for idiom brackets and an applicative do-notation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "applicative-splice" = callPackage @@ -32065,8 +29916,6 @@ self: { ]; description = "Write applicative programs in direct style (generalizes idiom brackets)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apply-refact" = callPackage @@ -32114,8 +29963,6 @@ self: { ]; description = "Apply a function to an argument specified by a type level Nat"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "apply-unordered-mono" = callPackage @@ -32166,8 +30013,6 @@ self: { ]; description = "ApproveAPI Haskell Client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "approx" = callPackage @@ -32194,8 +30039,6 @@ self: { ]; description = "Easy-to-use emulation of approximate, ranges and tolerances in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "approx-rand-test" = callPackage @@ -32292,8 +30135,6 @@ self: { ]; description = "Pure Haskell arbitrary length FFT library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arbb-vm" = callPackage @@ -32310,8 +30151,6 @@ self: { librarySystemDepends = [ arbb_dev ]; description = "FFI binding to the Intel Array Building Blocks (ArBB) virtual machine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {arbb_dev = null;}; "arbor-datadog" = callPackage @@ -32336,8 +30175,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Datadog client for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arbor-lru-cache" = callPackage @@ -32376,8 +30213,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Counter library for submitting metrics to a backend such as datadog"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arbor-monad-logger" = callPackage @@ -32401,8 +30236,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Simple logging library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arbor-monad-metric" = callPackage @@ -32426,8 +30259,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Core metric library for publishing metrics"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arbor-monad-metric-datadog" = callPackage @@ -32453,8 +30284,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Metric library backend for datadog"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arbor-postgres" = callPackage @@ -32473,8 +30302,6 @@ self: { ]; description = "Convenience types and functions for postgresql-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arbtt" = callPackage @@ -32568,8 +30395,6 @@ self: { ]; description = "Distribute hackage packages to archlinux"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arch-web" = callPackage @@ -32593,8 +30418,6 @@ self: { ]; description = "Arch Linux official and AUR web interface binding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "archive" = callPackage @@ -32634,8 +30457,6 @@ self: { libraryToolDepends = [ cpphs ]; description = "Common interface using libarchive"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "archive-sig" = callPackage @@ -32700,8 +30521,6 @@ self: { ]; description = "Archive supplied URLs in WebCite & Internet Archive"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "archlinux" = callPackage @@ -32717,8 +30536,6 @@ self: { ]; description = "Support for working with Arch Linux packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "archlinux-web" = callPackage @@ -32744,8 +30561,6 @@ self: { ]; description = "Website maintenance for Arch Linux packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "archnews" = callPackage @@ -32761,8 +30576,6 @@ self: { ]; description = "Convert Arch Linux package updates in RSS to pretty markdown"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arduino-copilot" = callPackage @@ -32781,8 +30594,6 @@ self: { testHaskellDepends = [ base directory process temporary ]; description = "Arduino programming in haskell using the Copilot stream DSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arena" = callPackage @@ -32808,8 +30619,6 @@ self: { ]; description = "A journaled data store"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arff" = callPackage @@ -32826,8 +30635,6 @@ self: { ]; description = "Generate Attribute-Relation File Format (ARFF) files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arghwxhaskell" = callPackage @@ -32841,8 +30648,6 @@ self: { executableHaskellDepends = [ base directory wx ]; description = "An interpreter for the Argh! programming language in wxHaskell"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "argon" = callPackage @@ -32869,8 +30674,6 @@ self: { ]; description = "Measure your code's complexity"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "argon2" = callPackage @@ -32889,8 +30692,6 @@ self: { ]; description = "Memory-hard password hash and proof-of-work function"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "argparser" = callPackage @@ -32903,8 +30704,6 @@ self: { testHaskellDepends = [ base containers HTF HUnit ]; description = "Command line parsing framework for console applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arguedit" = callPackage @@ -32922,8 +30721,6 @@ self: { ]; description = "A computer assisted argumentation transcription and editing software"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ariadne" = callPackage @@ -32951,8 +30748,6 @@ self: { ]; description = "Go-to-definition for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arion" = callPackage @@ -32976,8 +30771,6 @@ self: { ]; description = "Watcher and runner for Hspec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arion-compose" = callPackage @@ -33101,8 +30894,6 @@ self: { ]; description = "Arithmetic circuits for zkSNARKs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arithmoi" = callPackage @@ -33160,8 +30951,6 @@ self: { executableHaskellDepends = [ base GLUT mtl OpenGL stm ]; description = "Space-based real time strategy game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "armor" = callPackage @@ -33180,8 +30969,6 @@ self: { ]; description = "Prevent serialization backwards compatibility problems using golden tests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arpa" = callPackage @@ -33196,8 +30983,6 @@ self: { executableHaskellDepends = [ base ]; description = "Library for reading ARPA n-gram models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arpack" = callPackage @@ -33221,8 +31006,6 @@ self: { ]; description = "Solve large scale eigenvalue problems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) arpack;}; "array_0_5_4_0" = callPackage @@ -33249,8 +31032,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Builders for arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "array-chunks" = callPackage @@ -33268,8 +31049,6 @@ self: { ]; description = "Lists of chunks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "array-forth" = callPackage @@ -33295,8 +31074,6 @@ self: { ]; description = "A simple interpreter for arrayForth, the language used on GreenArrays chips"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "array-list" = callPackage @@ -33311,8 +31088,6 @@ self: { ]; description = "IsList instances of Array for OverloadedLists extension"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "array-memoize" = callPackage @@ -33341,8 +31116,6 @@ self: { benchmarkHaskellDepends = [ base criterion ghc-prim ]; description = "Extra foreign primops for primitive arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "array-utils" = callPackage @@ -33378,8 +31151,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell bindings to the ArrayFire general-purpose GPU library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {af = null;}; "arraylist" = callPackage @@ -33397,8 +31168,6 @@ self: { ]; description = "Memory-efficient ArrayList implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arrow-extras" = callPackage @@ -33424,8 +31193,6 @@ self: { ]; description = "Improved arrows"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arrow-list" = callPackage @@ -33437,8 +31204,6 @@ self: { libraryHaskellDepends = [ base containers fail mtl ]; description = "List arrows for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arrowapply-utils" = callPackage @@ -33450,8 +31215,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Utilities for working with ArrowApply instances more naturally"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arrowp" = callPackage @@ -33465,8 +31228,6 @@ self: { executableHaskellDepends = [ array base containers haskell-src ]; description = "preprocessor translating arrow notation into Haskell 98"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arrowp-qq" = callPackage @@ -33487,8 +31248,6 @@ self: { executableHaskellDepends = [ base haskell-src-exts NoHoed ]; description = "A preprocessor and quasiquoter for translating arrow notation"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arrows" = callPackage @@ -33513,8 +31272,6 @@ self: { ]; description = "A simple, arrow-based reactive programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "artifact" = callPackage @@ -33528,8 +31285,6 @@ self: { libraryHaskellDepends = [ aeson base bytestring containers text ]; description = "Basic types and instances for Valve's Artifact Card-set API"; license = lib.licenses.agpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "arx" = callPackage @@ -33580,8 +31335,6 @@ self: { testHaskellDepends = [ base hedgehog jwt mtl text time ]; description = "Atlassian Service Authentication Protocol"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ascetic" = callPackage @@ -33672,8 +31425,6 @@ self: { executableHaskellDepends = [ base text ]; description = "Flattens European non-ASCII characaters into ASCII"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ascii-group" = callPackage @@ -33753,8 +31504,6 @@ self: { ]; description = "Compact representation of ASCII strings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ascii-superset" = callPackage @@ -33784,8 +31533,6 @@ self: { ]; description = "ASCII table"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ascii-th" = callPackage @@ -33822,8 +31569,6 @@ self: { ]; description = "Process Ascii Vectors for Advantest 93k"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ascii85-conduit" = callPackage @@ -33836,8 +31581,6 @@ self: { testHaskellDepends = [ base bytestring conduit hspec ]; description = "Conduit for encoding ByteString into Ascii85"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asciichart" = callPackage @@ -33890,8 +31633,6 @@ self: { executableHaskellDepends = [ asil base bytestring utf8-string ]; description = "Action Script Instrumentation Compiler"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asif" = callPackage @@ -33952,8 +31693,6 @@ self: { ]; description = "Action Script Instrumentation Library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asn" = callPackage @@ -33968,8 +31707,6 @@ self: { ]; description = "asn type and encoding/decoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asn1-codec" = callPackage @@ -33994,8 +31731,6 @@ self: { ]; description = "Encode and decode ASN.1"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asn1-data" = callPackage @@ -34012,8 +31747,6 @@ self: { libraryHaskellDepends = [ base bytestring cereal mtl text ]; description = "ASN1 data reader and writer in RAW, BER and DER forms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asn1-encoding" = callPackage @@ -34116,8 +31849,6 @@ self: { ]; description = "Helpers for Control.Exception.assert"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "assert-failure" = callPackage @@ -34142,8 +31873,6 @@ self: { testHaskellDepends = [ base data-default pretty-diff tasty text ]; description = "A set of assertion for writing more readable tests cases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "assert4hs-core" = callPackage @@ -34161,8 +31890,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A set of assertion for writing more readable tests cases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "assert4hs-hspec" = callPackage @@ -34175,8 +31902,6 @@ self: { testHaskellDepends = [ assert4hs-core base hspec HUnit ]; description = "integration point of assert4hs and hspec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "assert4hs-tasty" = callPackage @@ -34189,8 +31914,6 @@ self: { testHaskellDepends = [ assert4hs-core base tasty ]; description = "Provider for tasty runner to run assert4hs tests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "assertions" = callPackage @@ -34206,8 +31929,6 @@ self: { testHaskellDepends = [ base interpolate process ]; description = "A simple testing framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asset-bundle" = callPackage @@ -34236,8 +31957,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Asset map support for the JavaScript broccoli-asset-rev library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "assimp" = callPackage @@ -34251,8 +31970,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "The Assimp asset import library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) assimp;}; "assoc" = callPackage @@ -34312,8 +32029,6 @@ self: { ]; description = "An SMTP client library"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "assumpta-core" = callPackage @@ -34346,8 +32061,6 @@ self: { testHaskellDepends = [ base ]; description = "A library for constructing AST by using do-notation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ast-monad-json" = callPackage @@ -34362,8 +32075,6 @@ self: { testHaskellDepends = [ ast-monad base hspec text ]; description = "A library for writing JSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ast-path" = callPackage @@ -34419,8 +32130,6 @@ self: { ]; description = "an incomplete 2d space game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "astro" = callPackage @@ -34458,8 +32167,6 @@ self: { ]; description = "A GTK-based abstract syntax tree viewer for custom languages and parsers"; license = lib.licenses.bsdOriginal; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "astview-utils" = callPackage @@ -34521,8 +32228,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Async combinators"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "async-dejafu" = callPackage @@ -34539,8 +32244,6 @@ self: { ]; description = "Run MonadConc operations asynchronously and wait for their results"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "async-extra" = callPackage @@ -34593,8 +32296,6 @@ self: { executableHaskellDepends = [ async base stm unordered-containers ]; description = "A thread manager for async"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "async-pool" = callPackage @@ -34677,8 +32378,6 @@ self: { ]; description = "Provides API for timer based execution of IO actions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "asynchronous-exceptions" = callPackage @@ -34690,8 +32389,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Distinguish between synchronous and asynchronous exceptions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aterm" = callPackage @@ -34719,8 +32416,6 @@ self: { executableHaskellDepends = [ aterm base transformers wl-pprint ]; description = "Utility functions for working with aterms as generated by Minitermite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atl" = callPackage @@ -34775,8 +32470,6 @@ self: { ]; description = "Atlassian Connect snaplet for the Snap Framework and helper code"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atlassian-connect-descriptor" = callPackage @@ -34798,8 +32491,6 @@ self: { ]; description = "Code that helps you create a valid Atlassian Connect Descriptor"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atmos" = callPackage @@ -34838,8 +32529,6 @@ self: { libraryHaskellDepends = [ atmos base dimensional-tf ]; description = "dimensional-tf wrapper on atmos package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atndapi" = callPackage @@ -34864,8 +32553,6 @@ self: { ]; description = "An interface of ATND API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atom" = callPackage @@ -34930,8 +32617,6 @@ self: { libraryHaskellDepends = [ atom base mtl ]; description = "Convenience functions for using Atom with the MSP430 microcontroller family"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atomic-file-ops" = callPackage @@ -34958,8 +32643,6 @@ self: { libraryHaskellDepends = [ base stm ]; description = "A typeclass for mutable references that have an atomic modify operation"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atomic-primops" = callPackage @@ -34989,8 +32672,6 @@ self: { ]; description = "An atomic counter implemented using the FFI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atomic-primops-vector" = callPackage @@ -35003,8 +32684,6 @@ self: { testHaskellDepends = [ base vector ]; description = "Atomic operations on Data.Vector types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atomic-write" = callPackage @@ -35048,8 +32727,6 @@ self: { ]; description = "A highly dynamic, extremely simple, very fun programming language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atp" = callPackage @@ -35068,8 +32745,6 @@ self: { ]; description = "Interface to automated theorem provers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atp-haskell" = callPackage @@ -35087,8 +32762,6 @@ self: { testHaskellDepends = [ base containers HUnit time ]; description = "Translation from Ocaml to Haskell of John Harrison's ATP code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atrans" = callPackage @@ -35154,8 +32827,6 @@ self: { doHaddock = false; description = "A build tool for ATS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ats-setup" = callPackage @@ -35174,8 +32845,6 @@ self: { ]; description = "ATS scripts for Cabal builds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ats-storable" = callPackage @@ -35193,8 +32862,6 @@ self: { testSystemDepends = [ storable ]; description = "Marshal ATS types into Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {storable = null;}; "attempt" = callPackage @@ -35206,8 +32873,6 @@ self: { libraryHaskellDepends = [ base failure ]; description = "Concrete data type for handling extensible exceptions as failures. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attic-schedule" = callPackage @@ -35227,8 +32892,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "A script I use to run \"attic\" for my backups"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atto-lisp" = callPackage @@ -35252,8 +32915,6 @@ self: { ]; description = "Efficient parsing and serialisation of S-Expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attomail" = callPackage @@ -35276,8 +32937,6 @@ self: { testHaskellDepends = [ base doctest Glob QuickCheck ]; description = "Minimal mail delivery agent (MDA) for local mail with maildir support"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec" = callPackage @@ -35423,8 +33082,6 @@ self: { ]; description = "Pass input from an enumerator to an Attoparsec parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec-expr" = callPackage @@ -35454,8 +33111,6 @@ self: { ]; description = "Parse IP data types with attoparsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec-iso8601" = callPackage @@ -35488,8 +33143,6 @@ self: { ]; description = "An adapter to convert attoparsec Parsers into blazing-fast Iteratees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec-parsec" = callPackage @@ -35534,8 +33187,6 @@ self: { libraryHaskellDepends = [ array attoparsec base containers text ]; description = "(deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec-text-enumerator" = callPackage @@ -35547,8 +33198,6 @@ self: { libraryHaskellDepends = [ attoparsec-text base enumerator text ]; description = "(deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec-time" = callPackage @@ -35575,8 +33224,6 @@ self: { libraryHaskellDepends = [ attoparsec base transformers ]; description = "Interleaved effects for attoparsec parsers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec-uri" = callPackage @@ -35598,8 +33245,6 @@ self: { ]; description = "URI parser / printer using attoparsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "attoparsec-varword" = callPackage @@ -35628,8 +33273,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring ]; description = "Split a lazy bytestring at boundaries defined by an attoparsec parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "atuin" = callPackage @@ -35646,8 +33289,6 @@ self: { ]; description = "Embedded Turtle language compiler in Haskell, with Epic output"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "audacity" = callPackage @@ -35689,8 +33330,6 @@ self: { ]; description = "A battery-included audiovisual framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "augeas" = callPackage @@ -35710,8 +33349,6 @@ self: { executablePkgconfigDepends = [ augeas ]; description = "A Haskell FFI wrapper for the Augeas API"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) augeas;}; "augur" = callPackage @@ -35730,8 +33367,6 @@ self: { ]; description = "Renaming media collections in a breeze"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aur" = callPackage @@ -35750,8 +33385,6 @@ self: { ]; description = "Access metadata from the Arch Linux User Repository"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aur-api" = callPackage @@ -35768,8 +33401,6 @@ self: { ]; description = "ArchLinux AUR json v5 API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aura" = callPackage @@ -35804,8 +33435,6 @@ self: { ]; description = "A secure package manager for Arch Linux and the AUR"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "authenticate" = callPackage @@ -35847,8 +33476,6 @@ self: { libraryHaskellDepends = [ base LDAP text transformers ]; description = "LDAP authentication for Haskell web applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "authenticate-oauth" = callPackage @@ -35880,8 +33507,6 @@ self: { libraryHaskellDepends = [ attoparsec base network text ]; description = "Password querying for .authinfo"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "authoring" = callPackage @@ -35900,8 +33525,6 @@ self: { ]; description = "A library for writing papers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "auto" = callPackage @@ -35978,8 +33601,6 @@ self: { ]; description = "Generates and displays patterns from next nearest neighbors cellular automata"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "automata" = callPackage @@ -36004,8 +33625,6 @@ self: { ]; description = "automata"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "automitive-cse" = callPackage @@ -36064,8 +33683,6 @@ self: { ]; description = "Library for Nix expression dependency generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "autonix-deps-kf5" = callPackage @@ -36089,8 +33706,6 @@ self: { ]; description = "Generate dependencies for KDE 5 Nix expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "autopack" = callPackage @@ -36102,8 +33717,6 @@ self: { libraryHaskellDepends = [ base Cabal dir-traverse filepath ]; description = "Custom Setup to automate package modules discovery"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "autoproc" = callPackage @@ -36145,8 +33758,6 @@ self: { executableHaskellDepends = [ base JuicyPixels random ]; description = "A simple random avatar icon generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "average" = callPackage @@ -36193,8 +33804,6 @@ self: { ]; description = "Server-side implementation of the Avers storage model"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "avers-api" = callPackage @@ -36211,8 +33820,6 @@ self: { ]; description = "Types describing the core and extended Avers APIs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "avers-api-docs" = callPackage @@ -36231,8 +33838,6 @@ self: { ]; description = "Swagger documentation for the Avers API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "avers-server" = callPackage @@ -36253,8 +33858,6 @@ self: { ]; description = "Server implementation of the Avers API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aviation-cessna172-diagrams" = callPackage @@ -36328,8 +33931,6 @@ self: { ]; description = "A compile-time balanced AVL tree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "avr-shake" = callPackage @@ -36341,8 +33942,6 @@ self: { libraryHaskellDepends = [ base dependent-sum mtl process shake ]; description = "AVR Crosspack actions for shake build systems"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "avro" = callPackage @@ -36416,8 +34015,6 @@ self: { ]; description = "Tool for decoding avro"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "avwx" = callPackage @@ -36448,8 +34045,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A prelude which I can be happy with. Based on base-prelude."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "awesomium" = callPackage @@ -36465,8 +34060,6 @@ self: { ]; description = "High-level Awesomium bindings"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "awesomium-glut" = callPackage @@ -36478,8 +34071,6 @@ self: { libraryHaskellDepends = [ awesomium awesomium-raw base GLUT ]; description = "Utilities for using Awesomium with GLUT"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "awesomium-raw" = callPackage @@ -36493,8 +34084,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Low-level Awesomium bindings"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {awesomium = null;}; "aws" = callPackage @@ -36590,8 +34179,6 @@ self: { ]; description = "For signing AWS CloudFront HTTP URL requests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-configuration-tools" = callPackage @@ -36611,8 +34198,6 @@ self: { ]; description = "Configuration types, parsers & renderers for AWS services"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-dynamodb-conduit" = callPackage @@ -36630,8 +34215,6 @@ self: { ]; description = "Conduit-based interface for AWS DynamoDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-dynamodb-streams" = callPackage @@ -36654,8 +34237,6 @@ self: { ]; description = "Haskell bindings for Amazon DynamoDB Streams"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-easy" = callPackage @@ -36679,8 +34260,6 @@ self: { ]; description = "Helper function and types for working with amazonka"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-ec2" = callPackage @@ -36710,8 +34289,6 @@ self: { ]; description = "AWS EC2/VPC, ELB and CloudWatch client library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-ec2-knownhosts" = callPackage @@ -36734,8 +34311,6 @@ self: { ]; description = "Capture and manage AWS EC2 known_host pubkeys"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-elastic-transcoder" = callPackage @@ -36758,8 +34333,6 @@ self: { ]; description = "Haskell suite for the Elastic Transcoder service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-general" = callPackage @@ -36785,8 +34358,6 @@ self: { ]; description = "Bindings for Amazon Web Services (AWS) General Reference"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-kinesis" = callPackage @@ -36812,8 +34383,6 @@ self: { ]; description = "Bindings for Amazon Kinesis"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-kinesis-client" = callPackage @@ -36848,8 +34417,6 @@ self: { ]; description = "A producer & consumer client library for AWS Kinesis"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-kinesis-reshard" = callPackage @@ -36878,8 +34445,6 @@ self: { ]; description = "Reshard AWS Kinesis streams in response to Cloud Watch metrics"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-lambda" = callPackage @@ -36899,8 +34464,6 @@ self: { ]; description = "Haskell bindings for AWS Lambda"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-lambda-haskell-runtime" = callPackage @@ -36944,8 +34507,6 @@ self: { ]; description = "Run wai applications on AWS Lambda"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-lambda-runtime" = callPackage @@ -36970,8 +34531,6 @@ self: { executableHaskellDepends = [ aeson base lens lens-aeson text ]; description = "Haskell on AWS Lambda Runtime API"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-larpi" = callPackage @@ -36987,8 +34546,6 @@ self: { ]; description = "Package Haskell functions for easy use on AWS Lambda"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-mfa-credentials" = callPackage @@ -37010,8 +34567,6 @@ self: { ]; description = "Keep your AWS credentials file up to date with MFA-carrying credentials"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-performance-tests" = callPackage @@ -37037,8 +34592,6 @@ self: { ]; description = "Performance Tests for the Haskell bindings for Amazon Web Services (AWS)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-route53" = callPackage @@ -37056,8 +34609,6 @@ self: { ]; description = "Amazon Route53 DNS service plugin for the aws package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-sdk" = callPackage @@ -37086,8 +34637,6 @@ self: { ]; description = "AWS SDK for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-sdk-text-converter" = callPackage @@ -37109,8 +34658,6 @@ self: { ]; description = "The text converter for aws-sdk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-sdk-xml-unordered" = callPackage @@ -37131,8 +34678,6 @@ self: { ]; description = "The xml parser for aws-sdk package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-ses-easy" = callPackage @@ -37152,8 +34697,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Wrapper over Amazonka's SES"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-sign4" = callPackage @@ -37177,8 +34720,6 @@ self: { ]; description = "Amazon Web Services (AWS) Signature v4 HTTP request signer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-simple" = callPackage @@ -37196,8 +34737,6 @@ self: { ]; description = "Dead simple bindings to commonly used AWS Services"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "aws-sns" = callPackage @@ -37221,8 +34760,6 @@ self: { ]; description = "Bindings for AWS SNS Version 2013-03-31"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "axel" = callPackage @@ -37274,8 +34811,6 @@ self: { testToolDepends = [ hpack tasty-discover ]; description = "The Axel programming language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "axiom" = callPackage @@ -37292,8 +34827,6 @@ self: { ]; description = "Web EDSL for running in browsers and server nodes using transient"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "axiomatic-classes" = callPackage @@ -37333,8 +34866,6 @@ self: { testHaskellDepends = [ base hspec shelly text urbit-hob ]; description = "Interact with Azimuth from Haskell"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "azubi" = callPackage @@ -37353,8 +34884,6 @@ self: { ]; description = "A simple DevOps tool which will never \"reach\" enterprice level"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "azure-acs" = callPackage @@ -37372,8 +34901,6 @@ self: { ]; description = "Windows Azure ACS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "azure-email" = callPackage @@ -37392,8 +34919,6 @@ self: { ]; description = "send email with microsoft azure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "azure-functions-worker" = callPackage @@ -37421,8 +34946,6 @@ self: { testHaskellDepends = [ base ]; description = "Azure Functions Worker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "azure-service-api" = callPackage @@ -37441,8 +34964,6 @@ self: { ]; description = "Haskell bindings for the Microsoft Azure Service Management API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "azure-servicebus" = callPackage @@ -37460,8 +34981,6 @@ self: { ]; description = "Haskell wrapper over Microsoft Azure ServiceBus REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "azurify" = callPackage @@ -37491,8 +35010,6 @@ self: { ]; description = "A simple library for accessing Azure blob storage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "b-tree" = callPackage @@ -37518,8 +35035,6 @@ self: { benchmarkHaskellDepends = [ base criterion pipes ]; description = "Immutable disk-based B* trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "b9" = callPackage @@ -37561,8 +35076,6 @@ self: { ]; description = "A tool and library for building virtual machine images"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "babl" = callPackage @@ -37592,8 +35105,6 @@ self: { ]; description = "An implementation of a simple 2-player board game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "backblaze-b2-hs" = callPackage @@ -37626,8 +35137,6 @@ self: { ]; description = "A client library to access Backblaze B2 cloud storage in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "backdropper" = callPackage @@ -37645,8 +35154,6 @@ self: { ]; description = "Rotates backdrops for X11 displays using Imagemagic"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "backprop" = callPackage @@ -37691,8 +35198,6 @@ self: { ]; description = "Backstop a target directory by source directories"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "backtracking" = callPackage @@ -37724,8 +35229,6 @@ self: { ]; description = "A monad transformer for backtracking exceptions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "backward-state" = callPackage @@ -37737,8 +35240,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A state monad that runs the state in reverse through the computation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bacteria" = callPackage @@ -37764,8 +35265,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple stable bag"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bake" = callPackage @@ -37799,8 +35298,6 @@ self: { ]; description = "Continuous integration system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ballast" = callPackage @@ -37824,8 +35321,6 @@ self: { ]; description = "Shipwire API client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamboo" = callPackage @@ -37846,8 +35341,6 @@ self: { ]; description = "A blog engine on Hack"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamboo-launcher" = callPackage @@ -37868,8 +35361,6 @@ self: { ]; description = "bamboo-launcher"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamboo-plugin-highlight" = callPackage @@ -37887,8 +35378,6 @@ self: { ]; description = "A highlight middleware"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamboo-plugin-photo" = callPackage @@ -37907,8 +35396,6 @@ self: { ]; description = "A photo album middleware"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamboo-theme-blueprint" = callPackage @@ -37927,8 +35414,6 @@ self: { ]; description = "bamboo blueprint theme"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamboo-theme-mini-html5" = callPackage @@ -37951,8 +35436,6 @@ self: { ]; description = "bamboo mini html5 theme"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamse" = callPackage @@ -37970,8 +35453,6 @@ self: { ]; description = "A Windows Installer (MSI) generator framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bamstats" = callPackage @@ -37985,8 +35466,6 @@ self: { executableHaskellDepends = [ base cmdargs samtools ]; description = "A program to extract various information from BAM alignmnet files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ban-instance" = callPackage @@ -38001,8 +35480,6 @@ self: { testHaskellDepends = [ base ]; description = "For when a type should never be an instance of a class"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bank-holiday-usa" = callPackage @@ -38015,8 +35492,6 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck time ]; description = "A library for determining US bank holidays"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bank-holidays-england" = callPackage @@ -38048,8 +35523,6 @@ self: { ]; description = "Generalized word blacklister"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "barbies" = callPackage @@ -38113,8 +35586,6 @@ self: { executableHaskellDepends = [ base cmdargs csv diagrams filepath ]; description = "Creating Bar Charts in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "barcodes-code128" = callPackage @@ -38126,8 +35597,6 @@ self: { libraryHaskellDepends = [ base bytestring HPDF ]; description = "Generate Code 128 barcodes as PDFs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "barecheck" = callPackage @@ -38139,8 +35608,6 @@ self: { libraryHaskellDepends = [ base containers QuickCheck text time ]; description = "QuickCheck implementations for common types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "barley" = callPackage @@ -38173,8 +35640,6 @@ self: { libraryHaskellDepends = [ base containers filepath glib gtk ]; description = "Declarative Gtk GUI library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "barrier" = callPackage @@ -38199,8 +35664,6 @@ self: { ]; description = "Shields.io style badge generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "barrier-monad" = callPackage @@ -38212,8 +35675,6 @@ self: { libraryHaskellDepends = [ base comonad mtl transformers ]; description = "Implementation of barrier monad, can use custom front/back type"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base_4_15_0_0" = callPackage @@ -38266,8 +35727,6 @@ self: { doHaddock = false; description = "Helps migrating projects to base-compat(-batteries)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base-encoding" = callPackage @@ -38283,8 +35742,6 @@ self: { ]; description = "Binary-to-text encodings (e.g. base64)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base-feature-macros" = callPackage @@ -38297,8 +35754,6 @@ self: { doHaddock = false; description = "Semantic CPP feature macros for base"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base-generics" = callPackage @@ -38310,8 +35765,6 @@ self: { libraryHaskellDepends = [ base ]; description = "This library provides some instances for extra GHC.Generic typeclass such as Int8, Word16 and some unboxed types as well."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base-io-access" = callPackage @@ -38323,8 +35776,6 @@ self: { libraryHaskellDepends = [ base ]; description = "The IO functions included in base delimited into small, composable classes"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base-noprelude" = callPackage @@ -38399,8 +35850,6 @@ self: { ]; description = "Fast RFC 4648-compliant Base16 encoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base16-bytestring_0_1_1_7" = callPackage @@ -38449,8 +35898,6 @@ self: { ]; description = "Optics for the Base16 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base32" = callPackage @@ -38491,8 +35938,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "Fast base32 and base32hex codec for ByteStrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base32-lens" = callPackage @@ -38613,8 +36058,6 @@ self: { ]; description = "Base62 encoding and decoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base64" = callPackage @@ -38665,8 +36108,6 @@ self: { ]; description = "Base64 encoding of byte sequences"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base64-bytestring" = callPackage @@ -38750,8 +36191,6 @@ self: { ]; description = "Base64-encode and decode streams of bytes. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "base64-lens" = callPackage @@ -38866,8 +36305,6 @@ self: { ]; description = "Baserock Definitions Schema"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "basex-client" = callPackage @@ -38879,8 +36316,6 @@ self: { libraryHaskellDepends = [ base network pureMD5 utf8-string ]; description = "A BaseX client for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bash" = callPackage @@ -38912,8 +36347,6 @@ self: { ]; description = "Lifting values from base types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "basic-cpuid" = callPackage @@ -38965,8 +36398,6 @@ self: { ]; description = "Basic examples and functions for generics-sop"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "baskell" = callPackage @@ -38983,8 +36414,6 @@ self: { ]; description = "An interpreter for a small functional language"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "batch" = callPackage @@ -39046,8 +36475,6 @@ self: { ]; description = "Batch processing toolset for Linux / Unix"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "battlenet" = callPackage @@ -39061,8 +36488,6 @@ self: { ]; description = "API client for Battle.Net"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "battlenet-yesod" = callPackage @@ -39076,8 +36501,6 @@ self: { ]; description = "Yesod integration for the battlenet package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "battleplace" = callPackage @@ -39095,8 +36518,6 @@ self: { ]; description = "Core definitions for BattlePlace.io service"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "battleplace-api" = callPackage @@ -39110,8 +36531,6 @@ self: { ]; description = "Public API definitions of BattlePlace.io service"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "battleship-combinatorics" = callPackage @@ -39135,8 +36554,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Compute number of possible arrangements in the battleship game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "battleships" = callPackage @@ -39169,8 +36586,6 @@ self: { ]; description = "A web-based implementation of battleships including an AI opponent"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bayes-stack" = callPackage @@ -39190,8 +36605,6 @@ self: { ]; description = "Framework for inferring generative probabilistic models with Gibbs sampling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bazel-coverage-report-renderer" = callPackage @@ -39209,8 +36622,6 @@ self: { ]; description = "HTML Coverage Reports for Rules_Haskell"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bazel-runfiles" = callPackage @@ -39257,8 +36668,6 @@ self: { ]; description = "Tools for reading Big Binary Indexed files, e.g., bigBed, bigWig"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bcp47" = callPackage @@ -39278,8 +36687,6 @@ self: { ]; description = "Language tags as specified by BCP 47"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bcp47-orphans" = callPackage @@ -39299,8 +36706,6 @@ self: { ]; description = "BCP47 orphan instances"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bcrypt" = callPackage @@ -39359,8 +36764,6 @@ self: { ]; description = "Tools for managing a content store of software packages"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ostree;}; "bdcs-api" = callPackage @@ -39400,8 +36803,6 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libgit2-glib;}; "bdd" = callPackage @@ -39419,8 +36820,6 @@ self: { ]; description = "Behavior-Driven Development DSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bdelta" = callPackage @@ -39447,8 +36846,6 @@ self: { executableHaskellDepends = [ aeson base network text url ]; description = "Update CSS in the browser without reloading the page"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam" = callPackage @@ -39468,8 +36865,6 @@ self: { ]; description = "A type-safe SQL mapper for Haskell that doesn't use Template Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-automigrate" = callPackage @@ -39507,8 +36902,6 @@ self: { ]; description = "DB migration library for beam, targeting Postgres"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-core" = callPackage @@ -39530,8 +36923,6 @@ self: { ]; description = "Type-safe, feature-complete SQL query and manipulation interface for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-migrate" = callPackage @@ -39552,8 +36943,6 @@ self: { ]; description = "SQL DDL support and migrations support library for Beam"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-mysql" = callPackage @@ -39571,8 +36960,6 @@ self: { ]; description = "Connection layer between beam and MySQL/MariaDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-newtype-field" = callPackage @@ -39588,8 +36975,6 @@ self: { ]; description = "A newtype for wrapping newtypes into beam schemas"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-postgres" = callPackage @@ -39616,8 +37001,6 @@ self: { ]; description = "Connection layer between beam and postgres"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-sqlite" = callPackage @@ -39640,8 +37023,6 @@ self: { ]; description = "Beam driver for SQLite"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beam-th" = callPackage @@ -39663,8 +37044,6 @@ self: { ]; description = "Template Haskell utilities for beam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beamable" = callPackage @@ -39689,8 +37068,6 @@ self: { ]; description = "Generic serializer/deserializer with compact representation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bearriver" = callPackage @@ -39719,8 +37096,6 @@ self: { executableHaskellDepends = [ array base haskell98 mtl ]; description = "A pretty-printer for higher-order logic"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bech32" = callPackage @@ -39748,8 +37123,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Implementation of the Bech32 cryptocurrency address format (BIP 0173)"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bech32-th" = callPackage @@ -39767,8 +37140,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Template Haskell extensions to the Bech32 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bed-and-breakfast" = callPackage @@ -39785,8 +37156,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Efficient Matrix and Vector operations in 100% Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "beeminder-api" = callPackage @@ -39810,8 +37179,6 @@ self: { ]; description = "Bindings to the beeminder.com JSON API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bein" = callPackage @@ -39835,8 +37202,6 @@ self: { ]; description = "Bein is a provenance and workflow management system for bioinformatics"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "belka" = callPackage @@ -39865,8 +37230,6 @@ self: { ]; description = "HTTP client DSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bench" = callPackage @@ -39902,8 +37265,6 @@ self: { testHaskellDepends = [ base split text ]; description = "Plot and compare benchmarks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bench-show" = callPackage @@ -39930,8 +37291,6 @@ self: { testHaskellDepends = [ base split text ]; description = "Show, plot and compare benchmark results"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "benchmark-function" = callPackage @@ -39999,8 +37358,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bencodex reader/writer for Haskell"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bencoding" = callPackage @@ -40047,8 +37404,6 @@ self: { librarySystemDepends = [ db ]; description = "Pretty BerkeleyDB v4 binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) db;}; "berp" = callPackage @@ -40074,8 +37429,6 @@ self: { ]; description = "An implementation of Python 3"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bert" = callPackage @@ -40098,8 +37451,6 @@ self: { ]; description = "BERT implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "besout" = callPackage @@ -40111,8 +37462,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Extended GCD of polynomials over F_p[x]"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bet" = callPackage @@ -40139,8 +37488,6 @@ self: { ]; description = "Betfair API bindings. Bet on sports on betting exchanges."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "betacode" = callPackage @@ -40157,8 +37504,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck smallcheck ]; description = "A codec for beta code (http://en.wikipedia.org/wiki/Beta_Code)."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "betris" = callPackage @@ -40181,8 +37526,6 @@ self: { ]; description = "A horizontal version of tetris for braille users"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "between" = callPackage @@ -40222,8 +37565,6 @@ self: { ]; description = "Bidirectionalization for Free! (POPL'09)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bff-mono" = callPackage @@ -40256,8 +37597,6 @@ self: { ]; description = "Implementation of the BGAPI serial protocol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bgmax" = callPackage @@ -40269,8 +37608,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring time ]; description = "Parse BgMax-files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bgzf" = callPackage @@ -40286,8 +37623,6 @@ self: { ]; description = "Blocked GZip"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bhoogle" = callPackage @@ -40309,8 +37644,6 @@ self: { ]; description = "Simple terminal GUI for local hoogle"; license = "(BSD-3-Clause OR Apache-2.0)"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bibdb" = callPackage @@ -40333,8 +37666,6 @@ self: { executableToolDepends = [ alex happy ]; description = "A database based bibliography manager for BibTeX"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bibtex" = callPackage @@ -40370,8 +37701,6 @@ self: { ]; description = "The unicode bidirectional algorithm via ICU"; license = "(BSD-2-Clause OR Apache-2.0)"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {icu-uc = null;}; "bidirectional" = callPackage @@ -40384,8 +37713,6 @@ self: { testHaskellDepends = [ base hedgehog mtl ]; description = "Simple bidirectional serialization and deserialization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bidirectionalization-combined" = callPackage @@ -40405,8 +37732,6 @@ self: { ]; description = "Prototype Implementation of Combining Syntactic and Semantic Bidirectionalization (ICFP'10)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bidispec" = callPackage @@ -40418,8 +37743,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "Specification of generators and parsers"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bidispec-extras" = callPackage @@ -40431,8 +37754,6 @@ self: { libraryHaskellDepends = [ base bytestring dataenc mtl ]; description = "Extra helper functions for bidirectional specifications"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bifunctor" = callPackage @@ -40501,8 +37822,6 @@ self: { ]; description = "A parser for the Billboard chord dataset"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "billeksah-forms" = callPackage @@ -40520,8 +37839,6 @@ self: { ]; description = "Leksah library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "billeksah-main" = callPackage @@ -40540,8 +37857,6 @@ self: { ]; description = "Leksah plugin base"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "billeksah-main-static" = callPackage @@ -40582,8 +37897,6 @@ self: { ]; description = "Leksah library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "billeksah-services" = callPackage @@ -40599,8 +37912,6 @@ self: { ]; description = "Leksah library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bimap" = callPackage @@ -40720,8 +38031,6 @@ self: { ]; description = "Bit parsing/writing on top of binary"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-communicator" = callPackage @@ -40733,8 +38042,6 @@ self: { libraryHaskellDepends = [ base binary bytestring mtl ]; description = "Flexible way to ease transmission of binary data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-conduit" = callPackage @@ -40765,8 +38072,6 @@ self: { libraryHaskellDepends = [ base binary ghc-prim ]; description = "Automatic deriving of Binary using GHC.Generics"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-enum" = callPackage @@ -40803,8 +38108,6 @@ self: { ]; description = "An alternate with strong-typed errors for `Data.Binary.Get` monad from `binary` package."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-file" = callPackage @@ -40820,8 +38123,6 @@ self: { ]; description = "read/write binary file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-generic" = callPackage @@ -40874,8 +38175,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Binary Indexed Trees (a.k.a. Fenwick Trees)."; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-instances" = callPackage @@ -41028,8 +38327,6 @@ self: { libraryHaskellDepends = [ base binary bytestring mtl ]; description = "Monad to ease implementing a binary network protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-protocol-zmq" = callPackage @@ -41045,8 +38342,6 @@ self: { ]; description = "Monad to ease implementing a binary network protocol over ZeroMQ"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-search" = callPackage @@ -41135,8 +38430,6 @@ self: { ]; description = "data serialization/deserialization io-streams library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-strict" = callPackage @@ -41179,8 +38472,6 @@ self: { ]; description = "Tagged binary serialisation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-tree" = callPackage @@ -41220,8 +38511,6 @@ self: { ]; description = "Type-safe binary serialization"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binary-varint" = callPackage @@ -41274,8 +38563,6 @@ self: { ]; description = "Data marshaling library that uses type level equations to optimize buffering"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binding-core" = callPackage @@ -41290,8 +38577,6 @@ self: { testHaskellDepends = [ base HTF HUnit QuickCheck random ]; description = "Data Binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binding-gtk" = callPackage @@ -41306,8 +38591,6 @@ self: { testHaskellDepends = [ base binding-core directory gtk ]; description = "Data Binding in Gtk2Hs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binding-wx" = callPackage @@ -41322,8 +38605,6 @@ self: { testHaskellDepends = [ base binding-core directory wx ]; description = "Data Binding in WxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bindings" = callPackage @@ -41358,8 +38639,6 @@ self: { libraryPkgconfigDepends = [ esound ]; description = "Low level bindings to EsounD (ESD; Enlightened Sound Daemon)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {esound = null;}; "bindings-GLFW" = callPackage @@ -41398,8 +38677,6 @@ self: { librarySystemDepends = [ K8055D ]; description = "Bindings to Velleman K8055 dll"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {K8055D = null;}; "bindings-apr" = callPackage @@ -41412,8 +38689,6 @@ self: { libraryPkgconfigDepends = [ apr ]; description = "Low level bindings to Apache Portable Runtime (APR)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) apr;}; "bindings-apr-util" = callPackage @@ -41426,8 +38701,6 @@ self: { libraryPkgconfigDepends = [ apr-util ]; description = "Low level bindings to Apache Portable Runtime Utility (APR Utility)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {apr-util = null;}; "bindings-audiofile" = callPackage @@ -41455,8 +38728,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "Bindings for libbfd, a library of the GNU `binutils'"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {bfd = null; opcodes = null;}; "bindings-cctools" = callPackage @@ -41469,8 +38740,6 @@ self: { librarySystemDepends = [ dttools ]; description = "Bindings to the CCTools WorkQueue C library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {dttools = null;}; "bindings-codec2" = callPackage @@ -41501,8 +38770,6 @@ self: { libraryHaskellDepends = [ base ]; description = "This package is obsolete. Look for bindings-DSL instead."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bindings-dc1394" = callPackage @@ -41516,8 +38783,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Library for using firewire (iidc-1394) cameras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {dc1394 = null;}; "bindings-directfb" = callPackage @@ -41546,8 +38811,6 @@ self: { libraryPkgconfigDepends = [ eskit ]; description = "Bindings to ESKit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {eskit = null;}; "bindings-fann" = callPackage @@ -41560,8 +38823,6 @@ self: { libraryPkgconfigDepends = [ fann ]; description = "Low level bindings to FANN neural network library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {fann = null;}; "bindings-fluidsynth" = callPackage @@ -41574,8 +38835,6 @@ self: { libraryPkgconfigDepends = [ fluidsynth ]; description = "Haskell FFI bindings for fluidsynth software synthesizer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fluidsynth;}; "bindings-friso" = callPackage @@ -41588,8 +38847,6 @@ self: { librarySystemDepends = [ friso ]; description = "Low level bindings for friso"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {friso = null;}; "bindings-glib" = callPackage @@ -41638,8 +38895,6 @@ self: { libraryPkgconfigDepends = [ gsl ]; description = "Low level bindings to GNU GSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gsl;}; "bindings-gts" = callPackage @@ -41669,8 +38924,6 @@ self: { executableHaskellDepends = [ base ]; description = "Hamlib bindings for Haskell"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) hamlib;}; "bindings-hdf5" = callPackage @@ -41682,8 +38935,6 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "Project bindings-* raw interface to HDF5 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bindings-levmar" = callPackage @@ -41733,8 +38984,6 @@ self: { libraryPkgconfigDepends = [ libftdi libusb ]; description = "Low level bindings to libftdi"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libftdi; libusb = null;}; "bindings-libg15" = callPackage @@ -41747,8 +38996,6 @@ self: { librarySystemDepends = [ g15 ]; description = "Bindings to libg15"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {g15 = null;}; "bindings-libpci" = callPackage @@ -41760,8 +39007,6 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "Low level bindings to libpci"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bindings-librrd" = callPackage @@ -41774,8 +39019,6 @@ self: { libraryPkgconfigDepends = [ librrd ]; description = "Low level bindings to RRDtool"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {librrd = null;}; "bindings-libstemmer" = callPackage @@ -41792,8 +39035,6 @@ self: { librarySystemDepends = [ stemmer ]; description = "Binding for libstemmer with low level binding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {stemmer = null;}; "bindings-libusb" = callPackage @@ -41806,8 +39047,6 @@ self: { libraryPkgconfigDepends = [ libusb ]; description = "Low level bindings to libusb"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {libusb = null;}; "bindings-libv4l2" = callPackage @@ -41820,8 +39059,6 @@ self: { librarySystemDepends = [ v4l2 ]; description = "bindings to libv4l2 for Linux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {v4l2 = null;}; "bindings-libzip" = callPackage @@ -41845,8 +39082,6 @@ self: { libraryHaskellDepends = [ base bindings-DSL ioctl ]; description = "bindings to Video For Linux Two (v4l2) kernel interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bindings-lxc" = callPackage @@ -41885,8 +39120,6 @@ self: { libraryPkgconfigDepends = [ monetdb-mapi ]; description = "Low-level bindings for the MonetDB API (mapi)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {monetdb-mapi = null;}; "bindings-mpdecimal" = callPackage @@ -41898,8 +39131,6 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "bindings to mpdecimal library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bindings-nettle" = callPackage @@ -41974,8 +39205,6 @@ self: { libraryHaskellDepends = [ base bindings-DSL ioctl ]; description = "PPDev bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bindings-saga-cmd" = callPackage @@ -42024,8 +39253,6 @@ self: { librarySystemDepends = [ scsynth ]; description = "Low-level bindings to the SuperCollider synthesis engine library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {scsynth = null;}; "bindings-sipc" = callPackage @@ -42041,8 +39268,6 @@ self: { executableHaskellDepends = [ base ]; description = "Low level bindings to SIPC"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {sipc = null;}; "bindings-sophia" = callPackage @@ -42101,8 +39326,6 @@ self: { testHaskellDepends = [ base ]; description = "Bindings against the wlc library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {wlc = null;}; "bindings-yices" = callPackage @@ -42129,8 +39352,6 @@ self: { libraryHaskellDepends = [ base binary bytestring rank1dynamic ]; description = "A variation of Data.Dynamic.Dynamic with a Binary instance"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binembed" = callPackage @@ -42149,8 +39370,6 @@ self: { ]; description = "Embed data into object files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "binembed-example" = callPackage @@ -42167,8 +39386,6 @@ self: { ]; description = "Example project using binembed to embed data in object files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bini" = callPackage @@ -42238,8 +39455,6 @@ self: { executableHaskellDepends = [ base bytestring random ]; description = "A bioinformatics library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bio-sequence" = callPackage @@ -42256,8 +39471,6 @@ self: { testHaskellDepends = [ base bytestring hspec QuickCheck ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bioace" = callPackage @@ -42271,8 +39484,6 @@ self: { ]; description = "Library for reading ace assembly files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bioalign" = callPackage @@ -42284,8 +39495,6 @@ self: { libraryHaskellDepends = [ base biocore bytestring ]; description = "Data structures and helper functions for calculating alignments"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biocore" = callPackage @@ -42299,8 +39508,6 @@ self: { libraryHaskellDepends = [ base bytestring stringable ]; description = "A bioinformatics library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biofasta" = callPackage @@ -42312,8 +39519,6 @@ self: { libraryHaskellDepends = [ base biocore bytestring ]; description = "Library for reading fasta sequence files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biofastq" = callPackage @@ -42325,8 +39530,6 @@ self: { libraryHaskellDepends = [ base biocore bytestring ]; description = "A library for reading FASTQ files"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biohazard" = callPackage @@ -42349,8 +39552,6 @@ self: { ]; description = "bioinformatics support library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bioinformatics-toolkit" = callPackage @@ -42387,8 +39588,6 @@ self: { ]; description = "A collection of bioinformatics tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biophd" = callPackage @@ -42404,8 +39603,6 @@ self: { ]; description = "Library for reading phd sequence files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biopsl" = callPackage @@ -42422,8 +39619,6 @@ self: { executableHaskellDepends = [ cmdargs unordered-containers ]; description = "Library and executables for working with PSL files"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biosff" = callPackage @@ -42440,8 +39635,6 @@ self: { executableHaskellDepends = [ array base cmdargs mtl ]; description = "Library and executables for working with SFF files"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "biostockholm" = callPackage @@ -42464,8 +39657,6 @@ self: { ]; description = "Parsing and rendering of Stockholm files (used by Pfam, Rfam and Infernal)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bip32" = callPackage @@ -42486,8 +39677,6 @@ self: { ]; description = "BIP-0032: Hierarchical Deterministic Wallets for Bitcoin and other cryptocurrencies"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "birch-beer" = callPackage @@ -42522,8 +39711,6 @@ self: { ]; description = "Plot a colorful tree"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bird" = callPackage @@ -42544,8 +39731,6 @@ self: { ]; description = "A simple, sinatra-inspired web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "birds-of-paradise" = callPackage @@ -42558,8 +39743,6 @@ self: { testHaskellDepends = [ base ]; description = "Birds of Paradise"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bisc" = callPackage @@ -42597,8 +39780,6 @@ self: { ]; description = "Determine relevant parts of binary data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bishbosh" = callPackage @@ -42629,8 +39810,6 @@ self: { ]; description = "Plays chess"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bit-array" = callPackage @@ -42643,8 +39822,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "A bit array (aka bitset, bitmap, bit vector) API for numeric types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bit-protocol" = callPackage @@ -42684,8 +39861,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Lazy, infinite, compact stream of Bool with O(1) indexing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bit-vector" = callPackage @@ -42736,8 +39911,6 @@ self: { ]; description = "Bitcoin address generation and rendering. Parsing coming soon."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-api" = callPackage @@ -42762,8 +39935,6 @@ self: { ]; description = "Provides access to the RPC API of Bitcoin Core"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-api-extra" = callPackage @@ -42786,8 +39957,6 @@ self: { ]; description = "Higher level constructs on top of the bitcoin-api package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-block" = callPackage @@ -42808,8 +39977,6 @@ self: { ]; description = "Utility functions for manipulating bitcoin blocks"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-compact-filters" = callPackage @@ -42832,8 +39999,6 @@ self: { ]; description = "BIP 158 compact block filters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-hash" = callPackage @@ -42871,8 +40036,6 @@ self: { ]; description = "Partial implementation of the Bitcoin protocol (as of 2013)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-keys" = callPackage @@ -42890,8 +40053,6 @@ self: { ]; description = "Bitcoin keys"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-payment-channel" = callPackage @@ -42957,8 +40118,6 @@ self: { ]; description = "Library to communicate with the Satoshi Bitcoin daemon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-script" = callPackage @@ -42976,8 +40135,6 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Compilation, manipulation and decompilation of Bitcoin scripts"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-scripting" = callPackage @@ -43001,8 +40158,6 @@ self: { ]; description = "Resources for working with miniscript, and script descriptors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-tx" = callPackage @@ -43023,8 +40178,6 @@ self: { ]; description = "Utility functions for manipulating bitcoin transactions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoin-types" = callPackage @@ -43044,8 +40197,6 @@ self: { ]; description = "Provides consistent low-level types used commonly among Bitcoin implementations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoind-regtest" = callPackage @@ -43075,8 +40226,6 @@ self: { ]; description = "A library for working with bitcoin-core regtest networks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitcoind-rpc" = callPackage @@ -43098,8 +40247,6 @@ self: { ]; description = "A streamlined interface to bitcoin core using Haskoin types and Servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitly-cli" = callPackage @@ -43115,8 +40262,6 @@ self: { ]; description = "A command line tool to access bit.ly URL shortener."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitmap" = callPackage @@ -43155,8 +40300,6 @@ self: { ]; description = "Bitmap library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bits" = callPackage @@ -43181,8 +40324,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Atomic bit operations on memory locations for low-level synchronization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bits-bytestring" = callPackage @@ -43232,8 +40373,6 @@ self: { ]; description = "Bitstream support for Conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bits-extra" = callPackage @@ -43270,8 +40409,6 @@ self: { librarySystemDepends = [ gcc_s ]; description = "Efficient high-level bit operations not found in Data.Bits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gcc_s = null;}; "bitset" = callPackage @@ -43294,8 +40431,6 @@ self: { benchmarkSystemDepends = [ gmp ]; description = "A space-efficient set data structure"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gmp;}; "bitset-word8" = callPackage @@ -43338,8 +40473,6 @@ self: { executablePkgconfigDepends = [ gtk2 pango ]; description = "Proof-of-concept tool for writing using binary choices"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk2; inherit (pkgs) pango;}; "bitstream" = callPackage @@ -43401,8 +40534,6 @@ self: { ]; description = "Bittorrent protocol implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bittrex" = callPackage @@ -43484,8 +40615,6 @@ self: { ]; description = "Bitwise operations on bounded enumerations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bitx-bitcoin" = callPackage @@ -43509,8 +40638,6 @@ self: { ]; description = "A Haskell library for working with the BitX bitcoin exchange"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bizzlelude" = callPackage @@ -43526,8 +40653,6 @@ self: { ]; description = "A lousy Prelude replacement by a lousy dude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bizzlelude-js" = callPackage @@ -43539,8 +40664,6 @@ self: { libraryHaskellDepends = [ base containers text ]; description = "A lousy Prelude replacement by a lousy dude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bk-tree" = callPackage @@ -43575,8 +40698,6 @@ self: { ]; description = "Backup utility for backing up to cloud storage services (S3 only right now)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bktrees" = callPackage @@ -43602,8 +40723,6 @@ self: { executableHaskellDepends = [ base haskell98 unix ]; description = "a stupid cron"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "black-jewel" = callPackage @@ -43686,8 +40805,6 @@ self: { libraryHaskellDepends = [ base bytestring text vector ]; description = "The BLAKE SHA-3 candidate hashes, in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blakesum-demo" = callPackage @@ -43705,8 +40822,6 @@ self: { ]; description = "The BLAKE SHA-3 candidate hashes, in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blank-canvas" = callPackage @@ -43761,8 +40876,6 @@ self: { libraryHaskellDepends = [ base ieee QuickCheck storable-complex ]; description = "Bindings to the BLAS library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blas-carray" = callPackage @@ -43835,8 +40948,6 @@ self: { ]; description = "Library for reading Blast XML output"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blatex" = callPackage @@ -43854,8 +40965,6 @@ self: { ]; description = "Blog in LaTeX"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blaze" = callPackage @@ -43926,8 +41035,6 @@ self: { ]; description = "Enumeratees for the incremental conversion of builders to bytestrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blaze-colonnade" = callPackage @@ -43946,8 +41053,6 @@ self: { testHaskellDepends = [ base colonnade doctest ]; description = "blaze-html backend for colonnade"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blaze-from-html" = callPackage @@ -44001,8 +41106,6 @@ self: { ]; description = "Some contributions to add handy things to blaze html"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blaze-html-hexpat" = callPackage @@ -44014,8 +41117,6 @@ self: { libraryHaskellDepends = [ base blaze-html bytestring hexpat text ]; description = "A hexpat backend for blaze-html"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blaze-html-truncate" = callPackage @@ -44031,8 +41132,6 @@ self: { ]; description = "A truncator for blaze-html"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blaze-json" = callPackage @@ -44054,8 +41153,6 @@ self: { ]; description = "tiny library for encoding json"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blaze-markup" = callPackage @@ -44134,8 +41231,6 @@ self: { ]; description = "Fast rendering of common datatypes (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blazeMarker" = callPackage @@ -44164,8 +41259,6 @@ self: { ]; description = "A true monad (transformer) version of the blaze-markup and blaze-html libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ble" = callPackage @@ -44197,8 +41290,6 @@ self: { ]; description = "Bluetooth Low Energy (BLE) peripherals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blindpass" = callPackage @@ -44232,8 +41323,6 @@ self: { ]; description = "Control library for blink(1) LED from ThingM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blip" = callPackage @@ -44252,8 +41341,6 @@ self: { ]; description = "Python to bytecode compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bliplib" = callPackage @@ -44269,8 +41356,6 @@ self: { ]; description = "Support code for Blip"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blockchain" = callPackage @@ -44294,8 +41379,6 @@ self: { ]; description = "Generic blockchain implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blockhash" = callPackage @@ -44317,8 +41400,6 @@ self: { testHaskellDepends = [ base ]; description = "Blockhash perceptual image hash algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blocking-transactions" = callPackage @@ -44351,8 +41432,6 @@ self: { executableHaskellDepends = [ base ConfigFile haskell98 old-time ]; description = "Very simple static blog software"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bloodhound" = callPackage @@ -44381,8 +41460,6 @@ self: { ]; description = "Elasticsearch client library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bloodhound-amazonka-auth" = callPackage @@ -44405,8 +41482,6 @@ self: { ]; description = "Adds convenient Amazon ElasticSearch Service authentication to Bloodhound"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bloomfilter" = callPackage @@ -44445,8 +41520,6 @@ self: { benchmarkHaskellDepends = [ base criterion random ]; description = "Distributed bloom filters on Redis (using the Hedis client)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blosum" = callPackage @@ -44468,8 +41541,6 @@ self: { ]; description = "BLOSUM generator"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bloxorz" = callPackage @@ -44484,8 +41555,6 @@ self: { executableHaskellDepends = [ base GLFW OpenGL ]; description = "OpenGL Logic Game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blubber" = callPackage @@ -44503,8 +41572,6 @@ self: { ]; description = "The blubber client; connects to the blubber server"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blubber-server" = callPackage @@ -44526,8 +41593,6 @@ self: { ]; description = "The blubber server, serves blubber clients"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blucontrol" = callPackage @@ -44617,8 +41682,6 @@ self: { executablePkgconfigDepends = [ gtk2 ]; description = "full-featured tiling for the GNOME desktop environment"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk2;}; "bluetileutils" = callPackage @@ -44632,8 +41695,6 @@ self: { executableHaskellDepends = [ base gtk ]; description = "Utilities for Bluetile"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blunk-hask-tests" = callPackage @@ -44649,8 +41710,6 @@ self: { executableHaskellDepends = [ base ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "blunt" = callPackage @@ -44672,8 +41731,6 @@ self: { executableHaskellDepends = [ base ]; description = "Convert between pointfree and pointful expressions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bmp" = callPackage @@ -44698,8 +41755,6 @@ self: { ]; description = "Library for communication with the Bosch BNO055 orientation sensor"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "board-games" = callPackage @@ -44768,8 +41823,6 @@ self: { ]; description = "Copy a directory tree, making zero-size sparse copies of big files"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bogre-banana" = callPackage @@ -44787,8 +41840,6 @@ self: { ]; executableHaskellDepends = [ base hogre hois random ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boilerplate" = callPackage @@ -44817,8 +41868,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Generate Haskell boilerplate"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bolt" = callPackage @@ -44842,8 +41891,6 @@ self: { ]; description = "Bolt driver for Neo4j"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boltzmann-brain" = callPackage @@ -44869,8 +41916,6 @@ self: { ]; description = "Analytic sampler compiler for combinatorial systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boltzmann-samplers" = callPackage @@ -44921,8 +41966,6 @@ self: { ]; description = "Bond schema compiler and code generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bond-haskell" = callPackage @@ -44951,8 +41994,6 @@ self: { ]; description = "Runtime support for BOND serialization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bond-haskell-compiler" = callPackage @@ -44974,8 +42015,6 @@ self: { testHaskellDepends = [ base ]; description = "Bond code generator for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bookkeeper" = callPackage @@ -45003,8 +42042,6 @@ self: { ]; description = "Anonymous records and overloaded labels"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bookkeeper-permissions" = callPackage @@ -45016,8 +42053,6 @@ self: { libraryHaskellDepends = [ base bookkeeper type-level-sets ]; description = "Permissions for bookkeeper records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bookkeeping" = callPackage @@ -45114,8 +42149,6 @@ self: { ]; description = "Boolean normal form: NNF, DNF & CNF"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boolector" = callPackage @@ -45147,8 +42180,6 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "Boolean expressions with various representations and search queries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bools" = callPackage @@ -45206,8 +42237,6 @@ self: { ]; description = "Chronokinetic stream sources and incremental consumers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boomerang" = callPackage @@ -45242,8 +42271,6 @@ self: { ]; description = "Boomshine clone"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boop" = callPackage @@ -45279,8 +42306,6 @@ self: { ]; description = "Mathematically sound sound synthesis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boots" = callPackage @@ -45317,8 +42342,6 @@ self: { executableHaskellDepends = [ base time ]; description = "Factory for quickly building an application"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boots-cloud" = callPackage @@ -45336,8 +42359,6 @@ self: { ]; description = "Factory for quickly building a microservice"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boots-web" = callPackage @@ -45357,8 +42378,6 @@ self: { ]; description = "Factory for quickly building a web application"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bootstrap-types" = callPackage @@ -45413,8 +42432,6 @@ self: { ]; description = "Metering System for OpenStack metrics provided by Vaultaire"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "boring" = callPackage @@ -45455,8 +42472,6 @@ self: { executableHaskellDepends = [ base ]; description = "A boring window switcher"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bot" = callPackage @@ -45468,8 +42483,6 @@ self: { libraryHaskellDepends = [ arrows base Stream ]; description = "bots for functional reactive programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "both" = callPackage @@ -45494,8 +42507,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Build tool for Lambdabot"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bottom" = callPackage @@ -45520,8 +42531,6 @@ self: { ]; description = "Encoding and decoding for the Bottom spec"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bound" = callPackage @@ -45567,8 +42576,6 @@ self: { ]; description = "ScopeH and ScopeT extras for bound"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bound-gen" = callPackage @@ -45591,8 +42598,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Arrays with a value for every index"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bounded-queue" = callPackage @@ -45662,8 +42667,6 @@ self: { ]; description = "audio-visual pseudo-physical simulation of colliding circles"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "box" = callPackage @@ -45691,8 +42694,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "boxes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "box-csv" = callPackage @@ -45709,8 +42710,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "box-socket" = callPackage @@ -45734,8 +42733,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Box websockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "box-tuples" = callPackage @@ -45809,8 +42806,6 @@ self: { ]; description = "Types and functions to work with braids and Khovanov homology"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brain-bleep" = callPackage @@ -45824,8 +42819,6 @@ self: { executableHaskellDepends = [ array base containers parsec ]; description = "primitive imperative language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brainfuck" = callPackage @@ -45908,8 +42901,6 @@ self: { executableHaskellDepends = [ base haskgame mtl SDL ]; description = "A simple Breakout game implementation"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "breve" = callPackage @@ -45933,8 +42924,6 @@ self: { ]; description = "a url shortener"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brians-brain" = callPackage @@ -45948,8 +42937,6 @@ self: { executableHaskellDepends = [ array base parallel random SDL ]; description = "A Haskell implementation of the Brian's Brain cellular automaton"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brick" = callPackage @@ -45994,8 +42981,6 @@ self: { ]; description = "A drop-down menu widget for brick"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brick-filetree" = callPackage @@ -46055,8 +43040,6 @@ self: { ]; description = "Bricks is a lazy functional language based on Nix"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bricks-internal" = callPackage @@ -46075,8 +43058,6 @@ self: { ]; description = "..."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bricks-internal-test" = callPackage @@ -46092,8 +43073,6 @@ self: { ]; description = "..."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bricks-parsec" = callPackage @@ -46114,8 +43093,6 @@ self: { ]; description = "..."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bricks-rendering" = callPackage @@ -46136,8 +43113,6 @@ self: { ]; description = "..."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bricks-syntax" = callPackage @@ -46158,8 +43133,6 @@ self: { ]; description = "..."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brillig" = callPackage @@ -46180,8 +43153,6 @@ self: { ]; description = "Simple part of speech tagger"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brittany" = callPackage @@ -46303,8 +43274,6 @@ self: { libraryHaskellDepends = [ base containers stm time ]; description = "Small library for interactive functional programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brok" = callPackage @@ -46332,8 +43301,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Finds broken links in text files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "broker-haskell" = callPackage @@ -46347,8 +43314,6 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Haskell bindings to Broker, Bro's messaging library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {broker = null;}; "bronyradiogermany-common" = callPackage @@ -46366,8 +43331,6 @@ self: { ]; description = "Common types and URIs for the BronyRadioGermany API bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bronyradiogermany-streaming" = callPackage @@ -46388,8 +43351,6 @@ self: { ]; description = "Streaming interface for the BronyRadioGermany API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brotli" = callPackage @@ -46409,8 +43370,6 @@ self: { ]; description = "Brotli (RFC7932) compression and decompression"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) brotli;}; "brotli-conduit" = callPackage @@ -46431,8 +43390,6 @@ self: { ]; description = "Conduit interface for Brotli (RFC7932) compression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "brotli-streams" = callPackage @@ -46453,8 +43410,6 @@ self: { ]; description = "IO-Streams interface for Brotli (RFC7932) compression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "browscap" = callPackage @@ -46471,8 +43426,6 @@ self: { ]; description = "A reader and interface for the Browser Capabilities Project data files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bsb-http-chunked" = callPackage @@ -46507,8 +43460,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Access to the BSD sysctl(3) interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bson" = callPackage @@ -46530,8 +43481,6 @@ self: { ]; description = "BSON documents are JSON-like objects with a standard binary encoding"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bson-generic" = callPackage @@ -46543,8 +43492,6 @@ self: { libraryHaskellDepends = [ base bson ghc-prim text ]; description = "Generic functionality for BSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bson-generics" = callPackage @@ -46556,8 +43503,6 @@ self: { libraryHaskellDepends = [ base bson ghc-prim ]; description = "Generics functionality for BSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bson-lens" = callPackage @@ -46569,8 +43514,6 @@ self: { libraryHaskellDepends = [ base bson lens text ]; description = "BSON lenses"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bson-mapping" = callPackage @@ -46617,8 +43560,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A simple unassuming parser for bytestring"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "btree" = callPackage @@ -46638,8 +43579,6 @@ self: { benchmarkHaskellDepends = [ base clock ghc-prim hashable ]; description = "B-Tree on Unmanaged Heap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "btree-concurrent" = callPackage @@ -46662,8 +43601,6 @@ self: { ]; description = "A backend agnostic, concurrent BTree"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "btrfs" = callPackage @@ -46715,8 +43652,6 @@ self: { ]; description = "Automates most of your plain text accounting data entry in ledger format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buffer" = callPackage @@ -46738,8 +43673,6 @@ self: { benchmarkHaskellDepends = [ bug criterion rerebase ]; description = "Simple mutable low-level buffer for IO"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buffer-builder" = callPackage @@ -46764,8 +43697,6 @@ self: { ]; description = "Library for efficiently building up buffers, one piece at a time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buffer-builder-aeson" = callPackage @@ -46794,8 +43725,6 @@ self: { ]; description = "Serialize Aeson values with Data.BufferBuilder"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buffer-pipe" = callPackage @@ -46838,8 +43767,6 @@ self: { doHaddock = false; description = "Assembles many Dockerfiles in one"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buffon" = callPackage @@ -46856,8 +43783,6 @@ self: { ]; description = "An implementation of Buffon machines"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buffon-machines" = callPackage @@ -46907,8 +43832,6 @@ self: { ]; description = "Bugsnag error reporter for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bugsnag-hs" = callPackage @@ -46946,8 +43869,6 @@ self: { ]; description = "A Haskell interface to the Bugzilla native REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bugzilla-redhat" = callPackage @@ -46985,8 +43906,6 @@ self: { testHaskellDepends = [ base containers extra mtl transformers ]; description = "Build systems a la carte"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buildable" = callPackage @@ -46998,8 +43917,6 @@ self: { libraryHaskellDepends = [ base bytestring containers dlist text ]; description = "Typeclass for builders of linear data structures"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buildbox" = callPackage @@ -47016,8 +43933,6 @@ self: { ]; description = "Rehackable components for writing buildbots and test harnesses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buildbox-tools" = callPackage @@ -47031,8 +43946,6 @@ self: { executableHaskellDepends = [ base buildbox parseargs ]; description = "Tools for working with buildbox benchmark result files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "builder" = callPackage @@ -47047,8 +43960,6 @@ self: { ]; description = "bounded ByteArray builder type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buildwrapper" = callPackage @@ -47086,8 +43997,6 @@ self: { ]; description = "A library and an executable that provide an easy API for a Haskell IDE"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bullet" = callPackage @@ -47101,8 +44010,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "A wrapper for the Bullet physics engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) bullet;}; "bulletproofs" = callPackage @@ -47140,8 +44047,6 @@ self: { ]; description = "Bulletproofs are short zero-knowledge proofs without a trusted setup"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bulmex" = callPackage @@ -47166,8 +44071,6 @@ self: { ]; description = "Reflex infused with bulma (css)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bumper" = callPackage @@ -47187,8 +44090,6 @@ self: { ]; description = "Automatically bump package versions, also transitively"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bunz" = callPackage @@ -47204,8 +44105,6 @@ self: { testHaskellDepends = [ base doctest hspec ]; description = "CLI tool to beautify JSON string"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "burnt-explorer" = callPackage @@ -47223,8 +44122,6 @@ self: { ]; description = "List OP_RETURN cryptocurrency transaction outputs"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "burrito" = callPackage @@ -47255,8 +44152,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Burst detection algorithms"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bus-pirate" = callPackage @@ -47273,8 +44168,6 @@ self: { ]; description = "Haskell interface to the Bus Pirate binary interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buster" = callPackage @@ -47291,8 +44184,6 @@ self: { ]; description = "Almost but not quite entirely unlike FRP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buster-gtk" = callPackage @@ -47309,8 +44200,6 @@ self: { ]; description = "Almost but not quite entirely unlike FRP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buster-network" = callPackage @@ -47327,8 +44216,6 @@ self: { ]; description = "Almost but not quite entirely unlike FRP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bustle" = callPackage @@ -47404,8 +44291,6 @@ self: { ]; description = "Monad Transformer for Asyncronous Message Passing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "butterflies" = callPackage @@ -47427,8 +44312,6 @@ self: { ]; description = "butterfly tilings"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "buttplug-hs-core" = callPackage @@ -47531,8 +44414,6 @@ self: { ]; description = "a bitvector datatype that is parameterized by the vector width"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bv-sized-lens" = callPackage @@ -47544,7 +44425,6 @@ self: { libraryHaskellDepends = [ base bv-sized lens parameterized-utils ]; description = "Well-typed lenses for bv-sized bitvectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "byline" = callPackage @@ -47568,8 +44448,6 @@ self: { ]; description = "Library for creating command-line interfaces (colors, menus, etc.)"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytable" = callPackage @@ -47581,8 +44459,6 @@ self: { libraryHaskellDepends = [ base bytestring word24 ]; description = "data from/to ByteString"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "byte-count-reader" = callPackage @@ -47633,8 +44509,6 @@ self: { libraryHaskellDepends = [ base bytestring primitive text ]; description = "Parsing of bytearray-based data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytebuild" = callPackage @@ -47665,8 +44539,6 @@ self: { ]; description = "Serialize to a small byte arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytedump" = callPackage @@ -47707,8 +44579,6 @@ self: { ]; description = "Universal hashing of bytes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytelog" = callPackage @@ -47724,8 +44594,6 @@ self: { ]; description = "Fast logging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "byteorder" = callPackage @@ -47790,8 +44658,6 @@ self: { benchmarkHaskellDepends = [ base gauge primitive ]; description = "Slicing managed and unmanaged memory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytesmith" = callPackage @@ -47816,8 +44682,6 @@ self: { ]; description = "Nonresumable byte parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring_0_11_1_0" = callPackage @@ -47857,8 +44721,6 @@ self: { ]; description = "Arbitrary instances for ByteStrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-builder" = callPackage @@ -47887,8 +44749,6 @@ self: { ]; description = "Variable-length integer encoding"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-class" = callPackage @@ -47902,8 +44762,6 @@ self: { libraryHaskellDepends = [ base bytestring utf8-string ]; description = "Classes for automatic conversion to and from strict and lazy bytestrings. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-conversion" = callPackage @@ -47939,8 +44797,6 @@ self: { libraryHaskellDepends = [ array base bytestring dlist ]; description = "Parse CSV formatted data efficiently"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-delta" = callPackage @@ -48073,8 +44929,6 @@ self: { ]; description = "Plain byte strings ('ForeignPtr'-less 'ByteString's)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-progress" = callPackage @@ -48114,8 +44968,6 @@ self: { ]; description = "fast ByteString to number converting library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-rematch" = callPackage @@ -48129,8 +44981,6 @@ self: { doHaddock = false; description = "Rematch support for ByteString"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-short" = callPackage @@ -48160,8 +45010,6 @@ self: { ]; description = "Efficient conversion of values into readable byte strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-strict-builder" = callPackage @@ -48192,8 +45040,6 @@ self: { libraryHaskellDepends = [ base bytestring pipes primitive ]; description = "break bytestrings up into substrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-time" = callPackage @@ -48210,8 +45056,6 @@ self: { ]; description = "Library for Time parsing from ByteString"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-to-vector" = callPackage @@ -48260,8 +45104,6 @@ self: { libraryHaskellDepends = [ base binary bytestring ]; description = "An efficient finite map from (byte)strings to values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestring-typenats" = callPackage @@ -48280,8 +45122,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion QuickCheck ]; description = "Bytestrings with typenat lengths"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestringparser" = callPackage @@ -48293,8 +45133,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator parsing with Data.ByteString.Lazy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestringparser-temporary" = callPackage @@ -48306,8 +45144,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator parsing with Data.ByteString.Lazy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bytestringreadp" = callPackage @@ -48319,8 +45155,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A ReadP style parser library for ByteString"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "byteunits" = callPackage @@ -48419,8 +45253,6 @@ self: { libraryHaskellDepends = [ base language-c ]; description = "A higher level DSL on top of language-c"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "c-enum" = callPackage @@ -48443,8 +45275,6 @@ self: { libraryHaskellDepends = [ base ]; description = "C IO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "c-mosquitto" = callPackage @@ -48465,8 +45295,6 @@ self: { testHaskellDepends = [ base ]; description = "Simpe mosquito MQTT binding able to work with the Amazons IoT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) mosquitto;}; "c-storable" = callPackage @@ -48503,8 +45331,6 @@ self: { executableHaskellDepends = [ base c0parser ]; description = "Simple C0 Syntax Check"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "c0parser" = callPackage @@ -48516,8 +45342,6 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "Simple C0 Parser"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "c10k" = callPackage @@ -48529,8 +45353,6 @@ self: { libraryHaskellDepends = [ base network unix ]; description = "C10k server library using prefork"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "c14n" = callPackage @@ -48566,8 +45388,6 @@ self: { ]; description = "Translate C code into ATS"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "c2hs" = callPackage @@ -48677,8 +45497,6 @@ self: { ]; description = "A maintenance command of Haskell cabal packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal" = callPackage @@ -48706,8 +45524,6 @@ self: { libraryHaskellDepends = [ base Cabal filepath ]; description = "Cabal support for creating AppImage applications"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-audit" = callPackage @@ -48725,8 +45541,6 @@ self: { ]; description = "Check how up-to-date your .cabal dependencies are."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-auto-expose" = callPackage @@ -48762,8 +45576,6 @@ self: { ]; description = "A command line program for managing the dependency versions in a cabal file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-build-programs" = callPackage @@ -48791,8 +45603,6 @@ self: { ]; description = "Bundling C/C++ projects in Cabal package made easy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-cache" = callPackage @@ -48828,8 +45638,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "CI Assistant for Haskell projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-cargs" = callPackage @@ -48852,8 +45660,6 @@ self: { testHaskellDepends = [ base filepath tasty tasty-golden ]; description = "A command line program for extracting compiler arguments from a cabal file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-constraints" = callPackage @@ -48867,8 +45673,6 @@ self: { executableHaskellDepends = [ base Cabal optparse-applicative ]; description = "Repeatable builds for cabalized Haskell projects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-db" = callPackage @@ -48888,8 +45692,6 @@ self: { ]; description = "query tools for the local cabal database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-debian" = callPackage @@ -48929,8 +45731,6 @@ self: { ]; description = "Compose a list of a project's transitive dependencies with their licenses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-dev" = callPackage @@ -48953,8 +45753,6 @@ self: { executableToolDepends = [ cabal-install ]; description = "Manage sandboxed Haskell build environments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-dir" = callPackage @@ -48968,8 +45766,6 @@ self: { executableHaskellDepends = [ base Cabal directory filepath ]; description = "show dist dir of 'cabal copy/install'"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-doctest" = callPackage @@ -49004,8 +45800,6 @@ self: { ]; description = "Cabal utility"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-file" = callPackage @@ -49044,8 +45838,6 @@ self: { testHaskellDepends = [ base Cabal ]; description = "Template Haskell expressions for reading fields from a project's cabal file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-flatpak" = callPackage @@ -49109,8 +45901,6 @@ self: { libraryHaskellDepends = [ base Cabal ghc transformers ]; description = "Conveniently configure GHC's dynamic flags for use with Cabal projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-ghci" = callPackage @@ -49127,8 +45917,6 @@ self: { ]; description = "Set up ghci with options taken from a .cabal file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-graphdeps" = callPackage @@ -49146,8 +45934,6 @@ self: { ]; description = "Generate graphs of install-time Cabal dependencies"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-helper" = callPackage @@ -49198,8 +45984,6 @@ self: { ]; description = "Read information from cabal files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-install" = callPackage @@ -49250,8 +46034,6 @@ self: { executableSystemDepends = [ zlib ]; description = "The (bundled) command-line interface for Cabal and Hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zlib;}; "cabal-install-ghc72" = callPackage @@ -49271,8 +46053,6 @@ self: { ]; description = "Temporary version of cabal-install for ghc-7.2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-install-ghc74" = callPackage @@ -49292,8 +46072,6 @@ self: { ]; description = "Temporary version of cabal-install for ghc-7.4"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-install-parsers" = callPackage @@ -49340,8 +46118,6 @@ self: { ]; description = "Lenses and traversals for the Cabal library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-macosx" = callPackage @@ -49389,8 +46165,6 @@ self: { ]; description = "build multiple packages at once"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-mon" = callPackage @@ -49408,8 +46182,6 @@ self: { ]; description = "A monitor for cabal builds"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-nirvana" = callPackage @@ -49427,8 +46199,6 @@ self: { ]; description = "Avoid Cabal dependency hell by constraining to known good versions. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-plan" = callPackage @@ -49469,8 +46239,6 @@ self: { executableHaskellDepends = [ base Cabal directory filepath ]; description = "Show dependencies of program being built in current directory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-query" = callPackage @@ -49487,8 +46255,6 @@ self: { ]; description = "Helpers for quering .cabal files or hackageDB's 00-index.tar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-rpm" = callPackage @@ -49536,8 +46302,6 @@ self: { executableHaskellDepends = [ base Cabal ]; description = "The user interface for building and installing Cabal packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-sign" = callPackage @@ -49574,8 +46338,6 @@ self: { ]; description = "Topologically sort cabal packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-src" = callPackage @@ -49597,8 +46359,6 @@ self: { ]; description = "Alternative install procedure to avoid the diamond dependency issue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-test" = callPackage @@ -49614,8 +46374,6 @@ self: { ]; description = "Automated test tool for cabal projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-test-bin" = callPackage @@ -49657,8 +46415,6 @@ self: { libraryHaskellDepends = [ base Cabal QuickCheck ]; description = "QuickCheck for Cabal"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal-toolkit" = callPackage @@ -49700,8 +46456,6 @@ self: { executableHaskellDepends = [ base filepath HTTP network ]; description = "Command-line tool for uploading packages to Hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal2arch" = callPackage @@ -49721,8 +46475,6 @@ self: { ]; description = "Create Arch Linux packages from Cabal packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal2doap" = callPackage @@ -49738,8 +46490,6 @@ self: { ]; description = "Cabal to Description-of-a-Project (DOAP)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal2ebuild" = callPackage @@ -49754,8 +46504,6 @@ self: { executableHaskellDepends = [ base curl directory ]; description = "make gentoo's .ebuild file from .cabal file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal2ghci" = callPackage @@ -49774,8 +46522,6 @@ self: { ]; description = "A tool to generate .ghci file from .cabal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabal2nix" = callPackage @@ -49853,8 +46599,6 @@ self: { ]; description = "A simple tool to query cabal files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabalg" = callPackage @@ -49889,8 +46633,6 @@ self: { ]; description = "Generate pretty graphs of module trees from cabal files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabalish" = callPackage @@ -49909,8 +46651,6 @@ self: { ]; description = "Provides access to the cabal file data for shell scripts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabalmdvrpm" = callPackage @@ -49925,8 +46665,6 @@ self: { executableHaskellDepends = [ base Cabal cabalrpmdeps haskell98 ]; description = "Create mandriva rpm from cabal package"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabalrpmdeps" = callPackage @@ -49941,8 +46679,6 @@ self: { executableHaskellDepends = [ base Cabal filepath haskell98 ]; description = "Autogenerate rpm dependencies from cabal files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabalvchk" = callPackage @@ -49956,8 +46692,6 @@ self: { executableHaskellDepends = [ base Cabal ]; description = "Verify installed package version against user-specified constraints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabin" = callPackage @@ -49976,8 +46710,6 @@ self: { ]; description = "Cabal binary sandboxes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cabocha" = callPackage @@ -49990,8 +46722,6 @@ self: { librarySystemDepends = [ cabocha ]; testHaskellDepends = [ base text-format ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {cabocha = null;}; "cache" = callPackage @@ -50026,8 +46756,6 @@ self: { ]; description = "cached hashmaps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cached" = callPackage @@ -50045,8 +46773,6 @@ self: { ]; description = "Cache values to disk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cached-io" = callPackage @@ -50094,8 +46820,6 @@ self: { ]; description = "Cache combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "caching-vault" = callPackage @@ -50112,8 +46836,6 @@ self: { ]; description = "A vault-style cache implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cachix" = callPackage @@ -50212,8 +46934,6 @@ self: { ]; description = "A library implementing the Noise protocol"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "caerbannog" = callPackage @@ -50252,8 +46972,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Prelude subsets—take only what you want!"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "caffegraph" = callPackage @@ -50272,8 +46990,6 @@ self: { protocol-buffers-descriptor template-haskell temporary text ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cairo" = callPackage @@ -50339,8 +47055,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Cairo Haskell binding (partial)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) cairo;}; "cake" = callPackage @@ -50363,8 +47077,6 @@ self: { ]; description = "A build-system library and driver"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cake3" = callPackage @@ -50394,8 +47106,6 @@ self: { ]; description = "Third cake the Makefile EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cakyrespa" = callPackage @@ -50413,8 +47123,6 @@ self: { ]; description = "run turtle like LOGO with lojban"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cal-layout" = callPackage @@ -50429,8 +47137,6 @@ self: { executableHaskellDepends = [ base ]; description = "Calendar Layout Algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cal3d" = callPackage @@ -50443,8 +47149,6 @@ self: { librarySystemDepends = [ cal3d ]; description = "Haskell binding to the Cal3D animation library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {cal3d = null;}; "cal3d-examples" = callPackage @@ -50459,8 +47163,6 @@ self: { executableHaskellDepends = [ base cal3d cal3d-opengl OpenGL SDL ]; description = "Examples for the Cal3d animation library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cal3d-opengl" = callPackage @@ -50472,8 +47174,6 @@ self: { libraryHaskellDepends = [ base cal3d OpenGL ]; description = "OpenGL rendering for the Cal3D animation library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "calamity" = callPackage @@ -50503,8 +47203,6 @@ self: { ]; description = "A library for writing discord bots in haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "calamity-commands" = callPackage @@ -50534,8 +47232,6 @@ self: { executableHaskellDepends = [ array base harpy haskell98 mtl ]; description = "A small compiler for arithmetic expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "calculator" = callPackage @@ -50557,8 +47253,6 @@ self: { ]; description = "A calculator repl, with variables, functions & Mathematica like dynamic plots"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "caldims" = callPackage @@ -50579,8 +47273,6 @@ self: { ]; description = "Calculation tool and library supporting units"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "caledon" = callPackage @@ -50598,8 +47290,6 @@ self: { ]; description = "a logic programming language based on the calculus of constructions"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "calendar-recycling" = callPackage @@ -50630,8 +47320,6 @@ self: { ]; description = "Commandline tool to get week of the year"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "call" = callPackage @@ -50657,8 +47345,6 @@ self: { ]; description = "The call game engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "call-alloy" = callPackage @@ -50680,8 +47366,6 @@ self: { ]; description = "A simple library to call Alloy given a specification"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "call-haskell-from-anything" = callPackage @@ -50700,8 +47384,6 @@ self: { executableHaskellDepends = [ base bytestring data-msgpack mtl ]; description = "Call Haskell functions from other languages via serialization and dynamic libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "call-stack" = callPackage @@ -50751,8 +47433,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "CamFort - Cambridge Fortran infrastructure"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) flint;}; "camh" = callPackage @@ -50785,8 +47465,6 @@ self: { ]; description = "Haskell implementation of the Campfire API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "can-i-haz" = callPackage @@ -50831,8 +47509,6 @@ self: { ]; description = "Candid integration"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canon" = callPackage @@ -50844,8 +47520,6 @@ self: { libraryHaskellDepends = [ arithmoi array base containers random ]; description = "Arithmetic for Psychedelically Large Numbers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canonical-filepath" = callPackage @@ -50857,8 +47531,6 @@ self: { libraryHaskellDepends = [ base deepseq directory filepath ]; description = "Abstract data type for canonical file paths"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canonical-json" = callPackage @@ -50882,8 +47554,6 @@ self: { benchmarkHaskellDepends = [ base bytestring containers criterion ]; description = "Canonical JSON for signing and hashing JSON values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canteven-config" = callPackage @@ -50914,8 +47584,6 @@ self: { ]; description = "Utilities for HTTP programming"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canteven-listen-http" = callPackage @@ -50927,8 +47595,6 @@ self: { libraryHaskellDepends = [ aeson base ]; description = "data types to describe HTTP services"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canteven-log" = callPackage @@ -50946,8 +47612,6 @@ self: { ]; description = "A canteven way of setting up logging for your program"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canteven-parsedate" = callPackage @@ -50963,8 +47627,6 @@ self: { ]; description = "Date / time parsing utilities that try to guess the date / time format"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "canteven-template" = callPackage @@ -51003,8 +47665,6 @@ self: { ]; description = "Application for analysis of java source code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cantor-pairing" = callPackage @@ -51043,8 +47703,6 @@ self: { executableToolDepends = [ alex happy ]; description = "CAO Compiler"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cap" = callPackage @@ -51059,8 +47717,6 @@ self: { executableHaskellDepends = [ array base containers haskell98 ]; description = "Interprets and debug the cap language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "capability" = callPackage @@ -51147,8 +47803,6 @@ self: { ]; description = "Cap'n Proto for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "capped-list" = callPackage @@ -51160,8 +47814,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A list-like type for lazy sequences, with a user-defined termination value"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "capri" = callPackage @@ -51177,8 +47829,6 @@ self: { ]; description = "A simple wrapper over cabal-install to operate in project-private mode"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "caps" = callPackage @@ -51217,8 +47867,6 @@ self: { ]; description = "Simple web-server for organizing car-pooling for an event"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "caramia" = callPackage @@ -51243,8 +47891,6 @@ self: { ]; description = "High-level OpenGL bindings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "carbonara" = callPackage @@ -51259,8 +47905,6 @@ self: { ]; description = "some spaghetti code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "carboncopy" = callPackage @@ -51278,8 +47922,6 @@ self: { ]; description = "Drop emails from threads being watched into special CC folder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cardano-coin-selection" = callPackage @@ -51301,8 +47943,6 @@ self: { ]; description = "Algorithms for coin selection and fee balancing"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cardano-transactions" = callPackage @@ -51359,8 +47999,6 @@ self: { ]; description = "A presentation tool written with Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "carray" = callPackage @@ -51396,8 +48034,6 @@ self: { ]; description = "Carte: A commandline pastebin server"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cartel" = callPackage @@ -51426,8 +48062,6 @@ self: { ]; description = "Specify Cabal files in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cas-hashable" = callPackage @@ -51509,8 +48143,6 @@ self: { ]; description = "CASA Abbreviations and Acronyms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "casa-client" = callPackage @@ -51572,8 +48204,6 @@ self: { ]; description = "mid-level bindings to CasADi"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {casadi = null;}; "casadi-bindings-control" = callPackage @@ -51590,8 +48220,6 @@ self: { libraryPkgconfigDepends = [ casadi_control ]; description = "low level bindings to casadi-control"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {casadi_control = null;}; "casadi-bindings-core" = callPackage @@ -51608,8 +48236,6 @@ self: { librarySystemDepends = [ casadi ]; description = "autogenerated low level bindings to casadi"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {casadi = null;}; "casadi-bindings-internal" = callPackage @@ -51622,8 +48248,6 @@ self: { librarySystemDepends = [ casadi ]; description = "low level bindings to CasADi"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {casadi = null;}; "casadi-bindings-ipopt-interface" = callPackage @@ -51640,8 +48264,6 @@ self: { libraryPkgconfigDepends = [ casadi_ipopt_interface ]; description = "low level bindings to casadi-ipopt_interface"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {casadi_ipopt_interface = null;}; "casadi-bindings-snopt-interface" = callPackage @@ -51658,8 +48280,6 @@ self: { libraryPkgconfigDepends = [ casadi_snopt_interface ]; description = "low level bindings to casadi-snopt_interface"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {casadi_snopt_interface = null;}; "cascading" = callPackage @@ -51676,8 +48296,6 @@ self: { ]; description = "DSL for HTML CSS (Cascading Style Sheets)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "case-conversion" = callPackage @@ -51754,8 +48372,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Combinators for casing on constructors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cases" = callPackage @@ -51771,8 +48387,6 @@ self: { benchmarkHaskellDepends = [ gauge mwc-random rerebase ]; description = "A converter for spinal, snake and camel cases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cash" = callPackage @@ -51789,8 +48403,6 @@ self: { ]; description = "the Computer Algebra SHell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "casing" = callPackage @@ -51997,8 +48609,6 @@ self: { ]; description = "Haskell client for Cassandra's CQL protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cassandra-thrift" = callPackage @@ -52058,8 +48668,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Conduit interface for cassava package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cassava-embed" = callPackage @@ -52134,8 +48742,6 @@ self: { ]; description = "Auto-generation of records data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cassava-streams" = callPackage @@ -52168,8 +48774,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A combinator library for simultaneously defining parsers and pretty printers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cassy" = callPackage @@ -52197,8 +48801,6 @@ self: { ]; description = "A high level driver for the Cassandra datastore"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cast" = callPackage @@ -52270,8 +48872,6 @@ self: { ]; description = "A tool to manage shared cabal-install sandboxes"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "casui" = callPackage @@ -52286,8 +48886,6 @@ self: { executableHaskellDepends = [ base gtk haskell98 mtl parsec ]; description = "Equation Manipulator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "catalyst" = callPackage @@ -52311,8 +48909,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Exposes a Template Haskell function for generating catamorphisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "catch-fd" = callPackage @@ -52324,8 +48920,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "MonadThrow and MonadCatch, using functional dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "categorical-algebra" = callPackage @@ -52337,8 +48931,6 @@ self: { libraryHaskellDepends = [ base newtype pointless-haskell void ]; description = "Categorical Monoids and Semirings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "categories" = callPackage @@ -52388,8 +48980,6 @@ self: { doHaddock = false; description = "A meta-package documenting various packages inspired by category theory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "category-printf" = callPackage @@ -52414,8 +49004,6 @@ self: { libraryHaskellDepends = [ base categories ]; description = "Traced monoidal categories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "catnplus" = callPackage @@ -52435,8 +49023,6 @@ self: { ]; description = "Simple tool to display text files with line numbers and paging"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cautious" = callPackage @@ -52466,8 +49052,6 @@ self: { ]; description = "Ways to write a file cautiously, to reduce the chances of problems such as data loss due to crashes or power failures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cautious-gen" = callPackage @@ -52484,8 +49068,6 @@ self: { hspec QuickCheck ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cayene-lpp" = callPackage @@ -52502,8 +49084,6 @@ self: { testHaskellDepends = [ base base16-bytestring hspec ]; description = "Cayenne Low Power Payload"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cayenne-lpp" = callPackage @@ -52541,8 +49121,6 @@ self: { testHaskellDepends = [ aeson base hspec unordered-containers ]; description = "A Haskell client for the Cayley graph database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cayley-dickson" = callPackage @@ -52679,8 +49257,6 @@ self: { ]; description = "Bindings for the CCI networking library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {cci = null;}; "ccnx" = callPackage @@ -52692,8 +49268,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A Haskell implementation of the CCNx network protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cctools-workqueue" = callPackage @@ -52710,8 +49284,6 @@ self: { librarySystemDepends = [ dttools ]; description = "High-level interface to CCTools' WorkQueue library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {dttools = null;}; "cdeps" = callPackage @@ -52750,8 +49322,6 @@ self: { ]; description = "Convenient Chinese phrase & character lookup"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cef" = callPackage @@ -52766,8 +49336,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "CEF log format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cef3-raw" = callPackage @@ -52781,8 +49349,6 @@ self: { libraryPkgconfigDepends = [ gtk2 ]; description = "Raw CEF3 bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {cef = null; inherit (pkgs) gtk2;}; "cef3-simple" = callPackage @@ -52794,8 +49360,6 @@ self: { libraryHaskellDepends = [ base cef3-raw ]; description = "Simple wrapper around cef3-raw"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ceilometer-common" = callPackage @@ -52819,8 +49383,6 @@ self: { ]; description = "Common Haskell types and encoding for OpenStack Ceilometer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cellrenderer-cairo" = callPackage @@ -52834,8 +49396,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Cairo-based CellRenderer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk2;}; "celtchar" = callPackage @@ -52860,8 +49420,6 @@ self: { testHaskellDepends = [ base hspec raw-strings-qq ]; description = "A tool to build a novel"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cerberus" = callPackage @@ -52889,8 +49447,6 @@ self: { testHaskellDepends = [ base ]; description = "Protect and control API access with cerberus"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cereal" = callPackage @@ -52952,8 +49508,6 @@ self: { libraryHaskellDepends = [ base cereal ghc-prim ]; description = "Automatic deriving of Serialize using GHC.Generics"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cereal-enumerator" = callPackage @@ -52965,8 +49519,6 @@ self: { libraryHaskellDepends = [ base bytestring cereal enumerator ]; description = "Deserialize things with cereal and enumerator"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cereal-ieee754" = callPackage @@ -52978,8 +49530,6 @@ self: { libraryHaskellDepends = [ array base cereal ]; description = "Floating point support for the 'cereal' serialization library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cereal-io-streams" = callPackage @@ -53002,8 +49552,6 @@ self: { ]; description = "io-streams support for the cereal binary serialization library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cereal-plus" = callPackage @@ -53027,8 +49575,6 @@ self: { ]; description = "An extended serialization library on top of \"cereal\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cereal-streams" = callPackage @@ -53051,8 +49597,6 @@ self: { ]; description = "Use cereal to encode/decode io-streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cereal-text" = callPackage @@ -53133,8 +49677,6 @@ self: { ]; description = "Certificates and Key Reader/Writer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cf" = callPackage @@ -53152,8 +49694,6 @@ self: { ]; description = "Exact real arithmetic using continued fractions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cfenv" = callPackage @@ -53170,8 +49710,6 @@ self: { ]; description = "A library getting the environment when running on Cloud Foundry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cfipu" = callPackage @@ -53189,8 +49727,6 @@ self: { ]; description = "cfipu processor for toy brainfuck-like language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cflp" = callPackage @@ -53209,8 +49745,6 @@ self: { ]; description = "Constraint Functional-Logic Programming in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cfopu" = callPackage @@ -53228,8 +49762,6 @@ self: { ]; description = "cfopu processor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cg" = callPackage @@ -53250,8 +49782,6 @@ self: { ]; description = "Parser for categorial grammars"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cgen" = callPackage @@ -53271,8 +49801,6 @@ self: { doHaddock = false; description = "generates Haskell bindings and C wrappers for C++ libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cgi" = callPackage @@ -53315,8 +49843,6 @@ self: { libraryHaskellDepends = [ base cgi containers mtl random ]; description = "Simple modular utilities for CGI/FastCGI (sessions, etc.)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cgrep" = callPackage @@ -53342,8 +49868,6 @@ self: { ]; description = "Command line tool"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chain-codes" = callPackage @@ -53382,8 +49906,6 @@ self: { ]; description = "Mining Client for Kadena Chainweb"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chakra" = callPackage @@ -53431,8 +49953,6 @@ self: { ]; description = "A REST Web Api server template for building (micro)services"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chalk" = callPackage @@ -53462,8 +49982,6 @@ self: { ]; description = "Combinators for building and processing 2D images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chalkboard-viewer" = callPackage @@ -53475,8 +49993,6 @@ self: { libraryHaskellDepends = [ array base chalkboard GLUT OpenGL time ]; description = "OpenGL based viewer for chalkboard rendered images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chalmers-lava2000" = callPackage @@ -53599,8 +50115,6 @@ self: { ]; description = "Exposes subspecies types of Char. And naming cases."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "charade" = callPackage @@ -53624,8 +50138,6 @@ self: { ]; description = "Rapid prototyping websites with Snap and Heist"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "charset" = callPackage @@ -53682,8 +50194,6 @@ self: { ]; description = "Command-line utility to draw charts from input data easily"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chart-histogram" = callPackage @@ -53695,8 +50205,6 @@ self: { libraryHaskellDepends = [ base Chart ]; description = "Easily render histograms with Chart"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chart-svg" = callPackage @@ -53726,8 +50234,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Charting library targetting SVGs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chart-svg-various" = callPackage @@ -53751,8 +50257,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chart-unit" = callPackage @@ -53777,8 +50281,6 @@ self: { ]; description = "Native haskell charts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "charter" = callPackage @@ -53806,8 +50308,6 @@ self: { process scientific text wai warp ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chaselev-deque" = callPackage @@ -53913,8 +50413,6 @@ self: { libraryHaskellDepends = [ base chatty transformers ]; description = "Provides some classes and types for dealing with text, using the fundaments of Chatty"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chatty-utils" = callPackage @@ -53954,8 +50452,6 @@ self: { ]; description = "The ChatWork API in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cheapskate" = callPackage @@ -54033,8 +50529,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "check-email" = callPackage @@ -54066,8 +50560,6 @@ self: { ]; description = "Check whether module and package imports conform to the PVP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "checked" = callPackage @@ -54081,8 +50573,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Bounds-checking integer types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "checkers" = callPackage @@ -54126,8 +50616,6 @@ self: { ]; description = "Generate checklists relevant to a given patch"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "checksum" = callPackage @@ -54179,8 +50667,6 @@ self: { libraryHaskellDepends = [ base chell QuickCheck random ]; description = "QuickCheck support for the Chell testing library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cherry-core-alpha" = callPackage @@ -54243,8 +50729,6 @@ self: { ]; description = "Basic chess library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chesshs" = callPackage @@ -54275,8 +50759,6 @@ self: { ]; description = "Query interface for Chevalier"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chiasma" = callPackage @@ -54312,8 +50794,6 @@ self: { ]; description = "tmux api"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chimera" = callPackage @@ -54353,8 +50833,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell bindings for Chipmunk2D physics engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chitauri" = callPackage @@ -54374,8 +50852,6 @@ self: { testHaskellDepends = [ base ]; description = "Helper for the Major System"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "choice" = callPackage @@ -54398,8 +50874,6 @@ self: { libraryHaskellDepends = [ base MonadRandom ]; description = "Choose random elements from a stream"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "choose-exe" = callPackage @@ -54416,8 +50890,6 @@ self: { ]; description = "Command-line program to choose random element from a stream"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chorale" = callPackage @@ -54435,8 +50907,6 @@ self: { ]; description = "A module containing basic functions that the prelude does not offer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chorale-geo" = callPackage @@ -54454,8 +50924,6 @@ self: { ]; description = "A module containing basic geo functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chp" = callPackage @@ -54471,8 +50939,6 @@ self: { ]; description = "An implementation of concurrency ideas from Communicating Sequential Processes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chp-mtl" = callPackage @@ -54484,8 +50950,6 @@ self: { libraryHaskellDepends = [ base chp chp-plus mtl ]; description = "MTL class instances for the CHP library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chp-plus" = callPackage @@ -54502,8 +50966,6 @@ self: { ]; description = "A set of high-level concurrency utilities built on Communicating Haskell Processes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chp-spec" = callPackage @@ -54519,8 +50981,6 @@ self: { ]; description = "A mirror implementation of chp that generates a specification of the program"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chp-transformers" = callPackage @@ -54532,8 +50992,6 @@ self: { libraryHaskellDepends = [ base chp chp-plus transformers ]; description = "Transformers instances for the CHP library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chr-core" = callPackage @@ -54550,8 +51008,6 @@ self: { ]; description = "Constraint Handling Rules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chr-data" = callPackage @@ -54589,8 +51045,6 @@ self: { executableHaskellDepends = [ base chr-data ]; description = "AST + surface language around chr"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chr-parse" = callPackage @@ -54604,8 +51058,6 @@ self: { libraryHaskellDepends = [ base containers uulib ]; description = "Parsing for chr library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chr-pretty" = callPackage @@ -54654,8 +51106,6 @@ self: { ]; description = "neovim package manager"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chronograph" = callPackage @@ -54669,8 +51119,6 @@ self: { ]; description = "measure timings of data evaluation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chronologique" = callPackage @@ -54763,8 +51211,6 @@ self: { benchmarkHaskellDepends = [ base ]; description = "Benchmarking tool with focus on comparing results"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chs-cabal" = callPackage @@ -54812,8 +51258,6 @@ self: { ]; description = "FFI for Chu2 Agda Web Server Interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chuchu" = callPackage @@ -54858,8 +51302,6 @@ self: { libraryHaskellDepends = [ base haskell98 parsec template-haskell ]; description = "Simple template library with static safety"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "chunky" = callPackage @@ -54875,8 +51317,6 @@ self: { testHaskellDepends = [ base binary bytestring HUnit text ]; description = "Human-readable storage of text/binary objects"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "church" = callPackage @@ -54888,8 +51328,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Automatically convert Generic instances to and from church representations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "church-list" = callPackage @@ -54913,8 +51351,6 @@ self: { libraryHaskellDepends = [ base deepseq semigroupoids semigroups ]; description = "Church encoded Maybe"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "church-pair" = callPackage @@ -54946,8 +51382,6 @@ self: { ]; description = "Channel/Arrow based streaming computation library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cielo" = callPackage @@ -54970,8 +51404,6 @@ self: { ]; description = "Cielo API v3 Bindings for Haskell"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cil" = callPackage @@ -54983,8 +51415,6 @@ self: { libraryHaskellDepends = [ base bytestring language-c ]; description = "An interface to CIL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cimple" = callPackage @@ -55017,8 +51447,6 @@ self: { librarySystemDepends = [ cinvoke ]; description = "A binding to cinvoke"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {cinvoke = null;}; "cio" = callPackage @@ -55030,8 +51458,6 @@ self: { libraryHaskellDepends = [ base monad-stm mtl parallel-io stm ]; description = "A monad for concurrent IO on a thread pool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cipher-aes" = callPackage @@ -55105,8 +51531,6 @@ self: { ]; description = "Blowfish cipher"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cipher-camellia" = callPackage @@ -55207,8 +51631,6 @@ self: { executableHaskellDepends = [ array base bytestring parseargs ]; description = "Implementation of CipherSaber2 RC4 cryptography"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "circ" = callPackage @@ -55250,8 +51672,6 @@ self: { ]; description = "The CircleCI REST API for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "circuit-breaker" = callPackage @@ -55297,8 +51717,6 @@ self: { benchmarkHaskellDepends = [ base criterion vector ]; description = "Circular fixed-sized mutable vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cirru-parser" = callPackage @@ -55361,8 +51779,6 @@ self: { ]; description = "convert document IDs such as DOI, ISBN, arXiv ID to bibliographic reference"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "citeproc" = callPackage @@ -55408,8 +51824,6 @@ self: { ]; description = "A Citation Style Language implementation in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "citeproc-hs-pandoc-filter" = callPackage @@ -55429,8 +51843,6 @@ self: { ]; description = "A Pandoc filter for processing bibliographic references with citeproc-hs"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cityhash" = callPackage @@ -55470,8 +51882,6 @@ self: { ]; description = "A new Haskeleton package"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cjk" = callPackage @@ -55489,8 +51899,6 @@ self: { testHaskellDepends = [ base ]; description = "Data about Chinese, Japanese and Korean characters and languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cl3" = callPackage @@ -55504,8 +51912,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Clifford Algebra of three dimensional space"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cl3-hmatrix-interface" = callPackage @@ -55517,8 +51923,6 @@ self: { libraryHaskellDepends = [ base cl3 hmatrix ]; description = "Interface to/from Cl3 and HMatrix"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cl3-linear-interface" = callPackage @@ -55530,8 +51934,6 @@ self: { libraryHaskellDepends = [ base cl3 linear ]; description = "Interface to/from Cl3 and Linear"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clac" = callPackage @@ -55550,8 +51952,6 @@ self: { ]; description = "Simple CLI RPN calculator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clafer" = callPackage @@ -55586,8 +51986,6 @@ self: { ]; description = "Compiles Clafer models to other formats: Alloy, JavaScript, JSON, HTML, Dot"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "claferIG" = callPackage @@ -55620,8 +52018,6 @@ self: { ]; description = "claferIG is an interactive tool that generates instances of Clafer models"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "claferwiki" = callPackage @@ -55641,8 +52037,6 @@ self: { ]; description = "A wiki-based IDE for literate modeling with Clafer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clang-compilation-database" = callPackage @@ -55655,8 +52049,6 @@ self: { testHaskellDepends = [ aeson base bytestring ]; description = "JSON Compilation Database Format encoding and decoding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clang-pure" = callPackage @@ -55679,8 +52071,6 @@ self: { testHaskellDepends = [ base bytestring lens ]; description = "Pure C++ code analysis with libclang"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (self.llvmPackages) clang;}; "clanki" = callPackage @@ -55696,8 +52086,6 @@ self: { ]; description = "Command-line spaced-repetition software"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clarifai" = callPackage @@ -55715,8 +52103,6 @@ self: { ]; description = "API Client for the Clarifai API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash" = callPackage @@ -55736,8 +52122,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware (CLaSH)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-ghc" = callPackage @@ -55767,8 +52151,6 @@ self: { executableHaskellDepends = [ base ]; description = "CAES Language for Synchronous Hardware"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-ghc_1_4_1" = callPackage @@ -55800,7 +52182,6 @@ self: { description = "Clash: a functional hardware description language - GHC frontend"; license = lib.licenses.bsd2; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-lib" = callPackage @@ -55840,8 +52221,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - As a Library"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-lib_1_4_1" = callPackage @@ -55885,7 +52264,6 @@ self: { description = "Clash: a functional hardware description language - As a library"; license = lib.licenses.bsd2; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-multisignal" = callPackage @@ -55900,8 +52278,6 @@ self: { base clash-prelude deepseq ghc-typelits-knownnat QuickCheck ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-prelude" = callPackage @@ -55940,8 +52316,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - Prelude library"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-prelude_1_4_1" = callPackage @@ -55983,7 +52357,6 @@ self: { description = "Clash: a functional hardware description language - Prelude library"; license = lib.licenses.bsd2; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-prelude-quickcheck" = callPackage @@ -56014,8 +52387,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - SystemVerilog backend"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-verilog" = callPackage @@ -56033,8 +52404,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - Verilog backend"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clash-vhdl" = callPackage @@ -56052,8 +52421,6 @@ self: { ]; description = "CAES Language for Synchronous Hardware - VHDL backend"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "classify" = callPackage @@ -56096,8 +52463,6 @@ self: { ]; description = "Classify sounds produced by Xenopus laevis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "classy-influxdb-simple" = callPackage @@ -56114,8 +52479,6 @@ self: { ]; description = "Super simple InfluxDB package in Classy-MTL style"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "classy-miso" = callPackage @@ -56136,8 +52499,6 @@ self: { testHaskellDepends = [ base miso rfc ]; description = "Typeclass based support for Miso, the Tasty Web Framework for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "classy-parallel" = callPackage @@ -56153,8 +52514,6 @@ self: { ]; description = "Fork of the monad-parallel package using monad-control"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "classy-prelude" = callPackage @@ -56232,8 +52591,6 @@ self: { benchmarkHaskellDepends = [ base criterion parallel uniplate ]; description = "Fuseable type-class based generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clay" = callPackage @@ -56281,8 +52638,6 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "A secure, reliable content management system (CMS) and blogging platform"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "clckwrks-cli" = callPackage @@ -56305,8 +52660,6 @@ self: { ]; description = "a command-line interface for adminstrating some aspects of clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-dot-com" = callPackage @@ -56328,8 +52681,6 @@ self: { executableToolDepends = [ hsx2hs ]; description = "clckwrks.com"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-plugin-bugs" = callPackage @@ -56355,8 +52706,6 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "bug tracking plugin for clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-plugin-ircbot" = callPackage @@ -56380,8 +52729,6 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "ircbot plugin for clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-plugin-mailinglist" = callPackage @@ -56406,8 +52753,6 @@ self: { ]; description = "mailing list plugin for clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-plugin-media" = callPackage @@ -56430,8 +52775,6 @@ self: { ]; description = "media plugin for clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-plugin-page" = callPackage @@ -56457,8 +52800,6 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "support for CMS/Blogging in clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-plugin-redirect" = callPackage @@ -56483,8 +52824,6 @@ self: { ]; description = "support redirects for CMS/Blogging in clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-theme-bootstrap" = callPackage @@ -56502,8 +52841,6 @@ self: { ]; description = "simple bootstrap based template for clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-theme-clckwrks" = callPackage @@ -56521,8 +52858,6 @@ self: { ]; description = "simple bootstrap based template for clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clckwrks-theme-geo-bootstrap" = callPackage @@ -56535,8 +52870,6 @@ self: { libraryHaskellDepends = [ base clckwrks hsp text ]; description = "geo bootstrap based template for clckwrks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cld2" = callPackage @@ -56548,8 +52881,6 @@ self: { libraryHaskellDepends = [ base bytestring hashable text ]; description = "Haskell bindings to Google's Compact Language Detector 2"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clean-home" = callPackage @@ -56578,8 +52909,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Open unions without need for Typeable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cless" = callPackage @@ -56598,8 +52927,6 @@ self: { ]; description = "Colorized LESS"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clevercss" = callPackage @@ -56614,8 +52941,6 @@ self: { executableHaskellDepends = [ parsec ]; description = "A CSS preprocessor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clexer" = callPackage @@ -56627,8 +52952,6 @@ self: { libraryHaskellDepends = [ base containers mtl parsec ]; description = "Lexes C++ code into simple tokens"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cli" = callPackage @@ -56661,8 +52984,6 @@ self: { testHaskellDepends = [ base doctest filemanip hspec QuickCheck ]; description = "Simple project template from stack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cli-extras" = callPackage @@ -56682,8 +53003,6 @@ self: { ]; description = "Miscellaneous utilities for building and working with command line interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cli-git" = callPackage @@ -56700,8 +53019,6 @@ self: { ]; description = "Bindings to the git command-line interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cli-nix" = callPackage @@ -56718,8 +53035,6 @@ self: { ]; description = "Bindings to the nix command-line interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cli-setup" = callPackage @@ -56786,8 +53101,6 @@ self: { ]; description = "A Haskell library as database client for Clickhouse"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clientsession" = callPackage @@ -56830,8 +53143,6 @@ self: { benchmarkHaskellDepends = [ base time ]; description = "A Clifford algebra number type for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clifford" = callPackage @@ -56864,8 +53175,6 @@ self: { ]; description = "A Clifford algebra library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clifm" = callPackage @@ -56885,8 +53194,6 @@ self: { ]; description = "Command Line Interface File Manager"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "climb" = callPackage @@ -56928,8 +53235,6 @@ self: { librarySystemDepends = [ clingo ]; description = "Haskell bindings to the Clingo ASP solver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) clingo;}; "clippard" = callPackage @@ -56941,8 +53246,6 @@ self: { libraryHaskellDepends = [ base process ]; description = "A simple Haskell library for copying text to the clipboard in a cross-platform way"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clipper" = callPackage @@ -56954,8 +53257,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell API to clipper (2d polygon union/intersection/xor/clipping API)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clippings" = callPackage @@ -56981,8 +53282,6 @@ self: { ]; description = "A parser/generator for Kindle-format clipping files (`My Clippings.txt`),"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clisparkline" = callPackage @@ -56995,8 +53294,6 @@ self: { testHaskellDepends = [ base ]; description = "Tiny library to pretty print sparklines onto the CLI"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clist" = callPackage @@ -57031,8 +53328,6 @@ self: { executableHaskellDepends = [ base ]; description = "Post tweets from stdin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cloben" = callPackage @@ -57105,8 +53400,6 @@ self: { libraryPkgconfigDepends = [ QtCore ]; description = "timer functionality to clock IO commands"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {QtCore = null;}; "clogparse" = callPackage @@ -57123,8 +53416,6 @@ self: { ]; description = "Parse IRC logs such as the #haskell logs on tunes.org"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clone-all" = callPackage @@ -57144,8 +53435,6 @@ self: { ]; description = "Clone all github repositories from a given user"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "closed" = callPackage @@ -57193,8 +53482,6 @@ self: { libraryHaskellDepends = [ base hashable unordered-containers ]; description = "Depth- and breadth-first set closures"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cloud-haskell" = callPackage @@ -57218,8 +53505,6 @@ self: { doHaddock = false; description = "The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cloud-seeder" = callPackage @@ -57248,8 +53533,6 @@ self: { ]; description = "A tool for interacting with AWS CloudFormation"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cloudfront-signer" = callPackage @@ -57266,8 +53549,6 @@ self: { ]; description = "CloudFront URL signer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cloudi" = callPackage @@ -57368,8 +53649,6 @@ self: { ]; description = "Quasiquoters for inline C# and F#"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clr-marshal" = callPackage @@ -57438,8 +53717,6 @@ self: { ]; description = "C to Lua data wrapper generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clumpiness" = callPackage @@ -57462,8 +53739,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "simple alternative to type classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clustering" = callPackage @@ -57489,8 +53764,6 @@ self: { ]; description = "High performance clustering algorithms"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clustertools" = callPackage @@ -57509,8 +53782,6 @@ self: { ]; description = "Tools for manipulating sequence clusters"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "clutterhs" = callPackage @@ -57528,8 +53799,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to the Clutter animation library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) clutter; inherit (pkgs) pango;}; "cmaes" = callPackage @@ -57615,8 +53884,6 @@ self: { ]; description = "Code highlighting for cmark"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmark-lucid" = callPackage @@ -57641,8 +53908,6 @@ self: { libraryHaskellDepends = [ base cmark ]; description = "Pattern synonyms for cmark"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmark-sections" = callPackage @@ -57661,8 +53926,6 @@ self: { ]; description = "Represent cmark-parsed Markdown as a tree of sections"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmath" = callPackage @@ -57674,8 +53937,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A binding to the standard C math library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmathml3" = callPackage @@ -57695,8 +53956,6 @@ self: { executableHaskellDepends = [ base Cabal filepath ]; description = "Data model, parser, serialiser and transformations for Content MathML 3"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmd-item" = callPackage @@ -57713,8 +53972,6 @@ self: { ]; description = "Library to compose and reuse command line fragments"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmdargs" = callPackage @@ -57765,8 +54022,6 @@ self: { libraryHaskellDepends = [ base mtl split syb transformers ]; description = "a library for command line parsing & online help"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmdtheline" = callPackage @@ -57788,8 +54043,6 @@ self: { ]; description = "Declarative command-line option parsing and documentation library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmf" = callPackage @@ -57802,8 +54055,6 @@ self: { testHaskellDepends = [ base containers hedgehog ]; description = "(C)oncurrent (M)onoidal (F)olds"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cml" = callPackage @@ -57826,8 +54077,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "A library for C-like programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmph" = callPackage @@ -57846,8 +54095,6 @@ self: { testSystemDepends = [ cmph ]; description = "low level interface to CMPH"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {cmph = null;}; "cmptype" = callPackage @@ -57862,8 +54109,6 @@ self: { ]; description = "Compare types of any kinds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmt" = callPackage @@ -57890,8 +54135,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Write consistent git commit messages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cmu" = callPackage @@ -57934,8 +54177,6 @@ self: { ]; description = "Detailed visualization of CMs, HMMs and their comparisions"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cnc-spec-compiler" = callPackage @@ -57957,8 +54198,6 @@ self: { ]; description = "Compiler/Translator for CnC Specification Files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cndict" = callPackage @@ -58050,8 +54289,6 @@ self: { executableHaskellDepends = [ base co-log-core polysemy ]; description = "Composable Contravariant Comonadic Logging Library"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "co-log-polysemy-formatting" = callPackage @@ -58075,8 +54312,6 @@ self: { ]; description = "A Polysemy logging effect for high quality (unstructured) logs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "co-log-sys" = callPackage @@ -58097,8 +54332,6 @@ self: { ]; description = "Syslog implementation on top of 'co-log-core'"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coalpit" = callPackage @@ -58117,8 +54350,6 @@ self: { ]; description = "Command-line options and DSV parsing and printing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cobot" = callPackage @@ -58167,8 +54398,6 @@ self: { ]; description = "Biological data file formats and IO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cobot-tools" = callPackage @@ -58192,8 +54421,6 @@ self: { ]; description = "Biological data file formats and IO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {RNA = null;}; "code-builder" = callPackage @@ -58205,8 +54432,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple system for generating code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "code-conjure" = callPackage @@ -58257,8 +54482,6 @@ self: { ]; description = "Simple bidirectional serialization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codec-beam" = callPackage @@ -58273,8 +54496,6 @@ self: { testHaskellDepends = [ base bytestring filepath process text ]; description = "Erlang VM byte code assembler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codec-libevent" = callPackage @@ -58297,8 +54518,6 @@ self: { ]; description = "Cross-platform structure serialisation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codec-mbox" = callPackage @@ -58333,8 +54552,6 @@ self: { ]; description = "A library for manipulating RPM files"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codecov-haskell" = callPackage @@ -58358,8 +54575,6 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Codecov.io support for Haskell."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codemonitor" = callPackage @@ -58378,8 +54593,6 @@ self: { ]; description = "Tool that automatically runs arbitrary commands when files change on disk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codepad" = callPackage @@ -58393,8 +54606,6 @@ self: { libraryHaskellDepends = [ base curl mtl network tagsoup ]; description = "Submit and retrieve paste output from CodePad.org."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codeworld-api" = callPackage @@ -58424,8 +54635,6 @@ self: { ]; description = "Graphics library for CodeWorld"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codex" = callPackage @@ -58451,8 +54660,6 @@ self: { ]; description = "A ctags file generator for cabal project dependencies"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "codo-notation" = callPackage @@ -58468,8 +54675,6 @@ self: { ]; description = "A notation for comonads, analogous to the do-notation for monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coerce-role" = callPackage @@ -58521,8 +54726,6 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "Utility functions for Coercible types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coercion-extras" = callPackage @@ -58634,8 +54837,6 @@ self: { ]; description = "Simple account manager"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coinbase-exchange" = callPackage @@ -58674,8 +54875,6 @@ self: { ]; description = "Connector library for the coinbase exchange"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coinbase-pro" = callPackage @@ -58708,8 +54907,6 @@ self: { ]; description = "Client for Coinbase Pro"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coincident-root-loci" = callPackage @@ -58728,8 +54925,6 @@ self: { ]; description = "Equivariant CSM classes of coincident root loci"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colada" = callPackage @@ -58753,8 +54948,6 @@ self: { ]; description = "Colada implements incremental word class class induction using online LDA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colchis" = callPackage @@ -58772,8 +54965,6 @@ self: { ]; description = "Rudimentary JSON-RPC 2.0 client over raw TCP."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cold-widow" = callPackage @@ -58806,8 +54997,6 @@ self: { ]; description = "Generate animated 3d objects in COLLADA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "collada-types" = callPackage @@ -58841,8 +55030,6 @@ self: { ]; description = "Collapse the duplication output into clones and return their frequencies"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "collapse-util" = callPackage @@ -58856,8 +55043,6 @@ self: { executableHaskellDepends = [ base ]; description = "utility for collapsing adjacent writes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "collect-errors" = callPackage @@ -58891,8 +55076,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Collection+JSON—Hypermedia Type Tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "collections" = callPackage @@ -58906,8 +55089,6 @@ self: { ]; description = "Useful standard collections types and related functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "collections-api" = callPackage @@ -58921,8 +55102,6 @@ self: { libraryHaskellDepends = [ array base QuickCheck ]; description = "API for collection data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "collections-base-instances" = callPackage @@ -58938,8 +55117,6 @@ self: { ]; description = "Useful standard collections types and related functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colock" = callPackage @@ -58972,8 +55149,6 @@ self: { ]; description = "Generic types and functions for columnar encoding and decoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "color-counter" = callPackage @@ -58998,8 +55173,6 @@ self: { ]; description = "Count colors in images"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colorful-monoids" = callPackage @@ -59048,8 +55221,6 @@ self: { ]; description = "Colorless | The Programmatic IDL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colorless-http-client" = callPackage @@ -59066,8 +55237,6 @@ self: { ]; description = "Http Client addon for Colorless"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colorless-scotty" = callPackage @@ -59081,8 +55250,6 @@ self: { ]; description = "Scotty server add-on for Colorless"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colors" = callPackage @@ -59141,8 +55308,6 @@ self: { ]; description = "Instances of the manifold-classes for colour types"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "colourista" = callPackage @@ -59175,8 +55340,6 @@ self: { ]; description = "A jazzy, minimal web framework for Haskell, inspired by Sinatra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "columbia" = callPackage @@ -59197,8 +55360,6 @@ self: { doHaddock = false; description = "Enhanced serialization using seeking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "columnar" = callPackage @@ -59216,8 +55377,6 @@ self: { ]; description = "A CSV toolkit based on cassava and enum-text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "com" = callPackage @@ -59229,8 +55388,6 @@ self: { doHaddock = false; description = "Haskell COM support library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "comark" = callPackage @@ -59309,8 +55466,6 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "Definitions of AST that represents a Commonmark (markdown) document"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "combinat" = callPackage @@ -59332,8 +55487,6 @@ self: { ]; description = "Generate and manipulate various combinatorial objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "combinat-compat" = callPackage @@ -59369,8 +55522,6 @@ self: { ]; description = "Graphical representations for various combinatorial objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "combinator-interactive" = callPackage @@ -59392,8 +55543,6 @@ self: { ]; description = "SKI Combinator interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "combinatorial" = callPackage @@ -59427,8 +55576,6 @@ self: { ]; description = "A number of data structures to represent and allow the manipulation of standard combinatorial problems, used as test problems in computer science"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "combinatorics" = callPackage @@ -59455,8 +55602,6 @@ self: { ]; description = "Various buffer implementations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "comfort-array" = callPackage @@ -59514,8 +55659,6 @@ self: { ]; description = "A format for describing comics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "comma" = callPackage @@ -59571,8 +55714,6 @@ self: { testHaskellDepends = [ base ]; description = "pattern matching against string based commands"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "commander-cli" = callPackage @@ -59624,8 +55765,6 @@ self: { ]; description = "Library for working with commoditized amounts and price histories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "commonmark" = callPackage @@ -59722,8 +55861,6 @@ self: { ]; description = "Provide communications security using symmetric ephemeral keys"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "commsec-keyexchange" = callPackage @@ -59742,8 +55879,6 @@ self: { ]; description = "Key agreement for commsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "commutative" = callPackage @@ -59854,8 +55989,6 @@ self: { testHaskellDepends = [ base ]; description = "An append only list in a compact region"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compact-map" = callPackage @@ -59869,8 +56002,6 @@ self: { ]; description = "Compact Data.Map implementation using Data.Binary"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compact-mutable" = callPackage @@ -59890,8 +56021,6 @@ self: { ]; description = "Mutable arrays living on the compact heap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compact-mutable-vector" = callPackage @@ -59905,8 +56034,6 @@ self: { testHaskellDepends = [ base compact hspec ]; description = "Mutable vector with different GC characteristics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compact-sequences" = callPackage @@ -59937,8 +56064,6 @@ self: { ]; description = "Socket functions for compact normal form"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compact-string" = callPackage @@ -59952,8 +56077,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Fast, packed and strict strings with Unicode support, based on bytestrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compact-string-fix" = callPackage @@ -59967,8 +56090,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Same as compact-string except with a small fix so it builds on ghc-6.12"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compact-word-vectors" = callPackage @@ -59985,8 +56106,6 @@ self: { ]; description = "Small vectors of small integers stored very compactly"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compactable" = callPackage @@ -59998,8 +56117,6 @@ self: { libraryHaskellDepends = [ base containers transformers vector ]; description = "A typeclass for structures which can be catMaybed, filtered, and partitioned"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compactmap" = callPackage @@ -60050,8 +56167,6 @@ self: { ]; description = "Compositional Data Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compdata-automata" = callPackage @@ -60067,8 +56182,6 @@ self: { ]; description = "Tree automata on Compositional Data Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compdata-dags" = callPackage @@ -60090,8 +56203,6 @@ self: { ]; description = "Compositional Data Types on DAGs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compdata-fixplate" = callPackage @@ -60127,8 +56238,6 @@ self: { ]; description = "Parametric Compositional Data Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compdoc" = callPackage @@ -60180,8 +56289,6 @@ self: { ]; description = "Client for the Compendium schema server"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compensated" = callPackage @@ -60211,8 +56318,6 @@ self: { libraryHaskellDepends = [ base filepath parsec ]; description = "Helpers and runners for code competitions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compilation" = callPackage @@ -60224,8 +56329,6 @@ self: { libraryHaskellDepends = [ base MissingH ]; description = "Haskell functionality for quickly assembling simple compilers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compiler-warnings" = callPackage @@ -60255,8 +56358,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "complex numbers with non-mandatory RealFloat"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "complex-integrate" = callPackage @@ -60284,8 +56385,6 @@ self: { ]; description = "Empirical algorithmic complexity"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "componentm" = callPackage @@ -60373,8 +56472,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Composable monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "composite-aeson" = callPackage @@ -60553,8 +56650,6 @@ self: { ]; description = "Opaleye SQL for Vinyl records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "composite-swagger" = callPackage @@ -60576,8 +56671,6 @@ self: { ]; description = "Swagger for Vinyl records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "composite-tuple" = callPackage @@ -60644,8 +56737,6 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "Composition trees for arbitrary monoids"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compositional-data" = callPackage @@ -60693,8 +56784,6 @@ self: { testHaskellDepends = [ base ]; description = "Plugin to generalize comprehensions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compressed" = callPackage @@ -60714,8 +56803,6 @@ self: { ]; description = "Compressed containers and reducers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "compression" = callPackage @@ -60743,8 +56830,6 @@ self: { ]; description = "Strategy combinators for compositional data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "comptrans" = callPackage @@ -60762,8 +56847,6 @@ self: { ]; description = "Automatically converting ASTs into compositional data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "computational-algebra" = callPackage @@ -60815,8 +56898,6 @@ self: { ]; description = "Well-kinded computational algebra library, currently supporting Groebner basis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "computational-geometry" = callPackage @@ -60833,8 +56914,6 @@ self: { ]; description = "Collection of algorithms in Computational Geometry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "computations" = callPackage @@ -60846,8 +56925,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Advanced notions of computation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concatenative" = callPackage @@ -60925,8 +57002,6 @@ self: { ]; description = "Morphological disambiguation based on constrained CRFs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concraft-hr" = callPackage @@ -60948,8 +57023,6 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "Part-of-speech tagger for Croatian"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concraft-pl" = callPackage @@ -60978,8 +57051,6 @@ self: { ]; description = "Morphological tagger for Polish"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concrete-haskell" = callPackage @@ -61023,8 +57094,6 @@ self: { ]; description = "Library for the Concrete data format"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concrete-haskell-autogen" = callPackage @@ -61041,8 +57110,6 @@ self: { ]; description = "Automatically generated Thrift definitions for the Concrete data format"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concrete-relaxng-parser" = callPackage @@ -61062,8 +57129,6 @@ self: { ]; description = "A parser driven by a standard RELAX NG schema with concrete syntax extensions"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concrete-typerep" = callPackage @@ -61083,8 +57148,6 @@ self: { ]; description = "Binary and Hashable instances for TypeRep"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concur-core" = callPackage @@ -61138,8 +57201,6 @@ self: { ]; description = "Benchmarks to compare concurrency APIs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concurrent-barrier" = callPackage @@ -61181,8 +57242,6 @@ self: { benchmarkHaskellDepends = [ bug criterion rerebase ]; description = "Concurrent expanding buffer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concurrent-dns-cache" = callPackage @@ -61271,8 +57330,6 @@ self: { benchmarkHaskellDepends = [ base machines time ]; description = "Concurrent networked stream transducers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concurrent-output" = callPackage @@ -61358,8 +57415,6 @@ self: { libraryHaskellDepends = [ base exceptions mtl stm transformers ]; description = "MTL-like library using TVars"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "concurrent-supply" = callPackage @@ -61430,8 +57485,6 @@ self: { ]; description = "Information retrieval library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "condorcet" = callPackage @@ -61443,8 +57496,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Library for Condorcet voting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conductive-base" = callPackage @@ -61456,8 +57507,6 @@ self: { libraryHaskellDepends = [ array base containers random stm time ]; description = "a library for live coding and real-time musical applications"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conductive-clock" = callPackage @@ -61485,8 +57534,6 @@ self: { ]; description = "a library with examples of using Conductive with hsc3"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conductive-song" = callPackage @@ -61498,8 +57545,6 @@ self: { libraryHaskellDepends = [ base conductive-base random ]; description = "a library of functions which are useful for composing music"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduino" = callPackage @@ -61611,8 +57656,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "conduit-audio interface to the LAME MP3 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {mp3lame = null;}; "conduit-audio-samplerate" = callPackage @@ -61632,8 +57675,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "conduit-audio interface to the libsamplerate resampling library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {samplerate = null;}; "conduit-audio-sndfile" = callPackage @@ -61760,8 +57801,6 @@ self: { ]; description = "A file-finding conduit that allows user control over traversals"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-iconv" = callPackage @@ -61782,8 +57821,6 @@ self: { ]; description = "Conduit for character encoding conversion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-merge" = callPackage @@ -61810,8 +57847,6 @@ self: { ]; description = "A base layer for network protocols using Conduits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-parse" = callPackage @@ -61850,8 +57885,6 @@ self: { ]; description = "Allows conduit to resume sinks to feed multiple sources into it"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-throttle" = callPackage @@ -61875,8 +57908,6 @@ self: { ]; description = "Throttle Conduit Producers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-tokenize-attoparsec" = callPackage @@ -61896,8 +57927,6 @@ self: { testHaskellDepends = [ attoparsec base conduit hspec resourcet ]; description = "Conduits for tokenizing streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-vfs" = callPackage @@ -61922,8 +57951,6 @@ self: { ]; description = "Virtual file system for Conduit; disk, pure, and in-memory impls"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-vfs-zip" = callPackage @@ -61950,8 +57977,6 @@ self: { ]; description = "Zip archive interface for the Conduit Virtual File System"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conduit-zstd" = callPackage @@ -61986,8 +58011,6 @@ self: { ]; description = "Parser for Haskell-based configuration files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conf-json" = callPackage @@ -62039,8 +58062,6 @@ self: { text transformers ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer" = callPackage @@ -62104,8 +58125,6 @@ self: { ]; description = "Configuration for reading dhall files"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-hedis" = callPackage @@ -62150,8 +58169,6 @@ self: { ]; description = "Configuration for reading dhall files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-provider-json" = callPackage @@ -62172,8 +58189,6 @@ self: { ]; description = "conferer's provider for reading json files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-provider-yaml" = callPackage @@ -62192,8 +58207,6 @@ self: { ]; description = "Configuration for reading yaml files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-snap" = callPackage @@ -62214,8 +58227,6 @@ self: { ]; description = "conferer's FromConfig instances for snap Config"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-source-dhall" = callPackage @@ -62236,8 +58247,6 @@ self: { ]; description = "Configuration for reading dhall files"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-source-json" = callPackage @@ -62258,8 +58267,6 @@ self: { ]; description = "conferer's source for reading json files"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-source-yaml" = callPackage @@ -62277,8 +58284,6 @@ self: { ]; description = "Configuration for reading yaml files"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conferer-warp" = callPackage @@ -62346,8 +58351,6 @@ self: { ]; description = "A .conf file formatter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "confide" = callPackage @@ -62362,8 +58365,6 @@ self: { testHaskellDepends = [ base deiko-config tasty tasty-hunit text ]; description = "derive typeclass instances for decoding types from HOCON conf"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "config-ini" = callPackage @@ -62417,8 +58418,6 @@ self: { testHaskellDepends = [ base extra hspec lens parsec text ]; description = "Parse config files using parsec and generate parse errors on unhandled keys"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "config-schema" = callPackage @@ -62454,8 +58453,6 @@ self: { ]; description = "A small program for swapping out dot files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "config-value" = callPackage @@ -62486,8 +58483,6 @@ self: { libraryHaskellDepends = [ base config-value text ]; description = "Interface between config-value and System.GetOpt"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "configifier" = callPackage @@ -62516,8 +58511,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "parser for config files, shell variables, command line args"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "configuration" = callPackage @@ -62529,8 +58522,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple data type for application configuration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "configuration-tools" = callPackage @@ -62626,8 +58617,6 @@ self: { ]; description = "The next generation of configuration management"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "configurator-pg" = callPackage @@ -62666,8 +58655,6 @@ self: { ]; description = "A command line tool for resolving conflicts of file synchronizers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "congruence-relation" = callPackage @@ -62679,8 +58666,6 @@ self: { libraryHaskellDepends = [ array base containers ]; description = "Decidable congruence relations for Haskell: up to you whether this is a joke"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conjugateGradient" = callPackage @@ -62712,8 +58697,6 @@ self: { ]; description = "A BitTorrent client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conkin" = callPackage @@ -62731,8 +58714,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Tools for functors from Hask^k to Hask"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "conlogger" = callPackage @@ -62747,8 +58728,6 @@ self: { executableHaskellDepends = [ base text ]; description = "A logger for a concurrent program"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "connection" = callPackage @@ -62801,8 +58780,6 @@ self: { testHaskellDepends = [ base doctest text ]; description = "A library for parsing connection strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "connections" = callPackage @@ -62818,8 +58795,6 @@ self: { testHaskellDepends = [ base hedgehog ]; description = "Orders, Galois connections, and lattices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "consistent" = callPackage @@ -62837,8 +58812,6 @@ self: { testHaskellDepends = [ base lifted-async transformers ]; description = "Eventually consistent STM transactions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "console-program" = callPackage @@ -62856,8 +58829,6 @@ self: { ]; description = "Interpret the command line and a config file as commands and options"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "console-prompt" = callPackage @@ -62903,8 +58874,6 @@ self: { testHaskellDepends = [ base directory process ]; description = "Compiler plugin for constant math elimination"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constaparser" = callPackage @@ -62927,8 +58896,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Equality by only Constructor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constrained" = callPackage @@ -62955,8 +58922,6 @@ self: { ]; description = "Constrained clones of the category-theory type classes, using ConstraintKinds"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constrained-category" = callPackage @@ -62976,8 +58941,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Constrained Categories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constrained-dynamic" = callPackage @@ -62990,8 +58953,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Dynamic typing with retained constraints"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constrained-monads" = callPackage @@ -63015,8 +58976,6 @@ self: { ]; description = "Typeclasses and instances for monads with constraints"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constrained-normal" = callPackage @@ -63078,8 +59037,6 @@ self: { libraryHaskellDepends = [ base indextype ]; description = "Some conviencience type functions for manipulating constraints"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constraint-reflection" = callPackage @@ -63156,8 +59113,6 @@ self: { testHaskellDepends = [ base constraints hspec transformers ]; description = "Defer instance lookups until runtime"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constraints-extras" = callPackage @@ -63224,8 +59179,6 @@ self: { ]; description = "Exact computation with constructible real numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "constructive-algebra" = callPackage @@ -63237,8 +59190,6 @@ self: { libraryHaskellDepends = [ base QuickCheck type-level ]; description = "A library of constructive algebra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "consul-haskell" = callPackage @@ -63263,8 +59214,6 @@ self: { ]; description = "A consul client for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "consumers" = callPackage @@ -63291,8 +59240,6 @@ self: { ]; description = "Concurrent PostgreSQL data consumers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "container" = callPackage @@ -63306,8 +59253,6 @@ self: { ]; description = "Containers abstraction and utilities"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "container-builder" = callPackage @@ -63378,8 +59323,6 @@ self: { ]; description = "Extensive benchmark suite for containers package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "containers-deepseq" = callPackage @@ -63413,8 +59356,6 @@ self: { libraryHaskellDepends = [ containers ]; description = "Formally verified drop-in replacement of containers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "content-store" = callPackage @@ -63439,8 +59380,6 @@ self: { ]; description = "Store and retrieve data from an on-disk store"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "context" = callPackage @@ -63502,8 +59441,6 @@ self: { ]; description = "Basic algorithms on context-free grammars"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "context-http-client" = callPackage @@ -63548,8 +59485,6 @@ self: { ]; description = "An abstraction of a stack and stack-based monadic context"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "context-wai-middleware" = callPackage @@ -63591,8 +59526,6 @@ self: { ]; description = "Unified interface for primitive arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "contiguous-checked" = callPackage @@ -63604,8 +59537,6 @@ self: { libraryHaskellDepends = [ base contiguous primitive ]; description = "contiguous with bounds checks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "contiguous-fft" = callPackage @@ -63617,8 +59548,6 @@ self: { libraryHaskellDepends = [ base contiguous primitive semirings ]; description = "dft of contiguous memory structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "continue" = callPackage @@ -63635,8 +59564,6 @@ self: { ]; description = "Monads with suspension and arbitrary-spot reentry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "continued-fraction" = callPackage @@ -63683,8 +59610,6 @@ self: { base bytestring cereal containers mtl nanomsg-haskell time ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "continuum-client" = callPackage @@ -63699,8 +59624,6 @@ self: { base bytestring cereal containers mtl nanomsg-haskell time ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "contra-tracer" = callPackage @@ -63771,8 +59694,6 @@ self: { ]; description = "Class of monad transformers which control operations can be lifted thru"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "control-bool" = callPackage @@ -63840,8 +59761,6 @@ self: { ]; description = "A typeclass for type isomorphisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "control-monad-attempt" = callPackage @@ -63853,8 +59772,6 @@ self: { libraryHaskellDepends = [ attempt base transformers ]; description = "Monad transformer for attempt. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "control-monad-exception" = callPackage @@ -63886,8 +59803,6 @@ self: { ]; description = "Monads-fd instances for the EMT exceptions monad transformer"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "control-monad-exception-monadstf" = callPackage @@ -63926,8 +59841,6 @@ self: { libraryHaskellDepends = [ base failure transformers ]; description = "A class for monads which can fail with an error. (deprecated)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "control-monad-failure-mtl" = callPackage @@ -63939,8 +59852,6 @@ self: { libraryHaskellDepends = [ base failure mtl ]; description = "A class for monads which can fail with an error for mtl 1 (deprecated)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "control-monad-free" = callPackage @@ -64018,8 +59929,6 @@ self: { libraryHaskellDepends = [ base contstuff monads-tf ]; description = "ContStuff instances for monads-tf transformers (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "contstuff-transformers" = callPackage @@ -64031,8 +59940,6 @@ self: { libraryHaskellDepends = [ base contstuff transformers ]; description = "Deprecated interface between contstuff 0.7.0 and the transformers package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "converge" = callPackage @@ -64115,8 +60022,6 @@ self: { ]; description = "Injective explicit total and partial conversions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "convert" = callPackage @@ -64134,8 +60039,6 @@ self: { ]; description = "Safe and unsafe data conversion utilities with strong type-level operation. checking."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "convert-annotation" = callPackage @@ -64159,8 +60062,6 @@ self: { ]; description = "Convert the annotation of a gene to another in a delimited file using a variety of different databases"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "convertible" = callPackage @@ -64194,8 +60095,6 @@ self: { ]; description = "convertible instances for ascii"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "convertible-text" = callPackage @@ -64216,8 +60115,6 @@ self: { ]; description = "Typeclasses and instances for converting between types (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cookbook" = callPackage @@ -64262,8 +60159,6 @@ self: { ]; description = "web cookies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coordinate" = callPackage @@ -64276,8 +60171,6 @@ self: { testHaskellDepends = [ base HUnit lens ]; description = "A representation of latitude and longitude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copilot" = callPackage @@ -64297,8 +60190,6 @@ self: { ]; description = "A stream DSL for writing embedded C programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copilot-c99" = callPackage @@ -64321,8 +60212,6 @@ self: { ]; description = "A compiler for Copilot targeting C99"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copilot-cbmc" = callPackage @@ -64339,8 +60228,6 @@ self: { ]; description = "Copilot interface to a C model-checker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copilot-core" = callPackage @@ -64368,8 +60255,6 @@ self: { ]; description = "A Haskell-embedded DSL for monitoring hard real-time distributed systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copilot-libraries" = callPackage @@ -64385,8 +60270,6 @@ self: { ]; description = "Libraries for the Copilot language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copilot-sbv" = callPackage @@ -64402,8 +60285,6 @@ self: { ]; description = "A compiler for CoPilot targeting SBV"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copilot-theorem" = callPackage @@ -64423,8 +60304,6 @@ self: { ]; description = "k-induction for Copilot"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "copr" = callPackage @@ -64444,8 +60323,6 @@ self: { testHaskellDepends = [ base hlint ]; description = "Haskell interface to the Fedora Copr system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coquina" = callPackage @@ -64483,8 +60360,6 @@ self: { libraryHaskellDepends = [ base bytestring parsec pretty ]; description = "External core parser and pretty printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "core-compiler" = callPackage @@ -64536,8 +60411,6 @@ self: { ]; description = "A subset of Haskell using in UCC for teaching purpose"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "core-program" = callPackage @@ -64602,8 +60475,6 @@ self: { ]; description = "A bliki written using yesod. Uses pandoc to process files stored in git."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "corecursive-main" = callPackage @@ -64641,8 +60512,6 @@ self: { librarySystemDepends = [ rocksdb ]; description = "Launches CoreNLP and parses the JSON output"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) rocksdb;}; "cornea" = callPackage @@ -64675,8 +60544,6 @@ self: { libraryHaskellDepends = [ base enumerator monad-coroutine ]; description = "Bridge between the monad-coroutine and enumerator packages"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coroutine-iteratee" = callPackage @@ -64688,8 +60555,6 @@ self: { libraryHaskellDepends = [ base iteratee monad-coroutine ]; description = "Bridge between the monad-coroutine and iteratee packages"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coroutine-object" = callPackage @@ -64701,8 +60566,6 @@ self: { libraryHaskellDepends = [ base either free mtl transformers ]; description = "Object-oriented programming realization using coroutine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "couch-hs" = callPackage @@ -64721,8 +60584,6 @@ self: { ]; description = "A CouchDB view server for Haskell"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "couch-simple" = callPackage @@ -64779,8 +60640,6 @@ self: { ]; description = "Couch DB client library using http-conduit and aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "couchdb-enumerator" = callPackage @@ -64808,8 +60667,6 @@ self: { ]; description = "Couch DB client library using http-enumerator and aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "count" = callPackage @@ -64853,8 +60710,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck text ]; description = "Countable Text Inflections"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "counter" = callPackage @@ -64866,8 +60721,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "An object frequency counter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "country" = callPackage @@ -64904,8 +60757,6 @@ self: { testHaskellDepends = [ aeson base HTF HUnit ]; description = "ISO 3166 country codes and i18n names"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "courier" = callPackage @@ -64930,8 +60781,6 @@ self: { ]; description = "A message-passing library for simplifying network applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "court" = callPackage @@ -64951,8 +60800,6 @@ self: { ]; description = "Simple and flexible CI system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coverage" = callPackage @@ -64965,8 +60812,6 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck ]; description = "Exhaustivity Checking Library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "coya" = callPackage @@ -64996,8 +60841,6 @@ self: { ]; description = "A simple C++ parser with preprocessor features. C++ refactorings included."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cpio-conduit" = callPackage @@ -65017,8 +60860,6 @@ self: { ]; description = "Conduit-based CPIO"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cpkg" = callPackage @@ -65049,8 +60890,6 @@ self: { testHaskellDepends = [ base hspec hspec-megaparsec megaparsec ]; description = "Build tool for C"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cplex-hs" = callPackage @@ -65085,8 +60924,6 @@ self: { testHaskellDepends = [ base process QuickCheck ]; description = "C++ Foreign Import Generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cppfilt" = callPackage @@ -65151,8 +60988,6 @@ self: { ]; description = "Run random effect using cprng-aes, a crypto pseudo number generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cps-except" = callPackage @@ -65229,8 +61064,6 @@ self: { executableHaskellDepends = [ base mtl process ]; description = "Modify the cpu frequency on OpenBSD systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cpython" = callPackage @@ -65246,8 +61079,6 @@ self: { testPkgconfigDepends = [ python3 ]; description = "Bindings for libpython"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {python3 = null;}; "cql" = callPackage @@ -65297,8 +61128,6 @@ self: { doHaddock = false; description = "Cassandra CQL client"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cql-io-tinylog" = callPackage @@ -65310,8 +61139,6 @@ self: { libraryHaskellDepends = [ base bytestring cql-io tinylog ]; description = "Tinylog integration for cql-io"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs" = callPackage @@ -65340,8 +61167,6 @@ self: { ]; description = "Command-Query Responsibility Segregation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs-example" = callPackage @@ -65363,8 +61188,6 @@ self: { ]; description = "Example for cqrs package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs-memory" = callPackage @@ -65381,8 +61204,6 @@ self: { testHaskellDepends = [ base cqrs-core cqrs-testkit hspec random ]; description = "Memory backend for the cqrs package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs-postgresql" = callPackage @@ -65406,8 +61227,6 @@ self: { ]; description = "PostgreSQL backend for the cqrs package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs-sqlite3" = callPackage @@ -65428,8 +61247,6 @@ self: { ]; description = "SQLite3 backend for the cqrs package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs-test" = callPackage @@ -65446,8 +61263,6 @@ self: { ]; description = "Command-Query Responsibility Segregation Test Support"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs-testkit" = callPackage @@ -65465,8 +61280,6 @@ self: { ]; description = "Command-Query Responsibility Segregation Test Support"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cqrs-types" = callPackage @@ -65497,8 +61310,6 @@ self: { ]; description = "Code review tool"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crack" = callPackage @@ -65511,8 +61322,6 @@ self: { librarySystemDepends = [ crack ]; description = "A haskell binding to cracklib"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {crack = null;}; "crackNum" = callPackage @@ -65576,8 +61385,6 @@ self: { ]; description = "A UNIX configuration management library in Haskell"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "craftwerk" = callPackage @@ -65591,8 +61398,6 @@ self: { libraryHaskellDepends = [ base colour mtl vector-space ]; description = "2D graphics library with integrated TikZ output"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "craftwerk-cairo" = callPackage @@ -65604,8 +61409,6 @@ self: { libraryHaskellDepends = [ base cairo craftwerk mtl ]; description = "Cairo backend for Craftwerk"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "craftwerk-gtk" = callPackage @@ -65623,8 +61426,6 @@ self: { ]; description = "Gtk UI for Craftwerk"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crawlchain" = callPackage @@ -65645,8 +61446,6 @@ self: { ]; description = "Simulation user crawl paths"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "craze" = callPackage @@ -65679,8 +61478,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "HTTP Racing Library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crc" = callPackage @@ -65698,8 +61495,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "Implements various Cyclic Redundancy Checks (CRC)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crc16" = callPackage @@ -65711,8 +61506,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Calculate the crc16-ccitt"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crc16-table" = callPackage @@ -65757,8 +61550,6 @@ self: { ]; description = "Conflict-free replicated data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crdt-event-fold" = callPackage @@ -65777,8 +61568,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Garbage collected event folding CRDT"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "creatur" = callPackage @@ -65804,8 +61593,6 @@ self: { ]; description = "Framework for artificial life experiments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "credential-store" = callPackage @@ -65825,8 +61612,6 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hunit ]; description = "Library to access secure credential storage providers"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "credentials" = callPackage @@ -65890,8 +61675,6 @@ self: { ]; description = "First-order, linear-chain conditional random fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crf-chain1-constrained" = callPackage @@ -65911,8 +61694,6 @@ self: { ]; description = "First-order, constrained, linear-chain conditional random fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crf-chain2-generic" = callPackage @@ -65930,8 +61711,6 @@ self: { ]; description = "Second-order, generic, constrained, linear conditional random fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crf-chain2-tiers" = callPackage @@ -65950,8 +61729,6 @@ self: { ]; description = "Second-order, tiered, constrained, linear conditional random fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "critbit" = callPackage @@ -65980,8 +61757,6 @@ self: { ]; description = "Crit-bit maps and sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "criterion" = callPackage @@ -66039,8 +61814,6 @@ self: { ]; description = "A simple tool for comparing in Criterion benchmark results"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "criterion-compare" = callPackage @@ -66062,8 +61835,6 @@ self: { ]; description = "A simple tool for visualising differences in Criterion benchmark results"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "criterion-measurement" = callPackage @@ -66106,8 +61877,6 @@ self: { ]; description = "Enhancement of the \"criterion\" benchmarking library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "criterion-to-html" = callPackage @@ -66126,8 +61895,6 @@ self: { ]; description = "Convert criterion output to HTML reports"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "criu-rpc" = callPackage @@ -66144,8 +61911,6 @@ self: { ]; description = "CRIU RPC client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "criu-rpc-types" = callPackage @@ -66159,8 +61924,6 @@ self: { libraryPkgconfigDepends = [ protobuf ]; description = "Criu RPC protocol buffer types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) protobuf;}; "crjdt-haskell" = callPackage @@ -66176,8 +61939,6 @@ self: { testHaskellDepends = [ base containers hedgehog hspec mtl ]; description = "A Conflict-Free Replicated JSON Datatype for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crockford" = callPackage @@ -66189,8 +61950,6 @@ self: { libraryHaskellDepends = [ base digits QuickCheck safe ]; description = "An implementation of Douglas Crockford's base32 encoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crocodile" = callPackage @@ -66209,8 +61968,6 @@ self: { ]; description = "An offline renderer supporting ray tracing and photon mapping"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cron" = callPackage @@ -66254,8 +62011,6 @@ self: { ]; description = "Cron datatypes and Attoparsec parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cronus" = callPackage @@ -66285,8 +62040,6 @@ self: { testHaskellDepends = [ base hlint ]; description = "Request and Response types for Eval.so's API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crunghc" = callPackage @@ -66305,8 +62058,6 @@ self: { ]; description = "A runghc replacement with transparent caching"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypt-sha512" = callPackage @@ -66328,8 +62079,6 @@ self: { ]; description = "Pure Haskell implelementation for GNU SHA512 crypt algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-api" = callPackage @@ -66382,8 +62131,6 @@ self: { ]; description = "Generic cryptography cipher benchmarks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-cipher-tests" = callPackage @@ -66435,8 +62182,6 @@ self: { testHaskellDepends = [ base bytestring QuickCheck ]; description = "An educational tool for studying classical cryptography schemes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-conduit" = callPackage @@ -66458,8 +62203,6 @@ self: { ]; description = "Conduit interface for cryptographic operations (from crypto-api)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-enigma" = callPackage @@ -66494,8 +62237,6 @@ self: { ]; description = "Like crypto-pubkey-openssh but not dependent on any specific crypto library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-multihash" = callPackage @@ -66516,8 +62257,6 @@ self: { testHaskellDepends = [ base bytestring hspec QuickCheck ]; description = "Multihash library on top of cryptonite crypto library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-numbers" = callPackage @@ -66590,8 +62329,6 @@ self: { ]; description = "OpenSSH keys decoder/encoder"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-pubkey-types" = callPackage @@ -66645,8 +62382,6 @@ self: { ]; description = "A random effect using crypto-random"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-rng" = callPackage @@ -66677,8 +62412,6 @@ self: { ]; description = "A simple high level encryption interface based on cryptonite"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypto-sodium" = callPackage @@ -66742,8 +62475,6 @@ self: { ]; description = "Symmetrical block and stream ciphers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cryptocompare" = callPackage @@ -66762,8 +62493,6 @@ self: { testHaskellDepends = [ base hspec hspec-expectations MissingH ]; description = "Haskell wrapper for the cryptocompare API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cryptoconditions" = callPackage @@ -66787,8 +62516,6 @@ self: { ]; description = "Interledger Crypto-Conditions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cryptohash" = callPackage @@ -66946,8 +62673,6 @@ self: { ]; description = "Reversable and secure encoding of object ids as a bytestring"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cryptoids-class" = callPackage @@ -66961,8 +62686,6 @@ self: { libraryHaskellDepends = [ base cryptoids-types exceptions ]; description = "Typeclass-based interface to cryptoids"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cryptoids-types" = callPackage @@ -66980,8 +62703,6 @@ self: { ]; description = "Shared types for encrypting internal object identifiers before exposure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cryptol" = callPackage @@ -67019,8 +62740,6 @@ self: { ]; description = "Cryptol: The Language of Cryptography"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cryptonite" = callPackage @@ -67128,8 +62847,6 @@ self: { ]; description = "Bindings for Cryptsy cryptocurrency exchange API"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crystalfontz" = callPackage @@ -67141,8 +62858,6 @@ self: { libraryHaskellDepends = [ base crc16-table MaybeT serialport ]; description = "Control Crystalfontz LCD displays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "csa" = callPackage @@ -67170,8 +62885,6 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Compiler plugin for common subexpression elimination"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "csg" = callPackage @@ -67203,8 +62916,6 @@ self: { ]; description = "Analytical CSG (Constructive Solid Geometry) library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "csound-catalog" = callPackage @@ -67343,8 +63054,6 @@ self: { ]; description = "A command line type checker for CSPM files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cspretty" = callPackage @@ -67356,8 +63065,6 @@ self: { libraryHaskellDepends = [ base containers pretty ]; description = "AST and pretty printer for CSPm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "css" = callPackage @@ -67369,8 +63076,6 @@ self: { libraryHaskellDepends = [ base mtl text ]; description = "Minimal monadic CSS DSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "css-easings" = callPackage @@ -67387,8 +63092,6 @@ self: { ]; description = "Defining and manipulating css easing strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "css-selectors" = callPackage @@ -67412,8 +63115,6 @@ self: { ]; description = "Parsing, rendering and manipulating css selectors in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "css-syntax" = callPackage @@ -67501,8 +63202,6 @@ self: { ]; description = "A flexible, fast, enumerator-based CSV parser library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "csv-nptools" = callPackage @@ -67520,8 +63219,6 @@ self: { ]; description = "A collection of CSV tools"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "csv-table" = callPackage @@ -67566,8 +63263,6 @@ self: { librarySystemDepends = [ ctemplate ]; description = "Binding to the Google ctemplate library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ctemplate = null;}; "ctkl" = callPackage @@ -67579,8 +63274,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "packaging of Manuel Chakravarty's CTK Light for Hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ctpl" = callPackage @@ -67597,8 +63290,6 @@ self: { executableHaskellDepends = [ array base chatty-text chatty-utils ]; description = "A programming language for text modification"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ctrie" = callPackage @@ -67639,8 +63330,6 @@ self: { ]; description = "Cubic DSL for 3D printing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cubical" = callPackage @@ -67659,8 +63348,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Implementation of Univalence in Cubical Sets"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cubicbezier" = callPackage @@ -67721,8 +63408,6 @@ self: { executableHaskellDepends = [ base GLUT Yampa ]; description = "3D Yampa/GLUT Puzzle Game"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cuckoo" = callPackage @@ -67745,8 +63430,6 @@ self: { doHaddock = false; description = "Haskell Implementation of Cuckoo Filters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cuckoo-filter" = callPackage @@ -67922,8 +63605,6 @@ self: { ]; description = "A framework for declaratively writing curl based API tests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "curlhs" = callPackage @@ -67994,8 +63675,6 @@ self: { testHaskellDepends = [ aeson base bson hspec QuickCheck ]; description = "ISO-4217 Currency Codes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "currency-convert" = callPackage @@ -68011,8 +63690,6 @@ self: { ]; description = "Typesafe currency conversion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "current-locale" = callPackage @@ -68081,8 +63758,6 @@ self: { ]; description = "Compile the functional logic language Curry to several intermediate formats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "curryer" = callPackage @@ -68130,8 +63805,6 @@ self: { ]; description = "Fast, Haskell RPC"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "curryrs" = callPackage @@ -68165,8 +63838,6 @@ self: { ]; description = "Terminal tool for viewing tabular data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cursor" = callPackage @@ -68234,8 +63905,6 @@ self: { base criterion cursor-fuzzy-time genvalidity-criterion QuickCheck ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cursor-gen" = callPackage @@ -68295,8 +63964,6 @@ self: { ]; description = "Library for drawing curve based images"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cusolver" = callPackage @@ -68342,8 +64009,6 @@ self: { libraryHaskellDepends = [ base basic-prelude monad-loops ]; description = "An enhanced prelude, serving as a foundation for my projects"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cut-the-crap" = callPackage @@ -68420,8 +64085,6 @@ self: { ]; description = "Functional Combinators for Computer Vision"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "cve" = callPackage @@ -68470,8 +64133,6 @@ self: { ]; description = "Haskell bindings for the neo4j \"cypher\" query language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "czipwith" = callPackage @@ -68514,8 +64175,6 @@ self: { ]; description = "Permissively licensed D-Bus client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "d10" = callPackage @@ -68560,8 +64219,6 @@ self: { libraryHaskellDepends = [ base mtl random text ]; description = "Declarative visualization on a web browser with DSL approach"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "daemonize-doublefork" = callPackage @@ -68618,8 +64275,6 @@ self: { ]; description = "Compile-time, type-safe directed acyclic graphs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "damnpacket" = callPackage @@ -68638,8 +64293,6 @@ self: { testHaskellDepends = [ base bytestring hspec HUnit QuickCheck ]; description = "Parsing dAmn messages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "danibot" = callPackage @@ -68662,8 +64315,6 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Basic Slack bot framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dao" = callPackage @@ -68694,8 +64345,6 @@ self: { ]; description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dapi" = callPackage @@ -68714,8 +64363,6 @@ self: { ]; description = "Prints a series of dates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcs" = callPackage @@ -68787,8 +64434,6 @@ self: { ]; description = "Comparative benchmark suite for darcs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcs-beta" = callPackage @@ -68820,8 +64465,6 @@ self: { executableSystemDepends = [ curl ]; description = "a distributed, interactive, smart revision control system"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) curl;}; "darcs-buildpackage" = callPackage @@ -68840,8 +64483,6 @@ self: { ]; description = "Tools to help manage Debian packages with Darcs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcs-cabalized" = callPackage @@ -68863,8 +64504,6 @@ self: { executableSystemDepends = [ curl ncurses zlib ]; description = "David's Advanced Version Control System"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) curl; inherit (pkgs) ncurses; inherit (pkgs) zlib;}; @@ -68885,8 +64524,6 @@ self: { ]; description = "Import/export git fast-import streams to/from darcs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcs-graph" = callPackage @@ -68905,8 +64542,6 @@ self: { ]; description = "Generate graphs of darcs repository activity"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcs-monitor" = callPackage @@ -68924,8 +64559,6 @@ self: { ]; description = "Darcs repository monitor (sends email)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcs-scripts" = callPackage @@ -68956,8 +64589,6 @@ self: { ]; description = "Outputs dependencies of darcs patches in dot format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcsden" = callPackage @@ -68985,8 +64616,6 @@ self: { ]; description = "Darcs repository UI and hosting/collaboration app (hub.darcs.net branch)."; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darcswatch" = callPackage @@ -69009,8 +64638,6 @@ self: { ]; description = "Track application of Darcs patches"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darkplaces-demo" = callPackage @@ -69038,8 +64665,6 @@ self: { ]; description = "Utility and parser for DarkPlaces demo files"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darkplaces-rcon" = callPackage @@ -69056,8 +64681,6 @@ self: { testHaskellDepends = [ base bytestring hspec hspec-core ]; description = "Darkplaces rcon client library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darkplaces-rcon-util" = callPackage @@ -69087,8 +64710,6 @@ self: { ]; description = "Darplaces rcon utility"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "darkplaces-text" = callPackage @@ -69106,8 +64727,6 @@ self: { testHaskellDepends = [ base bytestring hspec QuickCheck ]; description = "Parser for darkplaces colorful text"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dash-haskell" = callPackage @@ -69128,8 +64747,6 @@ self: { ]; description = "Convert package Haddock to Dash docsets (IDE docs)"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-accessor" = callPackage @@ -69166,8 +64783,6 @@ self: { ]; description = "Use Accessor to access state in monads-fd State monad class"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-accessor-monads-tf" = callPackage @@ -69181,8 +64796,6 @@ self: { ]; description = "Use Accessor to access state in monads-tf State monad type family"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-accessor-mtl" = callPackage @@ -69259,8 +64872,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator birds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-base" = callPackage @@ -69272,8 +64883,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Utilities for accessing and comparing types based on so called bases - representations with limited polymorphism"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-basic" = callPackage @@ -69297,8 +64906,6 @@ self: { ]; description = "A database library with a focus on ease of use, type safety and useful error messages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-binary-ieee754" = callPackage @@ -69368,8 +64975,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Library for checking and normalization of data (e.g. from web forms)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-checked" = callPackage @@ -69405,8 +65010,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Generate a special combinator from any data type"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-compat" = callPackage @@ -69429,8 +65032,6 @@ self: { libraryHaskellDepends = [ base stm ]; description = "A Library for directional queues"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-construction" = callPackage @@ -69442,8 +65043,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Data construction abstractions including Constructor, Destructor, Maker, Destroyer, Producer and Consumer"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-constructors" = callPackage @@ -69473,8 +65072,6 @@ self: { ]; description = "a cyclic doubly linked list"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-default" = callPackage @@ -69693,8 +65290,6 @@ self: { ]; description = "Space-efficient and privacy-preserving data dispersal algorithms"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-diverse" = callPackage @@ -69728,8 +65323,6 @@ self: { testHaskellDepends = [ base data-diverse hspec lens tagged ]; description = "Isos & Lens for Data.Diverse.Many and Prisms for Data.Diverse.Which"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-dword" = callPackage @@ -69764,8 +65357,6 @@ self: { ]; description = "Consistent set of utility functions for Maybe, Either, List and Monoids"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-elf" = callPackage @@ -69779,8 +65370,6 @@ self: { ]; description = "Executable and Linkable Format (ELF) data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-embed" = callPackage @@ -69805,8 +65394,6 @@ self: { ]; description = "Embed files and other binary blobs inside executables without Template Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-emoticons" = callPackage @@ -69818,8 +65405,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator emoticons: data-aviary in the flavor of emoticons"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-endian" = callPackage @@ -69871,8 +65456,6 @@ self: { ]; description = "A type safe file path data structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-files-gen" = callPackage @@ -69919,8 +65502,6 @@ self: { ]; description = "Finite totally ordered sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-fin-simple" = callPackage @@ -69933,8 +65514,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Simple integral finite set"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-fix" = callPackage @@ -69979,8 +65558,6 @@ self: { libraryHaskellDepends = [ base ]; description = "An efficient data type for sets of flags"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-foldapp" = callPackage @@ -70099,8 +65676,6 @@ self: { ]; description = "Interval datatype, interval arithmetic and interval-based containers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-inttrie" = callPackage @@ -70123,8 +65698,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Write-once variables with concurrency support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-json-token" = callPackage @@ -70155,8 +65728,6 @@ self: { ]; description = "Sculpt mutable recursive data with reference equality; bake it using a data kiln into an immutable lazy structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-layer" = callPackage @@ -70168,8 +65739,6 @@ self: { libraryHaskellDepends = [ base convert data-construction lens ]; description = "Data layering utilities. Layer is a data-type which wrapps other one, but keeping additional information. If you want to access content of simple newtype object, use Lens.Wrapper instead."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-layout" = callPackage @@ -70196,8 +65765,6 @@ self: { ]; description = "Used to be Haskell 98 Lenses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-lens-fd" = callPackage @@ -70211,8 +65778,6 @@ self: { ]; description = "Lenses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-lens-ixset" = callPackage @@ -70225,8 +65790,6 @@ self: { testHaskellDepends = [ QuickCheck ]; description = "A Lens for IxSet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-lens-light" = callPackage @@ -70249,8 +65812,6 @@ self: { libraryHaskellDepends = [ base data-lens template-haskell ]; description = "Utilities for Data.Lens"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-list-sequences" = callPackage @@ -70284,8 +65845,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Data.Map with multiple, unique keys"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-memocombinators" = callPackage @@ -70362,8 +65921,6 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "data Nat = Zero | Succ Nat"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-object" = callPackage @@ -70375,8 +65932,6 @@ self: { libraryHaskellDepends = [ base bytestring failure text time ]; description = "Represent hierachichal structures, called objects in JSON. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-object-json" = callPackage @@ -70393,8 +65948,6 @@ self: { ]; description = "Serialize JSON data to/from Haskell using the data-object library. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-object-yaml" = callPackage @@ -70413,8 +65966,6 @@ self: { ]; description = "Serialize data to and from Yaml files (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-or" = callPackage @@ -70461,8 +66012,6 @@ self: { libraryHaskellDepends = [ base deepseq mtl parallel pretty time ]; description = "Prettyprint and compare Data values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-quotientref" = callPackage @@ -70474,8 +66023,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Reference cells that need two independent indices to be accessed"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-r-tree" = callPackage @@ -70494,8 +66041,6 @@ self: { ]; description = "R-Tree is a spatial data structure similar to Quadtrees or B-Trees"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-ref" = callPackage @@ -70537,8 +66082,6 @@ self: { libraryHaskellDepends = [ base containers data-reify ]; description = "Common Sub-Expression Elimination for graphs generated by Data.Reify."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-repr" = callPackage @@ -70550,8 +66093,6 @@ self: { libraryHaskellDepends = [ base generic-deriving lens ]; description = "Alternative to Show data printing utility"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-result" = callPackage @@ -70563,8 +66104,6 @@ self: { libraryHaskellDepends = [ base poly-control prologue ]; description = "Data types for returning results distinguishable by types"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-rev" = callPackage @@ -70576,8 +66115,6 @@ self: { libraryHaskellDepends = [ base bytestring containers text vector ]; description = "A typeclass for reversing order of contents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-rope" = callPackage @@ -70589,8 +66126,6 @@ self: { libraryHaskellDepends = [ base bytestring bytestring-mmap unix ]; description = "Ropes, an alternative to (Byte)Strings"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-rtuple" = callPackage @@ -70602,8 +66137,6 @@ self: { libraryHaskellDepends = [ base lens typelevel ]; description = "Recursive tuple data structure. It is very usefull when implementing some lo-level operations, allowing to traverse different elements using Haskell's type classes."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-serializer" = callPackage @@ -70635,8 +66168,6 @@ self: { ]; description = "Profiling of data structures"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-spacepart" = callPackage @@ -70648,8 +66179,6 @@ self: { libraryHaskellDepends = [ base vector-space ]; description = "Deprecated. Now called \"spacepart\". Space partitioning data structures."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-standards" = callPackage @@ -70661,8 +66190,6 @@ self: { libraryHaskellDepends = [ base hashable unordered-containers ]; description = "A collection of standards representable by simple data types"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-stm32" = callPackage @@ -70716,8 +66243,6 @@ self: { ]; description = "Type safe, in-memory dictionary with multidimensional keys"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-stringmap" = callPackage @@ -70736,8 +66261,6 @@ self: { ]; description = "An efficient implementation of maps from strings to arbitrary values"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-structure-inferrer" = callPackage @@ -70758,8 +66281,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Program that infers the fastest data structure available for your program"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-sword" = callPackage @@ -70776,8 +66297,6 @@ self: { testHaskellDepends = [ base tasty tasty-quickcheck ]; description = "Shorter binary words"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-tensor" = callPackage @@ -70870,8 +66389,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Basic type wrangling types and classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-util" = callPackage @@ -70883,8 +66400,6 @@ self: { libraryHaskellDepends = [ base ]; description = "utilities for handle data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-validation" = callPackage @@ -70901,8 +66416,6 @@ self: { ]; description = "A library for creating type safe validations"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-variant" = callPackage @@ -70914,8 +66427,6 @@ self: { libraryHaskellDepends = [ base safe ]; description = "A variant data type, useful for modeling dynamically-typed programming languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "data-vector-growable" = callPackage @@ -70958,8 +66469,6 @@ self: { ]; description = "HasId/Groundhog interop"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "database-migrate" = callPackage @@ -70988,8 +66497,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Demonstrate how a database can be implemented the functional way"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "datadog" = callPackage @@ -71017,8 +66524,6 @@ self: { ]; description = "Datadog client for Haskell. Supports both the HTTP API and StatsD."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "datadog-tracing" = callPackage @@ -71054,8 +66559,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Datadog tracing client and mock agent"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dataenc" = callPackage @@ -71101,8 +66604,6 @@ self: { ]; description = "Fixing data-flow problems"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dataflow" = callPackage @@ -71126,8 +66627,6 @@ self: { ]; description = "Generate Graphviz documents from a Haskell representation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dataflower" = callPackage @@ -71172,8 +66671,6 @@ self: { ]; description = "An implementation of datalog in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "datapacker" = callPackage @@ -71191,8 +66688,6 @@ self: { ]; description = "Tool to help pack files into the minimum number of CDs/DVDs/etc"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "datarobot" = callPackage @@ -71244,8 +66739,6 @@ self: { ]; description = "Classical data sets for statistics and machine learning"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dataurl" = callPackage @@ -71264,8 +66757,6 @@ self: { ]; description = "Handle data-urls"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "date-cache" = callPackage @@ -71289,8 +66780,6 @@ self: { testHaskellDepends = [ base dates hspec QuickCheck time ]; description = "Date conversions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dates" = callPackage @@ -71307,8 +66796,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Small library for parsing different dates formats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "datetime" = callPackage @@ -71327,8 +66814,6 @@ self: { ]; description = "Utilities to make Data.Time.* easier to use"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "datetime-sb" = callPackage @@ -71347,8 +66832,6 @@ self: { ]; description = "Utilities to make Data.Time.* easier to use."; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dawdle" = callPackage @@ -71363,8 +66846,6 @@ self: { executableHaskellDepends = [ base filepath parsec pretty text ]; description = "Generates DDL suggestions based on a CSV file"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dawg" = callPackage @@ -71380,8 +66861,6 @@ self: { ]; description = "Directed acyclic word graphs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dawg-ord" = callPackage @@ -71414,8 +66893,6 @@ self: { testHaskellDepends = [ base hspec postgresql-simple text ]; description = "Clean database tables automatically around hspec tests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbf" = callPackage @@ -71429,8 +66906,6 @@ self: { ]; description = "Read and write XBase \".dbf\" files"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbjava" = callPackage @@ -71451,8 +66926,6 @@ self: { ]; description = "Decompiler Bytecode Java"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbm" = callPackage @@ -71471,8 +66944,6 @@ self: { ]; description = "A *simple* database migration tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbmigrations" = callPackage @@ -71520,8 +66991,6 @@ self: { ]; description = "The dbmigrations tool built for MySQL databases"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbmigrations-postgresql" = callPackage @@ -71540,8 +67009,6 @@ self: { ]; description = "The dbmigrations tool built for PostgreSQL databases"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbmigrations-sqlite" = callPackage @@ -71556,8 +67023,6 @@ self: { testHaskellDepends = [ base dbmigrations HDBC HDBC-sqlite3 HUnit ]; description = "The dbmigrations tool built for SQLite databases"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbus" = callPackage @@ -71628,8 +67093,6 @@ self: { ]; description = "Monadic and object-oriented interfaces to DBus"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbus-core" = callPackage @@ -71647,8 +67110,6 @@ self: { ]; description = "Low-level D-Bus protocol implementation"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbus-hslogger" = callPackage @@ -71681,8 +67142,6 @@ self: { testHaskellDepends = [ base containers dbus QuickCheck ]; description = "Quasi-quoter for DBus functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dbus-th" = callPackage @@ -71740,8 +67199,6 @@ self: { ]; description = "This packge is deprecated. See the the \"LIO.DCLabel\" in the \"lio\" package."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dclabel-eci11" = callPackage @@ -71753,8 +67210,6 @@ self: { libraryHaskellDepends = [ base pretty QuickCheck ]; description = "The Disjunction Category Label Format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dcpu16" = callPackage @@ -71774,8 +67229,6 @@ self: { testHaskellDepends = [ base ]; description = "DCPU-16 Emulator & Assembler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddate" = callPackage @@ -71787,8 +67240,6 @@ self: { libraryHaskellDepends = [ base dates time ]; description = "Discordian Date Types for Haskell"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-base" = callPackage @@ -71804,8 +67255,6 @@ self: { ]; description = "Disciplined Disciple Compiler common utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-build" = callPackage @@ -71825,8 +67274,6 @@ self: { ]; description = "Disciplined Disciple Compiler build framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-code" = callPackage @@ -71839,8 +67286,6 @@ self: { libraryHaskellDepends = [ base filepath ]; description = "Disciplined Disciple Compiler base libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core" = callPackage @@ -71857,8 +67302,6 @@ self: { ]; description = "Disciplined Disciple Compiler core language and type checker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core-babel" = callPackage @@ -71872,8 +67315,6 @@ self: { ]; description = "Disciplined Disciple Compiler PHP code generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core-eval" = callPackage @@ -71889,8 +67330,6 @@ self: { ]; description = "Disciplined Disciple Compiler semantic evaluator for the core language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core-flow" = callPackage @@ -71908,8 +67347,6 @@ self: { ]; description = "Disciplined Disciple Compiler data flow compiler"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core-llvm" = callPackage @@ -71926,8 +67363,6 @@ self: { ]; description = "Disciplined Disciple Compiler LLVM code generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core-salt" = callPackage @@ -71943,8 +67378,6 @@ self: { ]; description = "Disciplined Disciple Compiler C code generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core-simpl" = callPackage @@ -71960,8 +67393,6 @@ self: { ]; description = "Disciplined Disciple Compiler code transformations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-core-tetra" = callPackage @@ -71978,8 +67409,6 @@ self: { ]; description = "Disciplined Disciple Compiler intermediate language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-driver" = callPackage @@ -71999,8 +67428,6 @@ self: { ]; description = "Disciplined Disciple Compiler top-level driver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-interface" = callPackage @@ -72012,8 +67439,6 @@ self: { libraryHaskellDepends = [ base containers ddc-base directory ]; description = "Disciplined Disciple Compiler user interface support"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-source-tetra" = callPackage @@ -72030,8 +67455,6 @@ self: { ]; description = "Disciplined Disciple Compiler source language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-tools" = callPackage @@ -72054,8 +67477,6 @@ self: { ]; description = "Disciplined Disciple Compiler command line tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddc-war" = callPackage @@ -72073,8 +67494,6 @@ self: { ]; description = "Disciplined Disciple Compiler test driver and buildbot"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ddci-core" = callPackage @@ -72093,8 +67512,6 @@ self: { ]; description = "Disciple Core language interactive interpreter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dde" = callPackage @@ -72146,8 +67563,6 @@ self: { ]; description = "detect dead code in haskell projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dead-simple-json" = callPackage @@ -72163,8 +67578,6 @@ self: { ]; description = "Dead simple JSON parser, with some Template Haskell sugar"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "debian" = callPackage @@ -72254,8 +67667,6 @@ self: { ]; description = "Simple trace-based debugger"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "debug-diff" = callPackage @@ -72306,8 +67717,6 @@ self: { ]; description = "secure remote debugging"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "debug-pp" = callPackage @@ -72349,8 +67758,6 @@ self: { libraryHaskellDepends = [ base template-haskell unicode-show ]; description = "You do not have to write variable names twice in Debug.Trace"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "debug-tracy" = callPackage @@ -72365,8 +67772,6 @@ self: { executableHaskellDepends = [ base ]; description = "More useful trace functions for investigating bugs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deburr" = callPackage @@ -72401,8 +67806,6 @@ self: { libraryHaskellDepends = [ base comonad-transformers ]; description = "The categorical dual of transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "decidable" = callPackage @@ -72418,8 +67821,6 @@ self: { ]; description = "Combinators for manipulating dependently-typed predicates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "decimal-arithmetic" = callPackage @@ -72434,8 +67835,6 @@ self: { testHaskellDepends = [ base binary doctest hspec QuickCheck ]; description = "An implementation of the General Decimal Arithmetic Specification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "decimal-literals" = callPackage @@ -72450,8 +67849,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Preprocessing decimal literals more or less as they are (instead of via fractions)"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "declarative" = callPackage @@ -72498,8 +67895,6 @@ self: { libraryHaskellDepends = [ base binary bytestring conduit ]; description = "Conduit for decoding ByteStrings using Data.Binary.Get"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dedukti" = callPackage @@ -72522,8 +67917,6 @@ self: { ]; description = "A type-checker for the λΠ-modulo calculus"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deep-transformations" = callPackage @@ -72542,8 +67935,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Deep natural and unnatural tree transformations, including attribute grammars"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deepcontrol" = callPackage @@ -72560,8 +67951,6 @@ self: { ]; description = "A library that provides deep-level programming style and(or) notation on Applicative and Monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deepl" = callPackage @@ -72612,8 +68001,6 @@ self: { ]; description = "Deep Learning in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deepseq_1_4_5_0" = callPackage @@ -72654,8 +68041,6 @@ self: { ]; description = "Bounded deepseq, including support for generic deriving"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deepseq-generics" = callPackage @@ -72696,8 +68081,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Deep evaluation of data structures without NFData"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deepseq-th" = callPackage @@ -72710,8 +68093,6 @@ self: { testHaskellDepends = [ base deepseq template-haskell ]; description = "Template Haskell based deriver for optimised NFData instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deepzoom" = callPackage @@ -72723,8 +68104,6 @@ self: { libraryHaskellDepends = [ base directory filepath hsmagick ]; description = "A DeepZoom image slicer. Only known to work on 32bit Linux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "defargs" = callPackage @@ -72736,8 +68115,6 @@ self: { libraryHaskellDepends = [ base cluss ]; description = "default arguments in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deferred-folds" = callPackage @@ -72921,8 +68298,6 @@ self: { librarySystemDepends = [ mpdec ]; description = "Decimal floating point arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {mpdec = null;}; "deka-tests" = callPackage @@ -72943,8 +68318,6 @@ self: { testHaskellDepends = [ base bytestring deka QuickCheck quickpull ]; description = "Tests for deka, decimal floating point arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "delaunay" = callPackage @@ -72961,8 +68334,6 @@ self: { testHaskellDepends = [ AC-Vector base HUnit QuickCheck ]; description = "Build a Delaunay triangulation of a set of points"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "delay" = callPackage @@ -72993,8 +68364,6 @@ self: { ]; description = "Accessing the del.icio.us APIs from Haskell (v2)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "delimited-text" = callPackage @@ -73010,8 +68379,6 @@ self: { ]; description = "Parse character delimited textual data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "delimiter-separated" = callPackage @@ -73024,8 +68391,6 @@ self: { libraryHaskellDepends = [ base uhc-util uulib ]; description = "Library for dealing with tab and/or comma (or other) separated files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "delta" = callPackage @@ -73049,8 +68414,6 @@ self: { testHaskellDepends = [ base directory filepath hspec ]; description = "A library for detecting file changes"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "delta-h" = callPackage @@ -73072,8 +68435,6 @@ self: { ]; description = "Online entropy-based model of lexical category acquisition"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "delude" = callPackage @@ -73085,8 +68446,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Generalized the Prelude more functionally"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "demarcate" = callPackage @@ -73099,8 +68458,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Demarcating transformed monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "denominate" = callPackage @@ -73115,8 +68472,6 @@ self: { executableHaskellDepends = [ base directory filepath ]; description = "Functions supporting bulk file and directory name normalization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dense" = callPackage @@ -73141,8 +68496,6 @@ self: { ]; description = "Mutable and immutable dense multidimensional arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dense-int-set" = callPackage @@ -73164,8 +68517,6 @@ self: { ]; description = "Dense int-set"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dense-linear-algebra" = callPackage @@ -73201,8 +68552,6 @@ self: { ]; description = "Reader-like monad transformer for dependency injection"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dep-t-advice" = callPackage @@ -73225,8 +68574,6 @@ self: { ]; description = "Giving good advice to functions in a DepT environment"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dependency" = callPackage @@ -73263,8 +68610,6 @@ self: { ]; description = "Dependent hash maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dependent-map_0_2_4_0" = callPackage @@ -73311,8 +68656,6 @@ self: { ]; description = "Dependent map that uses semigroup mappend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dependent-state" = callPackage @@ -73324,8 +68667,6 @@ self: { libraryHaskellDepends = [ base lens mtl prologue ]; description = "Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dependent-sum_0_4" = callPackage @@ -73404,8 +68745,6 @@ self: { ]; description = "A simple configuration management tool for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dephd" = callPackage @@ -73424,8 +68763,6 @@ self: { ]; description = "Analyze quality of nucleotide sequences"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "depq" = callPackage @@ -73453,8 +68790,6 @@ self: { libraryHaskellDepends = [ base containers dlist mtl parsec ]; description = "DepTrack Core types and model"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deptrack-devops" = callPackage @@ -73473,8 +68808,6 @@ self: { ]; description = "DepTrack applied to DevOps"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deptrack-dot" = callPackage @@ -73487,8 +68820,6 @@ self: { testHaskellDepends = [ base containers deptrack-core dotgen ]; description = "Facilitate Graphviz representations of DepTrack dependencies"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deque" = callPackage @@ -73521,8 +68852,6 @@ self: { testHaskellDepends = [ base Cabal cabal-test-quickcheck ]; description = "A typeclass and an implementation for double-ended queues"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derangement" = callPackage @@ -73534,8 +68863,6 @@ self: { libraryHaskellDepends = [ base fgl ]; description = "Find derangements of lists"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derivation-trees" = callPackage @@ -73549,8 +68876,6 @@ self: { ]; description = "Typeset Derivation Trees via MetaPost"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derive" = callPackage @@ -73571,8 +68896,6 @@ self: { executableHaskellDepends = [ base ]; description = "A program and library to derive instances for data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derive-IG" = callPackage @@ -73584,8 +68907,6 @@ self: { libraryHaskellDepends = [ base instant-generics template-haskell ]; description = "Macro to derive instances for Instant-Generics using Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derive-enumerable" = callPackage @@ -73597,8 +68918,6 @@ self: { libraryHaskellDepends = [ base data-default ]; description = "Generic instances for enumerating complex data types"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derive-gadt" = callPackage @@ -73620,8 +68939,6 @@ self: { ]; description = "Instance deriving for (a subset of) GADTs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derive-lifted-instances" = callPackage @@ -73650,8 +68967,6 @@ self: { testHaskellDepends = [ base semigroups ]; description = "derive Semigroup/Monoid/IsList"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derive-storable" = callPackage @@ -73710,8 +69025,6 @@ self: { libraryHaskellDepends = [ array base containers template-haskell ]; description = "Automatic derivation of Trie implementations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "deriveJsonNoPrefix" = callPackage @@ -73797,8 +69110,6 @@ self: { libraryHaskellDepends = [ base derp ]; description = "combinators based on parsing with derivatives (derp) package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "derulo" = callPackage @@ -73835,8 +69146,6 @@ self: { ]; description = "Combinators for describing binary data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "descrilo" = callPackage @@ -73882,8 +69191,6 @@ self: { ]; description = "Library, interpreter, and CLI for Descript programming language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "descriptive" = callPackage @@ -73946,8 +69253,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Simple deterministic game engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "detour-via-sci" = callPackage @@ -73991,8 +69296,6 @@ self: { ]; description = "JSON and CSV encoding for quantities"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "detrospector" = callPackage @@ -74024,8 +69327,6 @@ self: { executableHaskellDepends = [ base bytestring utf8-string ]; description = "Get rid of unicode (utf-8) symbols in Haskell sources"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "devil" = callPackage @@ -74044,8 +69345,6 @@ self: { ]; description = "A small tool to make it easier to update program managed by Angel"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "devtools" = callPackage @@ -74067,8 +69366,6 @@ self: { ]; description = "Haskell development tool agregate"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dewdrop" = callPackage @@ -74082,8 +69379,6 @@ self: { ]; description = "Find gadgets for return-oriented programming on x86"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "df1" = callPackage @@ -74158,8 +69453,6 @@ self: { ]; description = "A generic data integrity layer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) leveldb;}; "dfrac" = callPackage @@ -74190,8 +69483,6 @@ self: { ]; description = "Build Debian From Scratch CD/DVD images"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dgim" = callPackage @@ -74204,8 +69495,6 @@ self: { testHaskellDepends = [ base Cabal QuickCheck ]; description = "Implementation of DGIM algorithm"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dgs" = callPackage @@ -74217,8 +69506,6 @@ self: { libraryHaskellDepends = [ base HTTP mtl network split ]; description = "Haskell front-end for DGS' bot interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall_1_29_0" = callPackage @@ -74365,8 +69652,6 @@ self: { ]; description = "Check all dhall files in a project"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-docs" = callPackage @@ -74395,8 +69680,6 @@ self: { ]; description = "Generate HTML docs from a dhall package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-fly" = callPackage @@ -74429,8 +69712,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Translate concourse config from Dhall to YAML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-json" = callPackage @@ -74531,8 +69812,6 @@ self: { ]; description = "Dhall to Nix compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-nixpkgs" = callPackage @@ -74554,8 +69833,6 @@ self: { ]; description = "Convert Dhall projects to Nix packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-openapi" = callPackage @@ -74600,8 +69877,6 @@ self: { ]; description = "Convert recursive ADTs from and to Dhall"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-text" = callPackage @@ -74619,8 +69894,6 @@ self: { ]; description = "Template text using Dhall"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-to-cabal" = callPackage @@ -74649,8 +69922,6 @@ self: { ]; description = "Compile Dhall expressions to Cabal files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhall-yaml" = callPackage @@ -74697,8 +69968,6 @@ self: { ]; description = "Parse a DHCP lease file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dhrun" = callPackage @@ -74732,8 +70001,6 @@ self: { doHaddock = false; description = "Dhall/YAML configurable concurrent integration test executor"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "di" = callPackage @@ -74841,8 +70108,6 @@ self: { libraryHaskellDepends = [ base deepseq ]; description = "An EDSL for teaching Haskell with diagrams - data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dia-functions" = callPackage @@ -74860,8 +70125,6 @@ self: { ]; description = "An EDSL for teaching Haskell with diagrams - functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams" = callPackage @@ -74891,8 +70154,6 @@ self: { libraryHaskellDepends = [ base cubicbezier diagrams-lib ]; description = "deprecated, part of diagrams-contrib since 1.4"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-braille" = callPackage @@ -74918,8 +70179,6 @@ self: { ]; description = "Braille diagrams with plain text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-builder" = callPackage @@ -74948,8 +70207,6 @@ self: { ]; description = "hint-based build service for the diagrams graphics EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-cairo" = callPackage @@ -74990,8 +70247,6 @@ self: { ]; description = "HTML5 canvas backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-contrib" = callPackage @@ -75054,8 +70309,6 @@ self: { ]; description = "Graph layout and drawing with GraphViz and diagrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-gtk" = callPackage @@ -75071,8 +70324,6 @@ self: { ]; description = "Backend for rendering diagrams directly to GTK windows"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-haddock" = callPackage @@ -75103,8 +70354,6 @@ self: { ]; description = "Preprocessor for embedding diagrams in Haddock documentation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-hsqml" = callPackage @@ -75140,8 +70389,6 @@ self: { ]; description = "HTML5 canvas backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-lib" = callPackage @@ -75200,8 +70447,6 @@ self: { ]; description = "A Pandoc filter to express diagrams inline using the Haskell EDSL _Diagrams_"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-pdf" = callPackage @@ -75219,8 +70464,6 @@ self: { ]; description = "PDF backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-pgf" = callPackage @@ -75240,8 +70483,6 @@ self: { ]; description = "PGF backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-postscript" = callPackage @@ -75276,8 +70517,6 @@ self: { ]; description = "Draw QR codes to SVG, PNG, PDF or PS files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-rasterific" = callPackage @@ -75300,8 +70539,6 @@ self: { testHaskellDepends = [ base diagrams-core diagrams-lib ]; description = "Rasterific backend for diagrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-reflex" = callPackage @@ -75335,8 +70572,6 @@ self: { ]; description = "Library for drawing the Rubik's Cube"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-solve" = callPackage @@ -75387,8 +70622,6 @@ self: { ]; description = "TikZ backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diagrams-wx" = callPackage @@ -75406,8 +70639,6 @@ self: { ]; description = "Backend for rendering diagrams in wxWidgets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dialog" = callPackage @@ -75469,8 +70700,6 @@ self: { ]; description = "A simple, forward build system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dice" = callPackage @@ -75516,8 +70745,6 @@ self: { executableHaskellDepends = [ base ]; description = "Convert a Diceware wordlist into a printer-ready LaTeX file"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dicom" = callPackage @@ -75531,8 +70758,6 @@ self: { ]; description = "A library for reading and writing DICOM files in the Explicit VR Little Endian transfer syntax"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dictionaries" = callPackage @@ -75561,8 +70786,6 @@ self: { ]; description = "Tools to handle StarDict dictionaries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dictionary-sharing" = callPackage @@ -75591,8 +70814,6 @@ self: { testHaskellDepends = [ base hspec parsec ]; description = "Parsec parsers for the DICT format produced by dictfmt -t"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diet" = callPackage @@ -75610,8 +70831,6 @@ self: { ]; description = "Discrete Interval Encoding Trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diff" = callPackage @@ -75623,8 +70842,6 @@ self: { libraryHaskellDepends = [ base Enum util ]; description = "Diff and patch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diff-gestalt" = callPackage @@ -75697,8 +70914,6 @@ self: { ]; description = "Diff two .cabal files syntactically"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diffdump" = callPackage @@ -75737,8 +70952,6 @@ self: { groups hedgehog hedgehog-checkers QuickCheck semigroupoids ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "differential" = callPackage @@ -75764,8 +70977,6 @@ self: { ]; description = "Finds out whether an entity comes from different distributions (statuses)"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diffmap" = callPackage @@ -75779,8 +70990,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "diff on maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "difftodo" = callPackage @@ -75806,8 +71015,6 @@ self: { ]; description = "Generate todo lists from source code"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digamma" = callPackage @@ -75874,8 +71081,6 @@ self: { ]; description = "Speed up form designing using digestive functors and bootstrap"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digestive-foundation-lucid" = callPackage @@ -75892,8 +71097,6 @@ self: { ]; description = "Speed up form designing using digestive functors and foundation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digestive-functors" = callPackage @@ -75936,8 +71139,6 @@ self: { ]; description = "Run digestive-functors forms against JSON"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digestive-functors-blaze" = callPackage @@ -75968,8 +71169,6 @@ self: { ]; description = "Happstack backend for the digestive-functors library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digestive-functors-heist" = callPackage @@ -75998,8 +71197,6 @@ self: { libraryToolDepends = [ trhsx ]; description = "HSP support for digestive-functors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digestive-functors-lucid" = callPackage @@ -76083,8 +71280,6 @@ self: { testHaskellDepends = [ base doctest hspec ]; description = "digitalocean api for haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digits" = callPackage @@ -76097,8 +71292,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Converts integers to lists of digits and back"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "digraph" = callPackage @@ -76178,8 +71371,6 @@ self: { libraryHaskellDepends = [ base dimensional numtype-dk ]; description = "CODATA Recommended Physical Constants with Dimensional Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dimensional-tf" = callPackage @@ -76191,8 +71382,6 @@ self: { libraryHaskellDepends = [ base numtype-tf time ]; description = "Statically checked physical dimensions, implemented using type families"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dimensions" = callPackage @@ -76231,8 +71420,6 @@ self: { ]; description = "Dingo is a Rich Internet Application platform based on the Warp web server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dingo-example" = callPackage @@ -76252,8 +71439,6 @@ self: { ]; description = "Dingo Example"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dingo-widgets" = callPackage @@ -76272,8 +71457,6 @@ self: { ]; description = "Dingo Widgets"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dino" = callPackage @@ -76319,8 +71502,6 @@ self: { ]; description = "Gemini client"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diophantine" = callPackage @@ -76333,8 +71514,6 @@ self: { libraryToolDepends = [ happy ]; description = "A quadratic diophantine equation solving library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diplomacy" = callPackage @@ -76350,8 +71529,6 @@ self: { ]; description = "Diplomacy board game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "diplomacy-server" = callPackage @@ -76375,8 +71552,6 @@ self: { ]; description = "Play Diplomacy over HTTP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dir-traverse" = callPackage @@ -76404,8 +71579,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "Serialization and deserialization monads for streams and ByteStrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "direct-daemonize" = callPackage @@ -76432,8 +71605,6 @@ self: { ]; description = "Native implementation of the FastCGI protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "direct-http" = callPackage @@ -76452,8 +71623,6 @@ self: { ]; description = "Native webserver that acts as a library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "direct-murmur-hash" = callPackage @@ -76476,8 +71645,6 @@ self: { libraryHaskellDepends = [ base ghc ghc-paths ]; description = "Lightweight replacement for Plugins, specific to GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "direct-rocksdb" = callPackage @@ -76497,8 +71664,6 @@ self: { ]; description = "Bindings to RocksDB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "direct-sqlite" = callPackage @@ -76531,8 +71696,6 @@ self: { ]; description = "Finite directed cubical complexes and associated algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "directory_1_3_6_1" = callPackage @@ -76567,8 +71730,6 @@ self: { testHaskellDepends = [ base filepath ]; description = "Recursively build, navigate, and operate on a tree of directory contents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "directory-layout" = callPackage @@ -76632,8 +71793,6 @@ self: { executableHaskellDepends = [ base directory ]; description = "Deletes a directory and retains its contents in the parent directory"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dirfiles" = callPackage @@ -76649,8 +71808,6 @@ self: { unordered-containers ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dirichlet" = callPackage @@ -76740,8 +71897,6 @@ self: { ]; description = "Client for Discogs REST API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discokitty" = callPackage @@ -76770,8 +71925,6 @@ self: { ]; description = "An API wrapper for Discord in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discord-haskell" = callPackage @@ -76811,8 +71964,6 @@ self: { ]; description = "An API wrapper for Discord in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discord-register" = callPackage @@ -76844,8 +71995,6 @@ self: { ]; description = "Discord verification bot"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discord-rest" = callPackage @@ -76865,8 +72014,6 @@ self: { ]; description = "An API wrapper for Discord in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discord-types" = callPackage @@ -76885,8 +72032,6 @@ self: { ]; description = "Type information for discord-hs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discordian-calendar" = callPackage @@ -76898,8 +72043,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "library for handling Discordian calendar dates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discount" = callPackage @@ -76925,8 +72068,6 @@ self: { libraryHaskellDepends = [ base ]; description = "replacement for enum"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "discrete-intervals" = callPackage @@ -77000,8 +72141,6 @@ self: { ]; description = "Disjoint containers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "disjoint-set" = callPackage @@ -77018,8 +72157,6 @@ self: { ]; description = "Persistent disjoint-sets, a.k.a union-find."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "disjoint-set-stateful" = callPackage @@ -77032,8 +72169,6 @@ self: { testHaskellDepends = [ base hspec primitive ref-tf vector ]; description = "Monadic disjoint set"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "disjoint-sets-st" = callPackage @@ -77123,8 +72258,6 @@ self: { doHaddock = false; description = "Generate/Upload cabal package to Hackage"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distance" = callPackage @@ -77138,8 +72271,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Useful distance datatype and functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distance-of-time" = callPackage @@ -77215,8 +72346,6 @@ self: { ]; description = "AWS Lambda backend for distributed-fork"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process" = callPackage @@ -77241,8 +72370,6 @@ self: { ]; description = "Cloud Haskell: Erlang-style concurrency in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-async" = callPackage @@ -77270,8 +72397,6 @@ self: { ]; description = "Cloud Haskell Async API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-azure" = callPackage @@ -77294,8 +72419,6 @@ self: { ]; description = "Microsoft Azure backend for Cloud Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-client-server" = callPackage @@ -77325,8 +72448,6 @@ self: { ]; description = "The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-ekg" = callPackage @@ -77342,8 +72463,6 @@ self: { ]; description = "Collect node stats for EKG"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-execution" = callPackage @@ -77379,8 +72498,6 @@ self: { ]; description = "Execution Framework for The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-extras" = callPackage @@ -77411,8 +72528,6 @@ self: { ]; description = "Cloud Haskell Extras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-fsm" = callPackage @@ -77445,8 +72560,6 @@ self: { ]; description = "The Cloud Haskell implementation of Erlang/OTP gen_statem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-lifted" = callPackage @@ -77472,8 +72585,6 @@ self: { ]; description = "monad-control style typeclass and transformer instances for Process monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-monad-control" = callPackage @@ -77490,8 +72601,6 @@ self: { ]; description = "Orphan instances for MonadBase and MonadBaseControl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-p2p" = callPackage @@ -77512,8 +72621,6 @@ self: { executableHaskellDepends = [ base distributed-process mtl ]; description = "Peer-to-peer node discovery for Cloud Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-platform" = callPackage @@ -77544,8 +72651,6 @@ self: { ]; description = "The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-registry" = callPackage @@ -77578,8 +72683,6 @@ self: { ]; description = "Cloud Haskell Extended Process Registry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-simplelocalnet" = callPackage @@ -77602,8 +72705,6 @@ self: { ]; description = "Simple zero-configuration backend for Cloud Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-supervisor" = callPackage @@ -77635,8 +72736,6 @@ self: { ]; description = "Supervisors for The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-systest" = callPackage @@ -77656,8 +72755,6 @@ self: { ]; description = "Cloud Haskell Test Support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-task" = callPackage @@ -77694,8 +72791,6 @@ self: { ]; description = "Task Framework for The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-tests" = callPackage @@ -77719,8 +72814,6 @@ self: { ]; description = "Tests and test support tools for distributed-process"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-process-zookeeper" = callPackage @@ -77749,8 +72842,6 @@ self: { ]; description = "A Zookeeper back-end for Cloud Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributed-static" = callPackage @@ -77779,8 +72870,6 @@ self: { ]; description = "Finite discrete probability distributions"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distribution-nixpkgs" = callPackage @@ -77836,8 +72925,6 @@ self: { ]; description = "Easily plot distributions from the distribution package.."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "distributive" = callPackage @@ -77899,8 +72986,6 @@ self: { ]; description = "Quantify the diversity of a population"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dixi" = callPackage @@ -77938,8 +73023,6 @@ self: { ]; description = "A wiki implemented with a firm theoretical foundation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "djembe" = callPackage @@ -77955,8 +73038,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Hit drums with haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "djinn" = callPackage @@ -78013,8 +73094,6 @@ self: { ]; description = "Generate executable Haskell code from a type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dl-fedora" = callPackage @@ -78037,8 +73116,6 @@ self: { testHaskellDepends = [ base simple-cmd ]; description = "Fedora image download tool"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dlist" = callPackage @@ -78139,8 +73216,6 @@ self: { ]; description = "AVAYA DMCC API bindings and WebSockets server for AVAYA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dmenu" = callPackage @@ -78156,8 +73231,6 @@ self: { ]; description = "Complete bindings to the dmenu and dmenu2 command line tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dmenu-pkill" = callPackage @@ -78175,8 +73248,6 @@ self: { ]; description = "dmenu script for killing applications. Sortable by process id or CPU/MEM usage."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dmenu-pmount" = callPackage @@ -78194,8 +73265,6 @@ self: { ]; description = "Mounting and unmounting linux devices as user with dmenu and pmount"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dmenu-search" = callPackage @@ -78213,8 +73282,6 @@ self: { ]; description = "dmenu script for searching the web with customizable search engines"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dns" = callPackage @@ -78257,8 +73324,6 @@ self: { executableHaskellDepends = [ base ]; description = "Caching DNS resolver library and mass DNS resolver utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dnsrbl" = callPackage @@ -78271,8 +73336,6 @@ self: { libraryHaskellDepends = [ base containers hsdns HUnit network ]; description = "Asynchronous DNS RBL lookup"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dnssd" = callPackage @@ -78285,8 +73348,6 @@ self: { librarySystemDepends = [ dns_sd ]; description = "DNS service discovery bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {dns_sd = null;}; "do-list" = callPackage @@ -78365,8 +73426,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Creates the time intervals for CLI changing messages on the screen"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dobutokO" = callPackage @@ -78529,8 +73588,6 @@ self: { ]; description = "Document review Web application, like http://book.realworldhaskell.org/"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "doccheck" = callPackage @@ -78549,8 +73606,6 @@ self: { ]; description = "Checks Haddock comments for pitfalls and version changes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docidx" = callPackage @@ -78569,8 +73624,6 @@ self: { ]; description = "Generate an HTML index of installed Haskell packages and their documentation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docker" = callPackage @@ -78604,8 +73657,6 @@ self: { ]; description = "An API client for docker written in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docker-build-cacher" = callPackage @@ -78628,8 +73679,6 @@ self: { ]; description = "Builds a docker image and caches all of its intermediate stages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dockercook" = callPackage @@ -78663,8 +73712,6 @@ self: { testHaskellDepends = [ base HTF text vector ]; description = "A build tool for multiple docker image layers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dockerfile" = callPackage @@ -78698,8 +73745,6 @@ self: { th-lift th-lift-instances time ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "doclayout" = callPackage @@ -78738,8 +73783,6 @@ self: { ]; description = "A command-line interface parser that will make you smile"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docrecords" = callPackage @@ -78760,8 +73803,6 @@ self: { ]; description = "Vinyl-based records with hierarchical field names, default values and documentation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docstrings" = callPackage @@ -78906,8 +73947,6 @@ self: { doHaddock = false; description = "Easy way to run doctests via cabal (no aeson dependency, uses configurator instead)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "doctest-driver-gen" = callPackage @@ -78979,8 +74018,6 @@ self: { testHaskellDepends = [ base doctest HUnit QuickCheck ]; description = "Allow QuickCheck-style property testing within doctest"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docusign-base" = callPackage @@ -78997,8 +74034,6 @@ self: { ]; description = "Low-level bindings to the DocuSign API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docusign-base-minimal" = callPackage @@ -79015,8 +74050,6 @@ self: { ]; description = "Low-level bindings to the DocuSign API (only what is necessary for docusign-client)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docusign-client" = callPackage @@ -79036,8 +74069,6 @@ self: { ]; description = "Client bindings for the DocuSign API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docusign-example" = callPackage @@ -79056,8 +74087,6 @@ self: { ]; description = "DocuSign examples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "docvim" = callPackage @@ -79084,8 +74113,6 @@ self: { ]; description = "Documentation generator for Vim plug-ins"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "doi" = callPackage @@ -79114,8 +74141,6 @@ self: { ]; description = "Automatic Bibtex and fulltext of scientific articles"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "doldol" = callPackage @@ -79238,8 +74263,6 @@ self: { ]; description = "Codegen helping you define domain models"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "domain-auth" = callPackage @@ -79274,8 +74297,6 @@ self: { ]; description = "Low-level API of \"domain\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "domain-optics" = callPackage @@ -79294,8 +74315,6 @@ self: { testHaskellDepends = [ domain optics rerebase ]; description = "Integration of domain with optics"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dominion" = callPackage @@ -79327,8 +74346,6 @@ self: { ]; description = "A simple templating library using HTML5 as its template language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dormouse-client" = callPackage @@ -79421,8 +74438,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dot2graphml" = callPackage @@ -79495,8 +74510,6 @@ self: { doHaddock = false; description = "Filesystem to manage and parse dotfiles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dotgen" = callPackage @@ -79587,8 +74600,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Doublify API toolkit for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dove" = callPackage @@ -79645,8 +74656,6 @@ self: { ]; description = "Dungeons of Wor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "download" = callPackage @@ -79689,8 +74698,6 @@ self: { ]; description = "Simple tool to download images from RSS feeds (e.g. Flickr, Picasa)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "downloader" = callPackage @@ -79707,8 +74714,6 @@ self: { ]; description = "A small, low-dependency library that provides turn-key file download over HTTP and HTTPS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dozenal" = callPackage @@ -79720,8 +74725,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A Haskell library for using Dozenal (Duodecimal - Base 12) numbers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dozens" = callPackage @@ -79741,8 +74744,6 @@ self: { ]; description = "dozens api library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-base" = callPackage @@ -79756,8 +74757,6 @@ self: { ]; description = "Data Parallel Haskell common config and debugging functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-examples" = callPackage @@ -79776,8 +74775,6 @@ self: { ]; description = "Data Parallel Haskell example programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-lifted-base" = callPackage @@ -79794,8 +74791,6 @@ self: { ]; description = "Data Parallel Haskell common definitions used by other dph-lifted packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-lifted-copy" = callPackage @@ -79811,8 +74806,6 @@ self: { ]; description = "Data Parallel Haskell lifted array combinators. (deprecated version)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-lifted-vseg" = callPackage @@ -79829,8 +74822,6 @@ self: { ]; description = "Data Parallel Haskell lifted array combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-par" = callPackage @@ -79853,8 +74844,6 @@ self: { libraryHaskellDepends = [ base dph-base random vector ]; description = "Data Parallel Haskell segmented arrays. (abstract interface)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-prim-par" = callPackage @@ -79871,8 +74860,6 @@ self: { ]; description = "Data Parallel Haskell segmented arrays. (production version)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-prim-seq" = callPackage @@ -79888,8 +74875,6 @@ self: { ]; description = "Data Parallel Haskell segmented arrays. (sequential implementation)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dph-seq" = callPackage @@ -79921,8 +74906,6 @@ self: { testPkgconfigDepends = [ libdpkg ]; description = "libdpkg bindings"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) dpkg; libdpkg = null;}; "dpor" = callPackage @@ -79936,8 +74919,6 @@ self: { ]; description = "A generic implementation of dynamic partial-order reduction (DPOR) for testing arbitrary models of concurrency"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dprox" = callPackage @@ -79974,8 +74955,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Monadic FRP"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dragen" = callPackage @@ -79996,8 +74975,6 @@ self: { ]; description = "Automatic derivation of optimized QuickCheck random generators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "drama" = callPackage @@ -80043,8 +75020,6 @@ self: { testHaskellDepends = [ base containers hspec QuickCheck ]; description = "A port of asciimoo's drawille to haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dresdner-verkehrsbetriebe" = callPackage @@ -80067,8 +75042,6 @@ self: { ]; description = "Library and program for querying DVB (Dresdner Verkehrsbetriebe AG)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "drifter" = callPackage @@ -80085,8 +75058,6 @@ self: { ]; description = "Simple schema management for arbitrary databases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "drifter-postgresql" = callPackage @@ -80107,8 +75078,6 @@ self: { ]; description = "PostgreSQL support for the drifter schema migration tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "drifter-sqlite" = callPackage @@ -80128,8 +75097,6 @@ self: { ]; description = "SQLite support for the drifter schema migraiton tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "drinkery" = callPackage @@ -80154,8 +75121,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "A Haskell bindings to the DRMAA C library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {drmaa = null;}; "drone" = callPackage @@ -80174,8 +75139,6 @@ self: { microlens req servant-server text warp ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dropbox" = callPackage @@ -80204,8 +75167,6 @@ self: { ]; description = "Dropbox API client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dropbox-sdk" = callPackage @@ -80227,8 +75188,6 @@ self: { ]; description = "A library to access the Dropbox HTTP API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dropsolve" = callPackage @@ -80247,8 +75206,6 @@ self: { ]; description = "A command line tool for resolving dropbox conflicts. Deprecated! Please use confsolve."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "drunken-bishop" = callPackage @@ -80278,8 +75235,6 @@ self: { testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; description = "A subset of the miniKanren language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dsc" = callPackage @@ -80299,8 +75254,6 @@ self: { ]; description = "Helper functions for setting up Double Submit Cookie defense for forms"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dsh-sql" = callPackage @@ -80328,8 +75281,6 @@ self: { ]; description = "SQL backend for Database Supported Haskell (DSH)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dsmc" = callPackage @@ -80347,8 +75298,6 @@ self: { ]; description = "DSMC library for rarefied gas dynamics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dsmc-tools" = callPackage @@ -80368,8 +75317,6 @@ self: { ]; description = "DSMC toolkit for rarefied gas dynamics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dson" = callPackage @@ -80381,8 +75328,6 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "Haskell Doge Serialized Object Notation Parser"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dson-parsec" = callPackage @@ -80394,8 +75339,6 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "DSON parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dsp" = callPackage @@ -80421,8 +75364,6 @@ self: { libraryHaskellDepends = [ base base-unicode-symbols dlist ]; description = "Difference strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dsv" = callPackage @@ -80484,8 +75425,6 @@ self: { ]; description = "Parse and render DTD files (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dtd-text" = callPackage @@ -80501,8 +75440,6 @@ self: { ]; description = "Parse and render XML DTDs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dtd-types" = callPackage @@ -80544,8 +75481,6 @@ self: { ]; description = "(Fast) Dynamic Time Warping"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dual" = callPackage @@ -80612,8 +75547,6 @@ self: { ]; description = "Automatically generate dual constructions"; license = "AGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dublincore-xml-conduit" = callPackage @@ -80698,8 +75631,6 @@ self: { ]; description = "A tiny language, a subset of Haskell (with type classes) aimed at aiding teachers to teach Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dumb-cas" = callPackage @@ -80717,8 +75648,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "A computer “algebra” system that knows nothing about algebra, at the core"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dump" = callPackage @@ -80756,8 +75685,6 @@ self: { ]; description = "A plug-in for rendering GHC core"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dunai" = callPackage @@ -80789,8 +75716,6 @@ self: { ]; description = "Generalised reactive framework supporting classic, arrowized and monadic FRP. (Core library fork.)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dunai-test" = callPackage @@ -80840,8 +75765,6 @@ self: { ]; description = "Frontend development build tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dura" = callPackage @@ -80855,8 +75778,6 @@ self: { libraryHaskellDepends = [ base bytestring directory filepath ]; description = "durable/atomic file system writes (from rio package)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "duration" = callPackage @@ -80913,8 +75834,6 @@ self: { ]; description = "Dead simple password manager"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dvda" = callPackage @@ -80937,8 +75856,6 @@ self: { ]; description = "Efficient automatic differentiation and code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dvdread" = callPackage @@ -80952,8 +75869,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "A monadic interface to libdvdread"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {dvdread = null;}; "dvi-processing" = callPackage @@ -80965,8 +75880,6 @@ self: { libraryHaskellDepends = [ base bytestring filepath transformers ]; description = "Read/write DVI and TFM file"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dvorak" = callPackage @@ -80991,8 +75904,6 @@ self: { libraryHaskellDepends = [ base binary bytestring containers ]; description = "Parser for DWARF debug format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dwarf-el" = callPackage @@ -81027,8 +75938,6 @@ self: { executableHaskellDepends = [ base containers dwarf-el ]; description = "High-level wrapper around the dwarf library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dwergaz" = callPackage @@ -81095,8 +76004,6 @@ self: { testHaskellDepends = [ ansi-terminal base hspec text ]; description = "A library for working with binary Dyck words"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dyepack" = callPackage @@ -81110,8 +76017,6 @@ self: { libraryHaskellDepends = [ base generics-sop ]; description = "Programatically identify space leaks in your program"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynamic" = callPackage @@ -81149,8 +76054,6 @@ self: { ]; description = "Access the functions from the Cabal library without depending on it"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynamic-graph" = callPackage @@ -81194,8 +76097,6 @@ self: { benchmarkHaskellDepends = [ base criterion primitive ]; description = "Dynamic graph algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynamic-linker-template" = callPackage @@ -81234,8 +76135,6 @@ self: { libraryHaskellDepends = [ base primitive vector ]; description = "A wrapper around MVector that enables pushing, popping and extending"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynamic-object" = callPackage @@ -81254,8 +76153,6 @@ self: { ]; description = "Object-oriented programming with duck typing and singleton classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynamic-plot" = callPackage @@ -81282,8 +76179,6 @@ self: { ]; description = "Interactive diagram windows"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynamic-pp" = callPackage @@ -81304,8 +76199,6 @@ self: { ]; description = "A pretty-print library that employs a dynamic programming algorithm for optimal rendering"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynamic-state" = callPackage @@ -81348,8 +76241,6 @@ self: { ]; description = "Typesafe library for working with DynamoDB database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynloader" = callPackage @@ -81362,8 +76253,6 @@ self: { testHaskellDepends = [ base ghc ghc-paths hspec ]; description = "Dynamically runtime loading packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dynobud" = callPackage @@ -81395,8 +76284,6 @@ self: { ]; description = "your dynamic optimization buddy"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dyre" = callPackage @@ -81442,8 +76329,6 @@ self: { libraryHaskellDepends = [ base bytestring transformers ]; description = "Bindings to the dywapitchtrack pitch tracking library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dzen-dhall" = callPackage @@ -81479,8 +76364,6 @@ self: { ]; description = "Configure dzen2 bars in Dhall language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "dzen-utils" = callPackage @@ -81492,8 +76375,6 @@ self: { libraryHaskellDepends = [ base colour process ]; description = "Utilities for creating inputs for dzen"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "each" = callPackage @@ -81507,8 +76388,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Template Haskell library for writing monadic expressions more easily"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eager-sockets" = callPackage @@ -81555,8 +76434,6 @@ self: { testHaskellDepends = [ base filepath hspec ]; description = "Ear Clipping Triangulation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "earcut" = callPackage @@ -81589,8 +76466,6 @@ self: { testHaskellDepends = [ base ]; description = "Early return syntax in do-notation (GHC plugin)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ease" = callPackage @@ -81617,8 +76492,6 @@ self: { ]; description = "Utility code for building HTTP API bindings more quickly"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "easy-args" = callPackage @@ -81648,8 +76521,6 @@ self: { ]; description = "types and functions for bitcoin applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "easy-file" = callPackage @@ -81676,8 +76547,6 @@ self: { ]; description = "Haskell JSON library with an emphasis on simplicity, minimal dependencies, and ease of use"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "easyplot" = callPackage @@ -81689,8 +76558,6 @@ self: { libraryHaskellDepends = [ base process ]; description = "A tiny plotting library, utilizes gnuplot for plotting"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "easyrender" = callPackage @@ -81723,8 +76590,6 @@ self: { ]; description = "Pure, type-indexed haskell vector, matrix, and tensor library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "easytensor-vulkan" = callPackage @@ -81736,8 +76601,6 @@ self: { libraryHaskellDepends = [ base dimensions easytensor vulkan-api ]; description = "Use easytensor with vulkan-api"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "easytest" = callPackage @@ -81757,8 +76620,6 @@ self: { ]; description = "Simple, expressive testing library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ebeats" = callPackage @@ -81770,8 +76631,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "Time in ebeats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ebnf-bff" = callPackage @@ -81790,8 +76649,6 @@ self: { ]; description = "Parser combinators & EBNF, BFFs!"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ec2-signature" = callPackage @@ -81830,8 +76687,6 @@ self: { ]; description = "A handy tool for uploading unikernels to Amazon's EC2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eccrypto" = callPackage @@ -81850,8 +76705,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion random ]; description = "Elliptic Curve Cryptography for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eccrypto-ed25519-bindings" = callPackage @@ -81863,8 +76716,6 @@ self: { libraryHaskellDepends = [ base bytestring eccrypto ]; description = "provides \"ed25519\" API using \"eccrypto\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ecdsa" = callPackage @@ -81912,8 +76763,6 @@ self: { executableHaskellDepends = [ base ]; description = "A ECMA-262 interpreter library"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ecstasy" = callPackage @@ -81947,8 +76796,6 @@ self: { executableSystemDepends = [ canlib ]; description = "Tools for automotive ECU development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {canlib = null;}; "ed25519" = callPackage @@ -81996,8 +76843,6 @@ self: { ]; description = "Command line file filtering with haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ede" = callPackage @@ -82029,8 +76874,6 @@ self: { ]; description = "Templating language with similar syntax and features to Liquid or Jinja2"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edenmodules" = callPackage @@ -82042,8 +76885,6 @@ self: { libraryHaskellDepends = [ base containers deepseq parallel ]; description = "Semi-explicit parallel programming library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edenskel" = callPackage @@ -82055,8 +76896,6 @@ self: { libraryHaskellDepends = [ base edenmodules parallel ]; description = "Semi-explicit parallel programming skeleton library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edentv" = callPackage @@ -82077,8 +76916,6 @@ self: { ]; description = "A Tool to Visualize Parallel Functional Program Executions"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edf" = callPackage @@ -82108,8 +76945,6 @@ self: { ]; description = "Top view space combat arcade game"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edges" = callPackage @@ -82137,8 +76972,6 @@ self: { ]; description = "Tools for efficient immutable graphs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edis" = callPackage @@ -82150,8 +76983,6 @@ self: { libraryHaskellDepends = [ base bytestring cereal hedis ]; description = "Statically typechecked client for Redis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edit" = callPackage @@ -82172,8 +77003,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A monad for rewriting things"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edit-distance" = callPackage @@ -82245,8 +77074,6 @@ self: { ]; description = "Symmetric, stateful edit lenses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "edit-lenses-demo" = callPackage @@ -82271,8 +77098,6 @@ self: { libraryHaskellDepends = [ base text vty vty-ui ]; description = "Interactive editors for Generics"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "editline" = callPackage @@ -82284,8 +77109,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Bindings to the editline library (libedit)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "editor-open" = callPackage @@ -82343,8 +77166,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A library for writing extensible algebraic effects and handlers. Similar to extensible-effects but with deep handlers."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "effect-monad" = callPackage @@ -82356,8 +77177,6 @@ self: { libraryHaskellDepends = [ base type-level-sets ]; description = "Embeds effect systems and program logics into Haskell using graded monads and parameterised monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "effect-stack" = callPackage @@ -82369,8 +77188,6 @@ self: { libraryHaskellDepends = [ base constraints mtl transformers ]; description = "Reducing the pain of transformer stacks with duplicated effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "effective-aspects" = callPackage @@ -82466,8 +77283,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A Typeable-free implementation of extensible effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "egison" = callPackage @@ -82503,8 +77318,6 @@ self: { benchmarkHaskellDepends = [ base criterion transformers ]; description = "Programming language with non-linear pattern-matching against non-free data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "egison-pattern-src" = callPackage @@ -82526,8 +77339,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Manipulating Egison patterns: abstract syntax, parser, and pretty-printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "egison-pattern-src-haskell-mode" = callPackage @@ -82547,8 +77358,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Parser and pretty printer for Egison pattern expressions in Haskell source code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "egison-pattern-src-th-mode" = callPackage @@ -82571,8 +77380,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Parser and pretty printer for Egison pattern expressions to use with TH"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "egison-quote" = callPackage @@ -82586,8 +77393,6 @@ self: { ]; description = "A quasi quotes for using Egison expression in Haskell code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "egison-tutorial" = callPackage @@ -82606,8 +77411,6 @@ self: { ]; description = "A tutorial program for the Egison programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "egyptian-fractions" = callPackage @@ -82637,8 +77440,6 @@ self: { ]; description = "like eruby, ehaskell is embedded haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ehs" = callPackage @@ -82659,8 +77460,6 @@ self: { ]; description = "Embedded haskell template using quasiquotes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eibd-client-simple" = callPackage @@ -82679,8 +77478,6 @@ self: { librarySystemDepends = [ eibclient ]; description = "EIBd Client"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {eibclient = null;}; "eigen" = callPackage @@ -82700,8 +77497,6 @@ self: { ]; description = "Eigen C++ library (linear algebra: matrices, sparse matrices, vectors, numerical solvers)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eio" = callPackage @@ -82717,8 +77512,6 @@ self: { executableToolDepends = [ markdown-unlit ]; description = "IO with Exceptions tracked on the type-level"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "either" = callPackage @@ -82763,8 +77556,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Functions involving lists of Either"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "either-result" = callPackage @@ -82793,8 +77584,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Functions for probing and unwrapping values inside of Either"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eithers" = callPackage @@ -82826,8 +77615,6 @@ self: { ]; description = "Binding to EJDB2 C library, an embedded JSON noSQL database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ejdb2 = null; libejdb2 = null;}; "ekg" = callPackage @@ -82865,8 +77652,6 @@ self: { ]; description = "Send ekg metrics to a Bosun instance"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-carbon" = callPackage @@ -82883,8 +77668,6 @@ self: { ]; description = "An EKG backend to send statistics to Carbon (part of Graphite monitoring tools)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-cloudwatch" = callPackage @@ -82902,8 +77685,6 @@ self: { ]; description = "An ekg backend for Amazon Cloudwatch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-core" = callPackage @@ -82938,8 +77719,6 @@ self: { ]; description = "Push metrics to elastic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-elasticsearch" = callPackage @@ -82957,8 +77736,6 @@ self: { ]; description = "Push metrics to elasticsearch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-influxdb" = callPackage @@ -83007,8 +77784,6 @@ self: { ]; description = "Push metrics to a log file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-prometheus-adapter" = callPackage @@ -83045,8 +77820,6 @@ self: { ]; description = "Small framework to push metric deltas to a broadcast channel using the ekg-core library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-rrd" = callPackage @@ -83067,8 +77840,6 @@ self: { ]; description = "Passes ekg statistics to rrdtool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ekg-statsd" = callPackage @@ -83104,8 +77875,6 @@ self: { ]; description = "Remote monitoring of processes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elbow" = callPackage @@ -83168,8 +77937,6 @@ self: { executableHaskellDepends = [ base elerea GLFW OpenGL ]; description = "Example applications for Elerea"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elerea-sdl" = callPackage @@ -83193,8 +77960,6 @@ self: { libraryHaskellDepends = [ base extensible transformers ]; description = "Immediately lifts to a desired level"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elf" = callPackage @@ -83260,8 +78025,6 @@ self: { executableHaskellDepends = [ base ]; description = "Arrows with holes"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elliptic-curve" = callPackage @@ -83287,8 +78050,6 @@ self: { ]; description = "Elliptic curve library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elm-bridge" = callPackage @@ -83612,8 +78373,6 @@ self: { doHaddock = false; description = "Crossing the road between Haskell and Elm"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elm-syntax" = callPackage @@ -83663,8 +78422,6 @@ self: { ]; description = "Generate ELM code from a Wai websocket application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elm-yesod" = callPackage @@ -83779,8 +78536,6 @@ self: { testHaskellDepends = [ base directory filepath tasty tasty-hunit ]; description = "A tiny language for understanding the lambda-calculus"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elynx" = callPackage @@ -83798,8 +78553,6 @@ self: { ]; description = "Validate and (optionally) redo ELynx analyses"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "elynx-markov" = callPackage @@ -83900,8 +78653,6 @@ self: { ]; description = "Handle phylogenetic trees"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ema" = callPackage @@ -83950,8 +78701,6 @@ self: { ]; description = "library to parse emacs style keybinding into the modifiers and the chars"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "emacs-module" = callPackage @@ -83971,8 +78720,6 @@ self: { ]; description = "Utilities to write Emacs dynamic modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "email" = callPackage @@ -83989,8 +78736,6 @@ self: { ]; description = "Sending eMail in Haskell made easy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "email-header" = callPackage @@ -84012,8 +78757,6 @@ self: { ]; description = "Parsing and rendering of email and MIME headers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "email-postmark" = callPackage @@ -84029,8 +78772,6 @@ self: { ]; description = "A simple wrapper to send emails via the api of the service postmark (http://postmarkapp.com/)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "email-validate" = callPackage @@ -84103,8 +78844,6 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "Wrapper around email-validate library adding instances for common type classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "emailparse" = callPackage @@ -84127,8 +78866,6 @@ self: { ]; description = "An email parser that will parse everything"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "embeddock" = callPackage @@ -84145,8 +78882,6 @@ self: { ]; description = "Embed the values in scope in the haddock documentation of the module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "embeddock-example" = callPackage @@ -84158,8 +78893,6 @@ self: { libraryHaskellDepends = [ base embeddock time ]; description = "Example of using embeddock"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "embla" = callPackage @@ -84171,8 +78904,6 @@ self: { libraryHaskellDepends = [ base chronos ]; description = "execute actions periodically while avoiding drift"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "embroidery" = callPackage @@ -84191,8 +78922,6 @@ self: { executableHaskellDepends = [ base ]; description = "support for embroidery formats in haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "emd" = callPackage @@ -84235,8 +78964,6 @@ self: { testHaskellDepends = [ base HUnit QuickCheck syb ]; description = "Extensible and Modular Generics for the Masses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "emoji" = callPackage @@ -84289,8 +79016,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A container that always has no values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enchant" = callPackage @@ -84307,8 +79032,6 @@ self: { testHaskellDepends = [ base ]; description = "Binding to the Enchant library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) enchant;}; "enclosed-exceptions" = callPackage @@ -84366,8 +79089,6 @@ self: { testHaskellDepends = [ base bytestring HUnit QuickCheck ]; description = "A library for various character encodings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "encoding-io" = callPackage @@ -84381,8 +79102,6 @@ self: { ]; description = "Encoding-aware file I/O"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "encryptable" = callPackage @@ -84406,8 +79125,6 @@ self: { ]; description = "Typed encryption with persistent support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "endo" = callPackage @@ -84462,8 +79179,6 @@ self: { ]; description = "A Haskell implementation of Engine.IO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "engine-io-growler" = callPackage @@ -84482,8 +79197,6 @@ self: { unordered-containers wai wai-websockets websockets ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "engine-io-snap" = callPackage @@ -84500,8 +79213,6 @@ self: { snap-core unordered-containers websockets websockets-snap ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "engine-io-wai" = callPackage @@ -84520,8 +79231,6 @@ self: { ]; description = "An @engine-io@ @ServerAPI@ that is compatible with @Wai@"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "engine-io-yesod" = callPackage @@ -84538,8 +79247,6 @@ self: { unordered-containers wai wai-websockets websockets yesod-core ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "engineering-units" = callPackage @@ -84567,8 +79274,6 @@ self: { executableHaskellDepends = [ base matrix quipper-core ]; description = "An application (and library) to convert quipper circuits into Qpmc models"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "entropy" = callPackage @@ -84612,8 +79317,6 @@ self: { ]; description = "entwine - Concurrency tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enum-subset-generate" = callPackage @@ -84646,8 +79349,6 @@ self: { ]; description = "A text rendering and parsing toolkit for enumerated types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enum-text-rio" = callPackage @@ -84664,8 +79365,6 @@ self: { ]; description = "Making fmt available with rio"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enum-types" = callPackage @@ -84693,8 +79392,6 @@ self: { ]; description = "An experimental Utf8 parsing toolkit for enumerated types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enumerable" = callPackage @@ -84725,8 +79422,6 @@ self: { executableHaskellDepends = [ base ]; description = "enumerate all the values in a finite type (automatically)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enumerate-function" = callPackage @@ -84747,8 +79442,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "simple package for inverting functions and testing totality, via brute enumeration of the domain"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enumeration" = callPackage @@ -84781,8 +79474,6 @@ self: { ]; description = "Reliable, high-performance processing with left-fold enumerators"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enumerator-fd" = callPackage @@ -84794,8 +79485,6 @@ self: { libraryHaskellDepends = [ base enumerator mtl ]; description = "Enumerator instances for monads-fd classes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enumerator-tf" = callPackage @@ -84807,8 +79496,6 @@ self: { libraryHaskellDepends = [ base enumerator monads-tf ]; description = "Enumerator instances for monads-tf classes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enumfun" = callPackage @@ -84820,8 +79507,6 @@ self: { libraryHaskellDepends = [ base enummapset-th ]; description = "Finitely represented /total/ EnumMaps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enummapmap" = callPackage @@ -84846,8 +79531,6 @@ self: { ]; description = "Map of maps using Enum types as keys"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "enummaps" = callPackage @@ -84922,8 +79605,6 @@ self: { ]; description = "Safe helpers for accessing and modifying environment variables"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "env-locale" = callPackage @@ -84953,8 +79634,6 @@ self: { ]; description = "Pull configuration information from the ENV"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "envelope" = callPackage @@ -85002,8 +79681,6 @@ self: { ]; description = "Display efficiently the state of the local environment"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "envy" = callPackage @@ -85053,8 +79730,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell binding for EPANET"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "epass" = callPackage @@ -85066,8 +79741,6 @@ self: { libraryHaskellDepends = [ base stm time ]; description = "Baisc, Erlang-like message passing supporting sockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ephemeral" = callPackage @@ -85090,8 +79763,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "epi-sim" = callPackage @@ -85110,8 +79781,6 @@ self: { ]; description = "A library for simulating epidemics as birth-death processes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "epic" = callPackage @@ -85129,8 +79798,6 @@ self: { ]; description = "Compiler for a simple functional language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "epoll" = callPackage @@ -85144,8 +79811,6 @@ self: { libraryHaskellDepends = [ base unix ]; description = "epoll bindings"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eprocess" = callPackage @@ -85158,8 +79823,6 @@ self: { libraryHaskellDepends = [ base exceptions mtl ]; description = "Basic Erlang-like process support for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "epub" = callPackage @@ -85237,8 +79900,6 @@ self: { ]; description = "Rename epub ebook files based on meta information"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eq" = callPackage @@ -85298,8 +79959,6 @@ self: { ]; description = "Proof assistant for Haskell using DataKinds & PolyKinds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "equeue" = callPackage @@ -85321,8 +79980,6 @@ self: { ]; description = "Application level triggered, and edge triggered event multiqueues"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "equivalence" = callPackage @@ -85388,8 +80045,6 @@ self: { libraryHaskellDepends = [ base polynomial ]; description = "Native Haskell implementation of the interface from the erf package"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "erlang" = callPackage @@ -85405,8 +80060,6 @@ self: { ]; description = "FFI interface to Erlang"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "erlang-ffi" = callPackage @@ -85426,8 +80079,6 @@ self: { ]; description = "Send messages to an Erlang node using Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eros" = callPackage @@ -85440,8 +80091,6 @@ self: { libraryHaskellDepends = [ aeson base bytestring containers text ]; description = "A text censorship library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eros-client" = callPackage @@ -85460,8 +80109,6 @@ self: { ]; description = "DEPRECATED in favor of eros-http"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eros-http" = callPackage @@ -85481,8 +80128,6 @@ self: { ]; description = "JSON HTTP interface to Eros"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "errata" = callPackage @@ -85536,8 +80181,6 @@ self: { testHaskellDepends = [ base ]; description = "Error code functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "error-context" = callPackage @@ -85560,8 +80203,6 @@ self: { ]; description = "Provides API for enriching errors with contexts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "error-continuations" = callPackage @@ -85573,8 +80214,6 @@ self: { libraryHaskellDepends = [ base either mtl transformers ]; description = "Error Continuations"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "error-list" = callPackage @@ -85586,8 +80225,6 @@ self: { libraryHaskellDepends = [ base mtl text text-render ]; description = "A useful type for collecting error messages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "error-loc" = callPackage @@ -85599,8 +80236,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "An error replacement with call-site metadata"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "error-location" = callPackage @@ -85627,8 +80262,6 @@ self: { ]; description = "Composable error messages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "error-or" = callPackage @@ -85662,8 +80295,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Set of utils and operators for error handling"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "errorcall-eq-instance" = callPackage @@ -85710,8 +80341,6 @@ self: { ]; description = "`bracket`-like functions for `ExceptT` over `IO` monad"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ersaconcat" = callPackage @@ -85735,8 +80364,6 @@ self: { ]; description = "A script to concatenate AIP ERSA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ersatz" = callPackage @@ -85761,8 +80388,6 @@ self: { testHaskellDepends = [ array base ]; description = "A monad for expressing SAT or QSAT problems using observable sharing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ersatz-toysat" = callPackage @@ -85780,8 +80405,6 @@ self: { ]; description = "toysat driver as backend for ersatz"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ert" = callPackage @@ -85804,8 +80427,6 @@ self: { ]; description = "Easy Runtime Templates"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "escape-artist" = callPackage @@ -85822,8 +80443,6 @@ self: { ]; description = "ANSI Escape Sequence Text Decoration Made Easy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "escaped" = callPackage @@ -85871,8 +80490,6 @@ self: { doHaddock = false; description = "Terminal fuzzy selector"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "esotericbot" = callPackage @@ -85896,8 +80513,6 @@ self: { doHaddock = false; description = "Esotericbot is a sophisticated, lightweight IRC bot"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "espial" = callPackage @@ -85962,8 +80577,6 @@ self: { ]; description = "Espial is an open-source, web-based bookmarking server"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "esqueleto" = callPackage @@ -86036,8 +80649,6 @@ self: { libraryHaskellDepends = [ base ]; description = "The type-level S combinator in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "essence-of-live-coding" = callPackage @@ -86193,8 +80804,6 @@ self: { ]; description = "Tool for managing probability estimation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "estreps" = callPackage @@ -86211,8 +80820,6 @@ self: { ]; description = "Repeats from ESTs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "etc" = callPackage @@ -86265,8 +80872,6 @@ self: { ]; description = "everything breaking the Fairbairn threshold"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eternity" = callPackage @@ -86287,8 +80892,6 @@ self: { ]; description = "Native event-sourcing database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eternity-timestamped" = callPackage @@ -86306,8 +80909,6 @@ self: { ]; description = "Automatic timestamping for Eternity"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ether" = callPackage @@ -86336,8 +80937,6 @@ self: { ]; description = "Monad transformers and classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ethereum-analyzer" = callPackage @@ -86361,8 +80960,6 @@ self: { ]; description = "A Ethereum contract analyzer"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ethereum-analyzer-cli" = callPackage @@ -86390,8 +80987,6 @@ self: { ]; description = "A CLI frontend for ethereum-analyzer"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ethereum-analyzer-deps" = callPackage @@ -86437,8 +81032,6 @@ self: { ]; description = "A web frontend for ethereum-analyzer"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ethereum-client-haskell" = callPackage @@ -86467,8 +81060,6 @@ self: { ]; description = "A Haskell version of an Ethereum client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ethereum-merkle-patricia-db" = callPackage @@ -86493,8 +81084,6 @@ self: { ]; description = "A modified Merkle Patricia DB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ethereum-rlp" = callPackage @@ -86513,8 +81102,6 @@ self: { ]; description = "Ethereum Recursive Length Prefix Encoding"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eths-rlp" = callPackage @@ -86611,8 +81198,6 @@ self: { ]; description = "Dynamic network FRP with events and continuous values"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eurofxref" = callPackage @@ -86630,8 +81215,6 @@ self: { ]; description = "Free foreign exchange/currency feed from the European Central Bank"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "evdev" = callPackage @@ -86655,8 +81238,6 @@ self: { ]; description = "Bindings to libevdev"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libevdev;}; "evdev-streamly" = callPackage @@ -86675,8 +81256,6 @@ self: { ]; description = "Bridge for working with evdev and streamly"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eve" = callPackage @@ -86711,8 +81290,6 @@ self: { ]; testHaskellDepends = [ base bytestring eve lens mtl text vty ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eveff" = callPackage @@ -86737,8 +81314,6 @@ self: { ]; description = "Monoidal, monadic and first-class events"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "event-driven" = callPackage @@ -86750,8 +81325,6 @@ self: { libraryHaskellDepends = [ base monads-tf yjtools ]; description = "library for event driven programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "event-handlers" = callPackage @@ -86798,8 +81371,6 @@ self: { ]; description = "Event-graph simulation monad transformer"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "event-transformer" = callPackage @@ -86860,8 +81431,6 @@ self: { ]; description = "Library for eventful DynamoDB event stores"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eventful-memory" = callPackage @@ -86903,8 +81472,6 @@ self: { ]; description = "Postgres implementations for eventful"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eventful-sql-common" = callPackage @@ -86923,8 +81490,6 @@ self: { ]; description = "Common library for SQL event stores"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eventful-sqlite" = callPackage @@ -86947,8 +81512,6 @@ self: { ]; description = "SQLite implementations for eventful"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eventful-test-helpers" = callPackage @@ -86987,8 +81550,6 @@ self: { executableHaskellDepends = [ aeson base filepath text ]; description = "Visualise an eventlog"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eventloop" = callPackage @@ -87007,8 +81568,6 @@ self: { ]; description = "A different take on an IO system. Based on Amanda's IO loop, this eventloop takes a function that maps input events to output events. It can easily be extended by modules that represent IO devices or join multiple modules together."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eventsource-api" = callPackage @@ -87052,8 +81611,6 @@ self: { ]; description = "GetEventStore store implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "eventsource-store-specs" = callPackage @@ -87184,8 +81741,6 @@ self: { description = "EventStore TCP Client"; license = lib.licenses.bsd3; platforms = [ "x86_64-darwin" "x86_64-linux" ]; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "every" = callPackage @@ -87208,8 +81763,6 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "A functional pearl on encoding and decoding using question-and-answer strategies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ewe" = callPackage @@ -87229,8 +81782,6 @@ self: { executableToolDepends = [ alex happy uuagc ]; description = "An interpreter for EWE programming language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ex-pool" = callPackage @@ -87271,8 +81822,6 @@ self: { testHaskellDepends = [ base containers tasty tasty-hunit ]; description = "Efficient exact cover solver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exact-pi" = callPackage @@ -87322,8 +81871,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Framework for Exact Real Arithmetic in the Positional Number System"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "example-haskell-project" = callPackage @@ -87351,8 +81898,6 @@ self: { libraryHaskellDepends = [ base exceptions transformers ]; description = "Safely deal with exceptions in ExceptT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exception-hierarchy" = callPackage @@ -87390,8 +81935,6 @@ self: { ]; description = "Exception monad transformer instances for monads-fd classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exception-monads-tf" = callPackage @@ -87459,8 +82002,6 @@ self: { libraryHaskellDepends = [ base exceptions ]; description = "Essentially the Maybe type with error messages"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exceptionfree-readfile" = callPackage @@ -87476,8 +82017,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "An exception-free readFile for use with '+RTS -xc -RTS' projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exceptions_0_10_4" = callPackage @@ -87529,8 +82068,6 @@ self: { ]; description = "A Haskell client for https://exchangeratesapi.io/"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "execs" = callPackage @@ -87545,8 +82082,6 @@ self: { executableHaskellDepends = [ base directory process text ]; description = "Tool to run stack exec prj-exe more easy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "executable-hash" = callPackage @@ -87594,8 +82129,6 @@ self: { testHaskellDepends = [ async base doctest hspec process ]; description = "Shell helpers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exference" = callPackage @@ -87626,8 +82159,6 @@ self: { ]; description = "Tool to search/generate (haskell) expressions with a given type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exh" = callPackage @@ -87653,8 +82184,6 @@ self: { ]; description = "A library for crawling exhentai"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exhaustive" = callPackage @@ -87693,8 +82222,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Exheres generator for cabal packages"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exif" = callPackage @@ -87707,8 +82234,6 @@ self: { librarySystemDepends = [ exif ]; description = "A Haskell binding to a subset of libexif"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) exif;}; "exiftool" = callPackage @@ -87751,8 +82276,6 @@ self: { ]; description = "database schema for exigo marking/assessment tools"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exinst" = callPackage @@ -87842,8 +82365,6 @@ self: { libraryHaskellDepends = [ base constraints deepseq exinst ]; description = "Derive instances for the `deepseq` library for your existential types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exinst-hashable" = callPackage @@ -87857,8 +82378,6 @@ self: { ]; description = "Derive instances for the `hashable` library for your existential types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exinst-serialise" = callPackage @@ -87936,8 +82455,6 @@ self: { libraryHaskellDepends = [ base contravariant ]; description = "Existential datatypes holding evidence of constraints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exit-codes" = callPackage @@ -87969,8 +82486,6 @@ self: { ]; description = "Monad transformer for exit codes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exomizer" = callPackage @@ -88033,8 +82548,6 @@ self: { libraryHaskellDepends = [ base ]; description = "floating point with extended exponent range"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exp-pairs" = callPackage @@ -88072,8 +82585,6 @@ self: { ]; description = "Extensible Pandoc"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "expat-enumerator" = callPackage @@ -88089,8 +82600,6 @@ self: { ]; description = "Enumerator-based API for Expat"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "experimenter" = callPackage @@ -88164,8 +82673,6 @@ self: { ]; description = "Expiring containers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "expiring-mvar" = callPackage @@ -88192,8 +82699,6 @@ self: { ]; description = "Show how expressions are parsed"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "explicit-constraint-lens" = callPackage @@ -88208,8 +82713,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Fully-flexible polymorphic lenses, without any bizarre profunctors"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "explicit-determinant" = callPackage @@ -88221,8 +82724,6 @@ self: { libraryHaskellDepends = [ base ]; description = "explicit computation of determinant of small matrices"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "explicit-exception" = callPackage @@ -88247,8 +82748,6 @@ self: { libraryHaskellDepends = [ base base-unicode-symbols tagged ]; description = "File handles with explicit IOModes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "explicit-iomodes-bytestring" = callPackage @@ -88260,8 +82759,6 @@ self: { libraryHaskellDepends = [ base bytestring explicit-iomodes ]; description = "Extends explicit-iomodes with ByteString operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "explicit-iomodes-text" = callPackage @@ -88273,8 +82770,6 @@ self: { libraryHaskellDepends = [ base explicit-iomodes text ]; description = "Extends explicit-iomodes with Text operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "explicit-sharing" = callPackage @@ -88288,8 +82783,6 @@ self: { ]; description = "Explicit Sharing of Monadic Effects"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "explore" = callPackage @@ -88303,8 +82796,6 @@ self: { executableHaskellDepends = [ array base directory pngload ]; description = "Experimental Plot data Reconstructor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "exploring-interpreters" = callPackage @@ -88336,8 +82827,6 @@ self: { ]; description = "A distribution of the 'containers' package, with all modules exposed"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "express" = callPackage @@ -88362,8 +82851,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Generalization of parsec's expression parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "expressions" = callPackage @@ -88381,8 +82868,6 @@ self: { testHaskellDepends = [ base singletons text ]; description = "Expressions and Formulae a la carte"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "expressions-z3" = callPackage @@ -88401,8 +82886,6 @@ self: { ]; description = "Encode and Decode expressions from Z3 ASTs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "expresso" = callPackage @@ -88431,8 +82914,6 @@ self: { ]; description = "A simple expressions language based on row types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extcore" = callPackage @@ -88450,8 +82931,6 @@ self: { ]; description = "Libraries for processing GHC Core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extemp" = callPackage @@ -88474,8 +82953,6 @@ self: { ]; description = "automated printing for extemp speakers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extend-record-data-th" = callPackage @@ -88499,8 +82976,6 @@ self: { libraryHaskellDepends = [ base constraints ghc-prim tagged ]; description = "Extended Categories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extended-containers" = callPackage @@ -88578,8 +83053,6 @@ self: { ]; description = "Sums/products/lists/trees which can be extended in other modules"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extensible-effects" = callPackage @@ -88639,8 +83112,6 @@ self: { ]; description = "Message passing concurrency as extensible-effect"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extensible-exceptions" = callPackage @@ -88670,8 +83141,6 @@ self: { testHaskellDepends = [ base extensible ]; description = "Operational-based extensible effect library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extensible-sp" = callPackage @@ -88723,8 +83192,6 @@ self: { ]; description = "Sort large arrays on your hard drive. Kind of like the unix util sort."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extra" = callPackage @@ -88763,8 +83230,6 @@ self: { ]; description = "Given a hackage package outputs the list of its dependencies"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extractable-singleton" = callPackage @@ -88794,8 +83259,6 @@ self: { ]; description = "Extract an ELF's metadata and sections into files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extralife" = callPackage @@ -88811,8 +83274,6 @@ self: { ]; description = "API Client for ExtraLife team and user data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "extrapolate" = callPackage @@ -88852,8 +83313,6 @@ self: { ]; description = "A high level static library for working with CouchDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ez3" = callPackage @@ -88867,8 +83326,6 @@ self: { libraryHaskellDepends = [ base transformers z3 ]; description = "Z3 bonds with pure interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "f-algebra-gen" = callPackage @@ -88880,8 +83337,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Generate a special f-algebra combinator from any data type"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "f-ree-hack-cheats-free-v-bucks-generator" = callPackage @@ -88897,8 +83352,6 @@ self: { executableHaskellDepends = [ base ]; description = "Spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "faceted" = callPackage @@ -88910,8 +83363,6 @@ self: { libraryHaskellDepends = [ base free ]; description = "Faceted computation for dynamic information flow security"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "factor" = callPackage @@ -88960,8 +83411,6 @@ self: { ]; description = "Rational arithmetic in an irrational world"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "facts" = callPackage @@ -88975,8 +83424,6 @@ self: { libraryHaskellDepends = [ base exceptions mtl template-haskell ]; description = "Refined types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "factual-api" = callPackage @@ -88994,8 +83441,6 @@ self: { ]; description = "A driver for the Factual API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fad" = callPackage @@ -89027,8 +83472,6 @@ self: { ]; description = "Minimal library for music generation and notation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fadno-braids" = callPackage @@ -89045,8 +83488,6 @@ self: { ]; description = "Braid representations in Haskell"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fadno-xml" = callPackage @@ -89061,8 +83502,6 @@ self: { ]; description = "XML/XSD combinators/schemas/codegen"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fail" = callPackage @@ -89096,8 +83535,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A list-like type for lazy streams, which might terminate with an error"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "failure" = callPackage @@ -89125,8 +83562,6 @@ self: { ]; description = "Failure Detectors implimented in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fair" = callPackage @@ -89172,8 +83607,6 @@ self: { testHaskellDepends = [ base hspec lens random text time ]; description = "Randomly generated fake data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fake-type" = callPackage @@ -89186,8 +83619,6 @@ self: { librarySystemDepends = [ libXtst ]; description = "A crossplatform library to simulate keyboard input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs.xorg) libXtst;}; "fakedata" = callPackage @@ -89313,8 +83744,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Faktory Worker for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fallible" = callPackage @@ -89345,8 +83774,6 @@ self: { ]; description = "Falling sand game/cellular automata simulation using regular parallel arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fallingblocks" = callPackage @@ -89365,8 +83792,6 @@ self: { ]; description = "A fun falling blocks game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "familiar-reflection" = callPackage @@ -89394,8 +83819,6 @@ self: { ]; description = "A family tree library for the Haskell programming language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "farmhash" = callPackage @@ -89427,8 +83850,6 @@ self: { doHaddock = false; description = "Fast functions on integers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fast-builder" = callPackage @@ -89466,8 +83887,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Fast combinatorics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fast-digits" = callPackage @@ -89487,8 +83906,6 @@ self: { doHaddock = false; description = "Integer-to-digits conversion"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fast-downward" = callPackage @@ -89557,8 +83974,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Natural Numbers with no overhead"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fast-tags" = callPackage @@ -89630,8 +84045,6 @@ self: { ]; description = "A simple, mindless parser for fasta files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fastbayes" = callPackage @@ -89643,8 +84056,6 @@ self: { libraryHaskellDepends = [ base hmatrix vector ]; description = "Bayesian modeling algorithms accelerated for particular model structures"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fastcgi" = callPackage @@ -89678,8 +84089,6 @@ self: { ]; description = "find nearest neighbours by edit-distance"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fastirc" = callPackage @@ -89696,8 +84105,6 @@ self: { ]; description = "Fast Internet Relay Chat (IRC) library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fastly" = callPackage @@ -89717,8 +84124,6 @@ self: { testHaskellDepends = [ base hspec text ]; description = "A highly experimental Fastly API client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fastparser" = callPackage @@ -89757,8 +84162,6 @@ self: { ]; description = "Haskell bindings to the fastpbkdf2 C library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "fastsum" = callPackage @@ -89778,8 +84181,6 @@ self: { ]; description = "A fast open-union type suitable for 100+ contained alternatives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fathead-util" = callPackage @@ -89794,8 +84195,6 @@ self: { ]; description = "Utilities for working with DuckDuckHack's FatHead Instant Answers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fault-tree" = callPackage @@ -89807,8 +84206,6 @@ self: { libraryHaskellDepends = [ base yices ]; description = "A fault tree analysis library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fay" = callPackage @@ -89868,8 +84265,6 @@ self: { ]; description = "Compile Fay code on cabal install, and ad-hoc recompile during development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fay-dom" = callPackage @@ -89908,8 +84303,6 @@ self: { libraryHaskellDepends = [ fay-base fay-jquery ]; description = "Clientside HTML generation for fay"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fay-jquery" = callPackage @@ -89946,8 +84339,6 @@ self: { libraryHaskellDepends = [ fay-base ]; description = "SimpleJSON library for Fay"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fay-text" = callPackage @@ -90023,8 +84414,6 @@ self: { libraryHaskellDepends = [ base cereal fb persistent text time ]; description = "Provides Persistent instances to Facebook types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fbmessenger-api" = callPackage @@ -90053,8 +84442,6 @@ self: { testHaskellDepends = [ aeson base bytestring filepath hspec text ]; description = "High-level bindings to Facebook Messenger Platform API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fbrnch" = callPackage @@ -90084,8 +84471,6 @@ self: { doHaddock = false; description = "Build and create Fedora package repos and branches"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fca" = callPackage @@ -90102,8 +84487,6 @@ self: { ]; description = "Algo for Formal Concept Analysis"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fcache" = callPackage @@ -90120,8 +84503,6 @@ self: { testHaskellDepends = [ base hspec mtl ]; description = "Cache a function (a -> b)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fcd" = callPackage @@ -90141,8 +84522,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "A faster way to navigate directories using the command line"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fcf-containers" = callPackage @@ -90158,8 +84537,6 @@ self: { testHaskellDepends = [ base doctest first-class-families Glob ]; description = "Data structures and algorithms for first-class-families"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fcg" = callPackage @@ -90172,8 +84549,6 @@ self: { isExecutable = true; description = "TBA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fckeditor" = callPackage @@ -90185,8 +84560,6 @@ self: { libraryHaskellDepends = [ base cgi HaXml xhtml ]; description = "Server-Side Integration for FCKeditor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fclabels" = callPackage @@ -90217,8 +84590,6 @@ self: { libraryHaskellDepends = [ base fclabels monadLib ]; description = "MonadLib monadic interface for the \"fclabels\" package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fcm-client" = callPackage @@ -90250,8 +84621,6 @@ self: { ]; description = "Admin API for Firebase Cloud Messaging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fdo-notify" = callPackage @@ -90283,8 +84652,6 @@ self: { ]; description = "Utilities related to freedesktop Trash standard"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feather" = callPackage @@ -90325,8 +84692,6 @@ self: { ]; description = "A minimally obtrusive feature flag library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feature-flipper-postgres" = callPackage @@ -90348,8 +84713,6 @@ self: { ]; description = "A minimally obtrusive feature flag library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fec" = callPackage @@ -90411,8 +84774,6 @@ self: { ]; description = "Fedora image download tool"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fedora-packages" = callPackage @@ -90435,8 +84796,6 @@ self: { ]; description = "Haskell interface to the Fedora Packages webapp API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fee-estimate" = callPackage @@ -90494,8 +84853,6 @@ self: { ]; description = "A simple command line interface for creating and updating feeds like RSS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feed-collect" = callPackage @@ -90513,8 +84870,6 @@ self: { ]; description = "Watch RSS/Atom feeds (and do with them whatever you like)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feed-crawl" = callPackage @@ -90531,8 +84886,6 @@ self: { ]; description = "Utility for fetching feeds with redirect info and HTML link detection"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feed-gipeda" = callPackage @@ -90571,8 +84924,6 @@ self: { ]; description = "CI service around gipeda"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feed-translator" = callPackage @@ -90594,8 +84945,6 @@ self: { ]; description = "Translate syndication feeds"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feed2lj" = callPackage @@ -90614,8 +84963,6 @@ self: { ]; description = "(unsupported)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feed2twitter" = callPackage @@ -90632,8 +84979,6 @@ self: { ]; description = "Send posts from a feed to Twitter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fei-base" = callPackage @@ -90661,8 +85006,6 @@ self: { executableToolDepends = [ c2hs ]; description = "FFI to MXNet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) mxnet;}; "fei-cocoapi" = callPackage @@ -90690,8 +85033,6 @@ self: { ]; description = "Cocodataset with cocoapi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fei-dataiter" = callPackage @@ -90718,8 +85059,6 @@ self: { testHaskellDepends = [ base fei-base hspec streaming ]; description = "mxnet dataiters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) mxnet;}; "fei-datasets" = callPackage @@ -90749,8 +85088,6 @@ self: { ]; description = "Some datasets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fei-examples" = callPackage @@ -90771,8 +85108,6 @@ self: { ]; description = "fei examples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fei-modelzoo" = callPackage @@ -90789,8 +85124,6 @@ self: { ]; description = "A collection of standard models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fei-nn" = callPackage @@ -90812,8 +85145,6 @@ self: { ]; description = "Train a neural network with MXNet in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feldspar-compiler" = callPackage @@ -90842,8 +85173,6 @@ self: { ]; description = "Compiler for the Feldspar language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gcc_s = null;}; "feldspar-language" = callPackage @@ -90867,8 +85196,6 @@ self: { ]; description = "A functional embedded language for DSP and parallelism"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "feldspar-signal" = callPackage @@ -90941,8 +85268,6 @@ self: { executableSystemDepends = [ raptor ]; description = "Graph-based notetaking system"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {raptor = null;}; "fernet" = callPackage @@ -90968,8 +85293,6 @@ self: { ]; description = "Generate and verify HMAC-based authentication tokens"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "festung" = callPackage @@ -91000,8 +85323,6 @@ self: { ]; description = "Remote multi-db SQLCipher server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fez-conf" = callPackage @@ -91013,8 +85334,6 @@ self: { libraryHaskellDepends = [ base containers regex-compat ]; description = "Simple functions for loading config files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ffeed" = callPackage @@ -91029,8 +85348,6 @@ self: { executableHaskellDepends = [ base pretty ]; description = "Haskell binding to the FriendFeed API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fficxx" = callPackage @@ -91052,8 +85369,6 @@ self: { ]; description = "automatic C++ binding generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fficxx-runtime" = callPackage @@ -91104,8 +85419,6 @@ self: { ]; description = "Tutorials on ffmpeg usage to play video/audio"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fft" = callPackage @@ -91154,8 +85467,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "FFunctor typeclass"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fgl" = callPackage @@ -91196,8 +85507,6 @@ self: { libraryHaskellDepends = [ base containers fgl ]; description = "Graph decomposition algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fgl-visualize" = callPackage @@ -91241,8 +85550,6 @@ self: { ]; description = "Tools for running and analyzing Haskell benchmarks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fibonacci" = callPackage @@ -91274,8 +85581,6 @@ self: { ]; description = "update statically hosted file in a push stule through socketed"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fields" = callPackage @@ -91291,8 +85596,6 @@ self: { ]; description = "First-class record field combinators with infix record field syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fields-json" = callPackage @@ -91320,8 +85623,6 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Provides Fieldwise typeclass for operations of fields of records treated as independent components"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fig" = callPackage @@ -91333,8 +85634,6 @@ self: { libraryHaskellDepends = [ base containers parsec pretty ]; description = "Manipulation of FIG files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "file-collection" = callPackage @@ -91348,8 +85647,6 @@ self: { ]; description = "Provide a uniform interface over file archives and directories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "file-command-qq" = callPackage @@ -91365,8 +85662,6 @@ self: { ]; description = "Quasiquoter for system commands involving filepaths"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "file-embed" = callPackage @@ -91420,8 +85715,6 @@ self: { ]; description = "Use Template Haskell to embed file contents directly"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "file-location" = callPackage @@ -91439,8 +85732,6 @@ self: { testHaskellDepends = [ base lifted-base process ]; description = "common functions that show file location information"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "file-modules" = callPackage @@ -91517,8 +85808,6 @@ self: { ]; description = "A cache system associating values to files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filediff" = callPackage @@ -91540,8 +85829,6 @@ self: { ]; description = "Diffing and patching module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filelock" = callPackage @@ -91580,8 +85867,6 @@ self: { libraryHaskellDepends = [ base hinotify stm ]; description = "Block thread until a file stops being modified"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filepath_1_4_2_1" = callPackage @@ -91628,8 +85913,6 @@ self: { ]; description = "Reversable and secure encoding of object ids as filepaths"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filepath-io-access" = callPackage @@ -91641,8 +85924,6 @@ self: { libraryHaskellDepends = [ base base-io-access filepath ]; description = "IO Access for filepath"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filepather" = callPackage @@ -91659,8 +85940,6 @@ self: { ]; description = "Functions on System.FilePath"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filepattern" = callPackage @@ -91689,8 +85968,6 @@ self: { ]; description = "Library to process and search large files or a collection of files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filestore" = callPackage @@ -91728,8 +86005,6 @@ self: { ]; description = "A shared set of abstractions and types for representing filessytem data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filesystem-conduit" = callPackage @@ -91751,8 +86026,6 @@ self: { ]; description = "Use system-filepath data types with conduits. (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filesystem-enumerator" = callPackage @@ -91768,8 +86041,6 @@ self: { ]; description = "Enumerator-based API for manipulating the filesystem"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filesystem-trees" = callPackage @@ -91786,8 +86057,6 @@ self: { ]; description = "Recursively manipulate and traverse filesystems as lazy rose trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fillit" = callPackage @@ -91804,8 +86073,6 @@ self: { testHaskellDepends = [ base doctest hspec unordered-containers ]; description = "Flexible string substitution"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "filter-logger" = callPackage @@ -91906,8 +86173,6 @@ self: { ]; description = "Extensible pretty printing with semantic annotations and proportional fonts"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "find-clumpiness" = callPackage @@ -91933,8 +86198,6 @@ self: { ]; description = "Find the clumpiness of labels in a tree"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "find-conduit" = callPackage @@ -91969,8 +86232,6 @@ self: { ]; description = "A file-finding conduit that allows user control over traversals"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "find-source-files" = callPackage @@ -91982,8 +86243,6 @@ self: { libraryHaskellDepends = [ base Cabal directory filepath mtl ]; description = "Initial project template from stack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "findhttp" = callPackage @@ -92002,8 +86261,6 @@ self: { ]; description = "List http/html files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fingertree" = callPackage @@ -92032,8 +86289,6 @@ self: { libraryHaskellDepends = [ base fingertree ]; description = "Implementation of priority search queues as finger trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fingertree-tf" = callPackage @@ -92045,8 +86300,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Generic finger-tree structure using type families"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "finitary" = callPackage @@ -92095,8 +86348,6 @@ self: { ]; description = "Flexible and easy deriving of type classes for finitary types"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "finitary-optics" = callPackage @@ -92261,8 +86512,6 @@ self: { ]; description = "A simple example using Firefly"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "first-and-last" = callPackage @@ -92275,8 +86524,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "First and Last generalized to return up to n values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "first-class-families" = callPackage @@ -92306,8 +86553,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "First class typeclass instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "first-class-patterns" = callPackage @@ -92336,8 +86581,6 @@ self: { ]; description = "Defunctionalisation for Yhc Core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fishfood" = callPackage @@ -92361,8 +86604,6 @@ self: { ]; description = "Calculates file-size frequency-distribution"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fit" = callPackage @@ -92382,8 +86623,6 @@ self: { ]; description = "FIT file decoder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fits-parse" = callPackage @@ -92407,8 +86646,6 @@ self: { ]; description = "Parse FITS files"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fitsio" = callPackage @@ -92421,8 +86658,6 @@ self: { librarySystemDepends = [ cfitsio ]; description = "A library for reading and writing data files in the FITS data format"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) cfitsio;}; "fitspec" = callPackage @@ -92462,8 +86697,6 @@ self: { ]; description = "Program to manage the imports of a haskell module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fix-parser-simple" = callPackage @@ -92477,8 +86710,6 @@ self: { libraryHaskellDepends = [ base mmtl ]; description = "Simple fix-expression parser"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fix-symbols-gitit" = callPackage @@ -92490,8 +86721,6 @@ self: { libraryHaskellDepends = [ base containers gitit ]; description = "Gitit plugin: Turn some Haskell symbols into pretty math symbols"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fix-whitespace" = callPackage @@ -92557,8 +86786,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Binary fixed-point arithmetic"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-point-vector" = callPackage @@ -92570,8 +86797,6 @@ self: { libraryHaskellDepends = [ base fixed-point vector ]; description = "Unbox instances for the fixed-point package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-point-vector-space" = callPackage @@ -92583,8 +86808,6 @@ self: { libraryHaskellDepends = [ base fixed-point vector-space ]; description = "vector-space instances for the fixed-point package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-precision" = callPackage @@ -92600,8 +86823,6 @@ self: { ]; description = "Fixed Precision Arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-storable-array" = callPackage @@ -92613,8 +86834,6 @@ self: { libraryHaskellDepends = [ array base tagged ]; description = "Fixed-size wrapper for StorableArray, providing a Storable instance. Deprecated - use storable-static-array instead."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-timestep" = callPackage @@ -92626,8 +86845,6 @@ self: { libraryHaskellDepends = [ async base clock time ]; description = "Pure Haskell library to repeat an action at a specific frequency"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-vector" = callPackage @@ -92656,8 +86873,6 @@ self: { ]; description = "Binary instances for fixed-vector"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-vector-cborg" = callPackage @@ -92674,8 +86889,6 @@ self: { ]; description = "Binary instances for fixed-vector"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-vector-cereal" = callPackage @@ -92692,8 +86905,6 @@ self: { ]; description = "Cereal instances for fixed-vector"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixed-vector-hetero" = callPackage @@ -92717,8 +86928,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Fixed width subsets of an Int64/Word64"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixedprec" = callPackage @@ -92774,8 +86983,6 @@ self: { ]; description = "A Haskell client for http://fixer.io/"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixfile" = callPackage @@ -92797,8 +87004,6 @@ self: { ]; description = "File-backed recursive data structures"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixhs" = callPackage @@ -92823,8 +87028,6 @@ self: { ]; description = "FIX (co)parser"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixie" = callPackage @@ -92846,8 +87049,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Opininated testing framework for mtl style (spies, stubs, and mocks)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fixplate" = callPackage @@ -92908,8 +87109,6 @@ self: { libraryHaskellDepends = [ base ]; description = "test"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fizzbuzz-as-a-service" = callPackage @@ -92927,8 +87126,6 @@ self: { ]; description = "FizzBuzz as a service"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flac" = callPackage @@ -92955,8 +87152,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Complete high-level binding to libFLAC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {FLAC = null;}; "flac-picture" = callPackage @@ -92977,8 +87172,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Support for writing picture to FLAC metadata blocks with JuicyPixels"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flaccuraterip" = callPackage @@ -92996,8 +87189,6 @@ self: { ]; description = "Verify FLAC files ripped form CD using AccurateRip™"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flags-applicative" = callPackage @@ -93025,8 +87216,6 @@ self: { libraryHaskellDepends = [ base template-haskell text ]; description = "A template engine for HTML"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flamingra" = callPackage @@ -93043,8 +87232,6 @@ self: { ]; description = "FlameGraphs of profiling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flashblast" = callPackage @@ -93089,8 +87276,6 @@ self: { ]; description = "Generate language learning flashcards from video"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flat" = callPackage @@ -93129,8 +87314,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Strict Maybe without space and indirection overhead"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flat-mcmc" = callPackage @@ -93197,8 +87380,6 @@ self: { ]; description = "Haskell implementation of the FlatBuffers protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flatparse" = callPackage @@ -93233,8 +87414,6 @@ self: { testHaskellDepends = [ base tasty tasty-quickcheck transformers ]; description = "Work generically on your datatype without knowing its shape nor its contents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flexible-defaults" = callPackage @@ -93261,8 +87440,6 @@ self: { libraryHaskellDepends = [ base bytestring unix-time ]; description = "simple extension of Data.UnixTime."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flexible-unlit" = callPackage @@ -93288,8 +87465,6 @@ self: { libraryHaskellDepends = [ base data-type mtl QuickCheck ]; description = "Flexible wrappers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flexiwrap-smallcheck" = callPackage @@ -93303,8 +87478,6 @@ self: { ]; description = "SmallCheck (Serial) instances for flexiwrap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flick-duration" = callPackage @@ -93335,8 +87508,6 @@ self: { executableHaskellDepends = [ xhtml ]; description = "Haskell binding to the Flickr API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flight-igc" = callPackage @@ -93392,8 +87563,6 @@ self: { libraryToolDepends = [ proto-lens-protoc ]; description = "Flink stateful functions SDK"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flip-cmd" = callPackage @@ -93436,8 +87605,6 @@ self: { ]; description = "f-lite compiler, interpreter and libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flo" = callPackage @@ -93474,8 +87641,6 @@ self: { ]; description = "C99 printf \"%a\" style formatting and parsing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "float128" = callPackage @@ -93500,8 +87665,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Conversions between floating and integral values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "floatshow" = callPackage @@ -93588,8 +87751,6 @@ self: { testHaskellDepends = [ base doctest flow QuickCheck ]; description = "More directional operators"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flow2dot" = callPackage @@ -93627,8 +87788,6 @@ self: { ]; description = "Flowdock client library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flowdock-api" = callPackage @@ -93665,8 +87824,6 @@ self: { ]; description = "API integration with Flowdock"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flowdock-rest" = callPackage @@ -93694,8 +87851,6 @@ self: { ]; description = "Flowdock REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flower" = callPackage @@ -93713,8 +87868,6 @@ self: { ]; description = "Analyze 454 flowgrams (.SFF files)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flowlocks-framework" = callPackage @@ -93727,8 +87880,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Generalized Flow Locks Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flowsim" = callPackage @@ -93747,8 +87898,6 @@ self: { ]; description = "Simulate 454 pyrosequencing"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "flp" = callPackage @@ -93781,8 +87930,6 @@ self: { testToolDepends = [ alex happy ]; description = "A layout spec language for memory managers implemented in Rust"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fltkhs" = callPackage @@ -93807,8 +87954,6 @@ self: { ]; description = "FLTK bindings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fltk14; inherit (pkgs) libGL; inherit (pkgs) libGLU; inherit (pkgs) pkg-config;}; @@ -93854,8 +87999,6 @@ self: { executableHaskellDepends = [ base bytestring fltkhs ]; description = "Fltkhs Fluid Examples"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fltkhs-hello-world" = callPackage @@ -93913,8 +88056,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A structured logger for Fluentd (Haskell)"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fluent-logger-conduit" = callPackage @@ -93966,8 +88107,6 @@ self: { ]; description = "The parser for fluffy to parsec the question bank in .docx type"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fluid-idl" = callPackage @@ -94033,8 +88172,6 @@ self: { librarySystemDepends = [ fluidsynth ]; description = "Haskell bindings to FluidSynth"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fluidsynth;}; "flush-queue" = callPackage @@ -94061,8 +88198,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A monoid for tracking changes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fmark" = callPackage @@ -94080,8 +88215,6 @@ self: { ]; description = "A Friendly Markup language without syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fmlist" = callPackage @@ -94142,8 +88275,6 @@ self: { libraryHaskellDepends = [ base enum-text-rio ]; description = "Adaptor for getting fmt to work with rio"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fmt-terminal-colors" = callPackage @@ -94156,8 +88287,6 @@ self: { testHaskellDepends = [ ansi-terminal base fmt ]; description = "ANSI terminal colors formatters for fmt library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fn" = callPackage @@ -94198,8 +88327,6 @@ self: { ]; description = "Extras for Fn, a functional web framework"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "focus" = callPackage @@ -94355,8 +88482,6 @@ self: { benchmarkHaskellDepends = [ base containers criterion foldl ]; description = "incremental folds"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foldl-statistics" = callPackage @@ -94381,8 +88506,6 @@ self: { ]; description = "Statistical functions from the statistics package implemented as Folds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foldl-transduce" = callPackage @@ -94409,8 +88532,6 @@ self: { ]; description = "Transducers for foldl folds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foldl-transduce-attoparsec" = callPackage @@ -94432,8 +88553,6 @@ self: { ]; description = "Attoparsec and foldl-transduce integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "folds" = callPackage @@ -94467,8 +88586,6 @@ self: { testHaskellDepends = [ base containers tasty tasty-quickcheck ]; description = "A playground of common folds for folds"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "folgerhs" = callPackage @@ -94515,8 +88632,6 @@ self: { ]; description = "Haskell library to follow content published on any subject"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "follow-file" = callPackage @@ -94559,8 +88674,6 @@ self: { ]; description = "Follow Tweets anonymously"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foma" = callPackage @@ -94573,8 +88686,6 @@ self: { librarySystemDepends = [ foma ]; description = "Simple Haskell bindings for Foma"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) foma;}; "font-awesome-type" = callPackage @@ -94600,8 +88711,6 @@ self: { executableHaskellDepends = [ base GLFW-b OpenGL ]; description = "Basic4x6 font for OpenGL"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foo" = callPackage @@ -94617,8 +88726,6 @@ self: { ]; description = "Paper soccer, an OpenGL game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foobar" = callPackage @@ -94650,8 +88757,6 @@ self: { ]; description = "Functor, Monad, MonadPlus, etc for free"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forbidden-fruit" = callPackage @@ -94672,8 +88777,6 @@ self: { ]; description = "A library accelerates imperative style programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "force-layout" = callPackage @@ -94703,8 +88806,6 @@ self: { executableHaskellDepends = [ base process transformers ]; description = "Run a command on files with magic substituion support (sequencing and regexp)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forecast-io" = callPackage @@ -94716,8 +88817,6 @@ self: { libraryHaskellDepends = [ aeson base text ]; description = "A Haskell library for working with forecast.io data."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foreign-storable-asymmetric" = callPackage @@ -94753,8 +88852,6 @@ self: { libraryHaskellDepends = [ base stm transformers ]; description = "Encapsulating mutatable state in external libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forest" = callPackage @@ -94770,8 +88867,6 @@ self: { ]; description = "Tree and Forest types"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forest-fire" = callPackage @@ -94793,8 +88888,6 @@ self: { ]; description = "Recursively delete CloudFormation stacks and their dependants"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forex2ledger" = callPackage @@ -94822,8 +88915,6 @@ self: { ]; description = "Print Forex quotes in Ledger format"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forger" = callPackage @@ -94838,8 +88929,6 @@ self: { executableHaskellDepends = [ base ]; description = "Library for generating fake placeholder data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forkable-monad" = callPackage @@ -94891,8 +88980,6 @@ self: { ]; description = "A statically typed, functional programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "format" = callPackage @@ -94905,8 +88992,6 @@ self: { testHaskellDepends = [ haskell2010 parsec QuickCheck ]; description = "Rendering from and scanning to format strings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "format-numbers" = callPackage @@ -94936,8 +89021,6 @@ self: { ]; description = "A utility for writing the date to dzen2"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "formatn" = callPackage @@ -94955,8 +89038,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Number text formatting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "formattable" = callPackage @@ -94977,8 +89058,6 @@ self: { ]; description = "Business-quality formatting of numbers, dates, and other things"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "formatting" = callPackage @@ -95043,8 +89122,6 @@ self: { ]; description = "A statically typed, functional programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "formlets" = callPackage @@ -95061,8 +89138,6 @@ self: { ]; description = "Formlets implemented in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "formlets-hsp" = callPackage @@ -95079,8 +89154,6 @@ self: { libraryToolDepends = [ trhsx ]; description = "HSP support for Formlets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "formura" = callPackage @@ -95102,8 +89175,6 @@ self: { ]; description = "Formura is a simple language to describe stencil computation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forsyde-deep" = callPackage @@ -95131,8 +89202,6 @@ self: { ]; description = "ForSyDe's Haskell-embedded Domain Specific Language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forsyde-shallow" = callPackage @@ -95160,8 +89229,6 @@ self: { libraryHaskellDepends = [ array-forth base free mtl ]; description = "A simple eDSL for generating arrayForth code"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fortran-src" = callPackage @@ -95191,8 +89258,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Parsers and analyses for Fortran standards 66, 77, 90 and 95"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fortran-src-extras" = callPackage @@ -95212,8 +89277,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Common functions and utils for fortran-src"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fortytwo" = callPackage @@ -95228,8 +89291,6 @@ self: { testHaskellDepends = [ base doctest hspec ]; description = "Interactive terminal prompt"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "forward-chan" = callPackage @@ -95260,8 +89321,6 @@ self: { ]; description = "Foscam File format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foscam-filename" = callPackage @@ -95281,8 +89340,6 @@ self: { ]; description = "Foscam File format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foscam-sort" = callPackage @@ -95309,8 +89366,6 @@ self: { ]; description = "Foscam File format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "foundation" = callPackage @@ -95394,8 +89449,6 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "IEEE 754-2019 compliant operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fpco-api" = callPackage @@ -95432,8 +89485,6 @@ self: { ]; description = "Simple interface to the FP Complete IDE API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fpe" = callPackage @@ -95479,8 +89530,6 @@ self: { testHaskellDepends = [ base ]; description = "Haskell bindings to "; license = lib.licenses.lgpl21Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fplll;}; "fpnla" = callPackage @@ -95516,8 +89565,6 @@ self: { ]; description = "Example implementations for FPNLA library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fptest" = callPackage @@ -95543,8 +89590,6 @@ self: { ]; description = "IEEE754r floating point conformance tests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fquery" = callPackage @@ -95588,8 +89633,6 @@ self: { testHaskellDepends = [ base integer-gmp QuickCheck ]; description = "A collection of useful fractal curve encoders"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fraction" = callPackage @@ -95601,8 +89644,6 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "Fractions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frag" = callPackage @@ -95617,8 +89658,6 @@ self: { executableHaskellDepends = [ array base GLUT OpenGL random ]; description = "A 3-D First Person Shooter Game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frame" = callPackage @@ -95656,7 +89695,6 @@ self: { description = "A markdown to Frame GUI writer for Pandoc"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "franchise" = callPackage @@ -95668,8 +89706,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A package for configuring and building Haskell software"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "franz" = callPackage @@ -95715,8 +89751,6 @@ self: { benchmarkHaskellDepends = [ base time ]; description = "Cached and parallel data fetching"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freddy" = callPackage @@ -95736,8 +89770,6 @@ self: { ]; description = "RabbitMQ Messaging API supporting request-response"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free" = callPackage @@ -95797,8 +89829,6 @@ self: { ]; description = "Free algebras"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-categories" = callPackage @@ -95827,8 +89857,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "efficient data types for free categories and arrows"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-concurrent" = callPackage @@ -95840,8 +89868,6 @@ self: { libraryHaskellDepends = [ base type-aligned ]; description = "Free monads suitable for concurrent computation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-er" = callPackage @@ -95894,8 +89920,6 @@ self: { ]; description = "Create games for free"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-http" = callPackage @@ -95912,8 +89936,6 @@ self: { ]; description = "An HTTP Client based on Free Monads"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-operational" = callPackage @@ -95929,8 +89951,6 @@ self: { ]; description = "Operational Applicative, Alternative, Monad and MonadPlus from free types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-theorems" = callPackage @@ -95946,8 +89966,6 @@ self: { ]; description = "Automatic generation of free theorems"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-theorems-counterexamples" = callPackage @@ -95966,8 +89984,6 @@ self: { executableHaskellDepends = [ cgi free-theorems utf8-string xhtml ]; description = "Automatically Generating Counterexamples to Naive Free Theorems"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-theorems-seq" = callPackage @@ -95985,8 +90001,6 @@ self: { ]; description = "Taming Selective Strictness"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-theorems-seq-webui" = callPackage @@ -96005,8 +90019,6 @@ self: { ]; description = "Taming Selective Strictness"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-theorems-webui" = callPackage @@ -96026,8 +90038,6 @@ self: { ]; description = "CGI-based web interface for the free-theorems package"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-v-bucks-generator-no-survey" = callPackage @@ -96043,8 +90053,6 @@ self: { executableHaskellDepends = [ base ]; description = "Spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-v-bucks-generator-ps4-no-survey" = callPackage @@ -96060,8 +90068,6 @@ self: { executableHaskellDepends = [ base ]; description = "Spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "free-vector-spaces" = callPackage @@ -96117,8 +90123,6 @@ self: { ]; description = "A soccer game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freelude" = callPackage @@ -96138,8 +90142,6 @@ self: { ]; description = "A generalisation of the Category->Functor->Applicative->Monad hierarchy and more"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freenect" = callPackage @@ -96194,8 +90196,6 @@ self: { ]; description = "Handle effects conversely using monadic conversation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freer-effects" = callPackage @@ -96216,8 +90216,6 @@ self: { benchmarkHaskellDepends = [ base criterion free mtl ]; description = "Implementation of effect system for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freer-indexed" = callPackage @@ -96268,8 +90266,6 @@ self: { testHaskellDepends = [ base freer-simple hspec ]; description = "Checked runtime exceptions with freer-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freer-simple-http" = callPackage @@ -96290,8 +90286,6 @@ self: { ]; description = "Make HTTP requests with freer-simple!"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freer-simple-profiling" = callPackage @@ -96304,8 +90298,6 @@ self: { testHaskellDepends = [ base containers freer-simple hspec time ]; description = "Automatic profling of freer-simple programs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freer-simple-random" = callPackage @@ -96318,8 +90310,6 @@ self: { testHaskellDepends = [ base containers freer-simple hspec random ]; description = "Random number generators using freer-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freer-simple-time" = callPackage @@ -96332,8 +90322,6 @@ self: { testHaskellDepends = [ base freer-simple hspec time ]; description = "freer-simple interface to IO based time functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freesect" = callPackage @@ -96351,8 +90339,6 @@ self: { ]; description = "A Haskell syntax extension for generalised sections"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freesound" = callPackage @@ -96374,8 +90360,6 @@ self: { ]; description = "Access the Freesound Project database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freetype-simple" = callPackage @@ -96390,8 +90374,6 @@ self: { ]; description = "Single line text rendering for OpenGL ES"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "freetype2" = callPackage @@ -96435,8 +90417,6 @@ self: { benchmarkHaskellDepends = [ base bytestring containers gauge ]; description = "Are you ready to get freaky?"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fresco-binding" = callPackage @@ -96464,8 +90444,6 @@ self: { libraryHaskellDepends = [ base containers haskell-src-exts syb ]; description = "Introduce fresh variables into Haskell source code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "friday" = callPackage @@ -96504,8 +90482,6 @@ self: { librarySystemDepends = [ libdevil ]; description = "Uses the DevIL C library to read and write images from and to files and memory buffers"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libdevil;}; "friday-juicypixels" = callPackage @@ -96537,8 +90513,6 @@ self: { ]; description = "Scale Friday images with DCT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "friendly" = callPackage @@ -96554,8 +90528,6 @@ self: { ]; description = "Attempt to pretty-print any input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "friendly-time" = callPackage @@ -96628,8 +90600,6 @@ self: { ]; description = "A reactive frontend web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frontmatter" = callPackage @@ -96673,8 +90643,6 @@ self: { executableHaskellDepends = [ base directory ]; description = "LALR(k) parser generator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frp-arduino" = callPackage @@ -96686,8 +90654,6 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Arduino programming without the hassle of C"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frpnow" = callPackage @@ -96702,8 +90668,6 @@ self: { libraryHaskellDepends = [ base containers mtl transformers ]; description = "Principled practical FRP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frpnow-gloss" = callPackage @@ -96719,8 +90683,6 @@ self: { ]; description = "Program awesome stuff with Gloss and frpnow!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frpnow-gtk" = callPackage @@ -96737,8 +90699,6 @@ self: { ]; description = "Program GUIs with GTK and frpnow!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frpnow-gtk3" = callPackage @@ -96752,8 +90712,6 @@ self: { ]; description = "Program GUIs with GTK3 and frpnow!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frpnow-vty" = callPackage @@ -96768,8 +90726,6 @@ self: { executableHaskellDepends = [ base containers frpnow vty ]; description = "Program terminal applications with vty and frpnow!"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "frquotes" = callPackage @@ -96795,8 +90751,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A haskell binding to the FSEvents API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fsh-csv" = callPackage @@ -96808,8 +90762,6 @@ self: { libraryHaskellDepends = [ base hint ]; description = "csv parser for fsh"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fsharp" = callPackage @@ -96836,8 +90788,6 @@ self: { ]; description = "Finite state machines and FSM actions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fsnotify" = callPackage @@ -96899,8 +90849,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Finite state transducers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fsutils" = callPackage @@ -96912,8 +90860,6 @@ self: { libraryHaskellDepends = [ base directory filepath ]; description = "File system utilities for Haskell that are missing from built in libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fswait" = callPackage @@ -96933,8 +90879,6 @@ self: { ]; description = "Wait and observe events on the filesystem for a path, with a timeout"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fswatch" = callPackage @@ -96955,8 +90899,6 @@ self: { ]; description = "File System watching tool with cli and slave functionalities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fswatcher" = callPackage @@ -96988,8 +90930,6 @@ self: { executableHaskellDepends = [ base mtl parsec ]; description = "implementation accompanying a WFLP'19 paper"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ftdi" = callPackage @@ -97011,8 +90951,6 @@ self: { ]; description = "A thin layer over USB to communicate with FTDI chips"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ftp-client" = callPackage @@ -97030,8 +90968,6 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hspec ]; description = "Transfer files with FTP and FTPS"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ftp-client-conduit" = callPackage @@ -97048,8 +90984,6 @@ self: { testHaskellDepends = [ base ]; description = "Transfer file with FTP and FTPS with Conduit"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ftp-conduit" = callPackage @@ -97066,8 +91000,6 @@ self: { ]; description = "FTP client package with conduit interface based off http-conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ftphs" = callPackage @@ -97085,8 +91017,6 @@ self: { ]; description = "FTP Client and Server Library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ftree" = callPackage @@ -97098,8 +91028,6 @@ self: { libraryHaskellDepends = [ base ShowF type-unary ]; description = "Depth-typed functor-based trees, both top-down and bottom-up"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ftshell" = callPackage @@ -97118,8 +91046,6 @@ self: { ]; description = "Shell interface to the FreeTheorems library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fugue" = callPackage @@ -97142,8 +91068,6 @@ self: { libraryHaskellDepends = [ base ghc network ]; description = "a monad for protocol-typed network programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "full-text-search" = callPackage @@ -97211,8 +91135,6 @@ self: { ]; description = "IRC bot for fun, learning, creativity and collaboration"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funbot-client" = callPackage @@ -97231,8 +91153,6 @@ self: { ]; description = "Report events to FunBot over a JSON/HTTP API"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funbot-ext-events" = callPackage @@ -97263,8 +91183,6 @@ self: { ]; description = "Git hook which sends events to FunBot"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funcmp" = callPackage @@ -97316,8 +91234,6 @@ self: { ]; description = "call-by-value lambda-calculus with meta-programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funcons-simple" = callPackage @@ -97333,8 +91249,6 @@ self: { executableHaskellDepends = [ base funcons-tools funcons-values ]; description = "A modular interpreter for executing SIMPLE funcons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funcons-tools" = callPackage @@ -97361,8 +91275,6 @@ self: { ]; description = "A modular interpreter for executing funcons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funcons-values" = callPackage @@ -97378,8 +91290,6 @@ self: { ]; description = "Library providing values and operations on values in a fixed universe"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "function-builder" = callPackage @@ -97403,8 +91313,6 @@ self: { libraryHaskellDepends = [ base data-type ]; description = "Combining functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "function-instances-algebra" = callPackage @@ -97416,8 +91324,6 @@ self: { libraryHaskellDepends = [ base numeric-prelude ]; description = "Instances of the Algebra.* classes for functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functional-arrow" = callPackage @@ -97429,8 +91335,6 @@ self: { libraryHaskellDepends = [ base HList ]; description = "Combinators that allow for a more functional/monadic style of Arrow programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functional-kmp" = callPackage @@ -97455,8 +91359,6 @@ self: { libraryHaskellDepends = [ base category ]; description = "Functors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functor-apply" = callPackage @@ -97510,8 +91412,6 @@ self: { ]; description = "Tools for functor combinator-based program design"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functor-combo" = callPackage @@ -97528,8 +91428,6 @@ self: { ]; description = "Functor combinators with tries & zippers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functor-friends" = callPackage @@ -97541,8 +91439,6 @@ self: { libraryHaskellDepends = [ base recursion-schemes ]; description = "Friendly helpers for your recursion schemes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functor-infix" = callPackage @@ -97556,8 +91452,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Infix operators for mapping over compositions of functors. Lots of them."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functor-monadic" = callPackage @@ -97580,8 +91474,6 @@ self: { libraryHaskellDepends = [ base microlens singletons text vinyl ]; description = "General functor products for various Foldable instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functor-utils" = callPackage @@ -97593,8 +91485,6 @@ self: { libraryHaskellDepends = [ base ghc-prim lens ]; description = "Collection of functor utilities, providing handy operators, like generalization of (.)."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functorm" = callPackage @@ -97606,8 +91496,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Data.FunctorM (compatibility package)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "functors" = callPackage @@ -97658,8 +91546,6 @@ self: { ]; description = "Workflows with arrows"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funflow-nix" = callPackage @@ -97681,8 +91567,6 @@ self: { ]; description = "Utility functions for using funflow with nix"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fungll-combinators" = callPackage @@ -97716,8 +91600,6 @@ self: { ]; description = "A unioning file-system using HFuse"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funnyprint" = callPackage @@ -97733,8 +91615,6 @@ self: { benchmarkHaskellDepends = [ base criterion hscolour ipprint ]; description = "funnyPrint function to colorize GHCi output"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funpat" = callPackage @@ -97746,8 +91626,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A generalization of pattern matching"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funsat" = callPackage @@ -97769,8 +91647,6 @@ self: { ]; description = "A modern DPLL-style SAT solver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "funspection" = callPackage @@ -97782,8 +91658,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Type-level function utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fused-effects" = callPackage @@ -97820,8 +91694,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Handle exceptions thrown in IO with fused-effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fused-effects-lens" = callPackage @@ -97906,8 +91778,6 @@ self: { ]; description = "Resumable exceptions for the fused-effects ecosystem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fused-effects-squeal" = callPackage @@ -97924,8 +91794,6 @@ self: { ]; description = "A fused-effects adapter for squeal-postgresql"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fused-effects-th" = callPackage @@ -97942,8 +91810,6 @@ self: { ]; description = "Template Haskell helpers for fused-effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fusion" = callPackage @@ -97958,8 +91824,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Effectful streaming library based on shortcut fusion techniques"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fusion-plugin" = callPackage @@ -98055,8 +91919,6 @@ self: { executableHaskellDepends = [ base bytestring network unix ]; description = "Simple IP-over-UDP tunnel using TUNTAP"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "future" = callPackage @@ -98068,8 +91930,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Supposed to mimics and enhance proposed C++ \"future\" features"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "future-resource" = callPackage @@ -98191,8 +92051,6 @@ self: { base criterion fuzzy-time genvalidity-criterion ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fuzzy-timings" = callPackage @@ -98213,8 +92071,6 @@ self: { ]; description = "Translates high-level definitions of \"fuzzily\" scheduled objects (e.g. play this commercial 10 times per hour between 9:00-13:00) to a list of accurately scheduled objects using glpk-hs."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fuzzyfind" = callPackage @@ -98298,8 +92154,6 @@ self: { ]; description = "Game engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fwgl-glfw" = callPackage @@ -98316,8 +92170,6 @@ self: { ]; description = "FWGL GLFW backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fwgl-javascript" = callPackage @@ -98333,8 +92185,6 @@ self: { ]; description = "FWGL GHCJS backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "fx" = callPackage @@ -98357,8 +92207,6 @@ self: { libraryHaskellDepends = [ base bytestring serialport ]; description = "Interface to the FXPak/FXPak Pro USB interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "g-npm" = callPackage @@ -98372,8 +92220,6 @@ self: { executableHaskellDepends = [ base HTTP json ]; description = "Generate Gentoo ebuilds from NodeJS/npm packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "g2" = callPackage @@ -98406,8 +92252,6 @@ self: { ]; description = "Haskell symbolic execution engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "g2q" = callPackage @@ -98419,8 +92263,6 @@ self: { libraryHaskellDepends = [ base g2 ]; description = "G2Q allows constraint programming, via writing Haskell predicates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "g4ip" = callPackage @@ -98433,8 +92275,6 @@ self: { testHaskellDepends = [ base ]; description = "A theorem prover for propositional logic that uses G4ip"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "g4ip-prover" = callPackage @@ -98469,8 +92309,6 @@ self: { ]; description = "General Alignment Clustering Tool"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "galois-fft" = callPackage @@ -98497,8 +92335,6 @@ self: { ]; description = "FFTs over finite fields"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "galois-field" = callPackage @@ -98524,8 +92360,6 @@ self: { ]; description = "Galois field library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "game-of-life" = callPackage @@ -98551,8 +92385,6 @@ self: { libraryHaskellDepends = [ base containers probability random ]; description = "Simple probability library for dice rolls, card games and similar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "game-tree" = callPackage @@ -98577,8 +92409,6 @@ self: { executableHaskellDepends = [ base cairo containers glib gtk time ]; description = "Game clock that shows two analog clock faces"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gamgee" = callPackage @@ -98609,8 +92439,6 @@ self: { ]; description = "Tool for generating TOTP MFA tokens"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gamma" = callPackage @@ -98631,8 +92459,6 @@ self: { ]; description = "Gamma function and related functions"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gang-of-threads" = callPackage @@ -98658,8 +92484,6 @@ self: { executableHaskellDepends = [ base haskeline transformers ]; description = "reverse prefix notation calculator and calculation library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "garfield" = callPackage @@ -98726,8 +92550,6 @@ self: { ]; description = "Connect to gargoyle-managed postgresql instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gargoyle-postgresql-nix" = callPackage @@ -98748,8 +92570,6 @@ self: { ]; description = "Manage PostgreSQL servers with gargoyle and nix"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "garlic-bread" = callPackage @@ -98784,8 +92604,6 @@ self: { libraryHaskellDepends = [ base free transformers ]; description = "Limit how many steps a program may take"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gasp" = callPackage @@ -98808,8 +92626,6 @@ self: { libraryHaskellDepends = [ base ]; description = "An applicative for parsing unordered things, heterogenous sorting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gauge" = callPackage @@ -98844,8 +92660,6 @@ self: { ]; description = "planar graph embedding into a plane"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gc" = callPackage @@ -98875,8 +92689,6 @@ self: { ]; description = "a wai application to show GHC.GCStats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gcodehs" = callPackage @@ -98923,8 +92735,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GNOME configuration database system"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs.gnome2) GConf;}; "gd" = callPackage @@ -98978,8 +92788,6 @@ self: { ]; description = "API Wrapping for Coinbase's GDAX exchange"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gdelt" = callPackage @@ -99020,8 +92828,6 @@ self: { ]; description = "Generic diff for the instant-generics library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gdiff-th" = callPackage @@ -99040,8 +92846,6 @@ self: { ]; description = "Generate gdiff GADTs and Instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gdo" = callPackage @@ -99104,8 +92908,6 @@ self: { testHaskellDepends = [ base hspec megaparsec text-all ]; description = "Parser for the GEDCOM genealogy file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geek" = callPackage @@ -99126,8 +92928,6 @@ self: { ]; description = "Geek blog engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geek-server" = callPackage @@ -99151,8 +92951,6 @@ self: { ]; description = "Geek blog engine server"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gegl" = callPackage @@ -99173,8 +92971,6 @@ self: { libraryPkgconfigDepends = [ gegl ]; description = "Haskell bindings to GEGL library"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gegl;}; "gelatin" = callPackage @@ -99193,8 +92989,6 @@ self: { executableHaskellDepends = [ base linear mtl vector ]; description = "A graphics description language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gelatin-freetype2" = callPackage @@ -99212,8 +93006,6 @@ self: { testHaskellDepends = [ base ]; description = "FreeType2 based text rendering for the gelatin realtime rendering system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gelatin-fruity" = callPackage @@ -99225,8 +93017,6 @@ self: { libraryHaskellDepends = [ base FontyFruity gelatin linear vector ]; description = "Gelatin's support for rendering TTF outlines, using FontyFruity"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gelatin-gl" = callPackage @@ -99248,8 +93038,6 @@ self: { executableHaskellDepends = [ base gelatin lens linear mtl vector ]; description = "OpenGL rendering routines for the gelatin-picture graphics EDSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gelatin-sdl2" = callPackage @@ -99267,8 +93055,6 @@ self: { executableHaskellDepends = [ base either filepath sdl2 ]; description = "An SDL2 backend for the gelatin renderer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gelatin-shaders" = callPackage @@ -99281,8 +93067,6 @@ self: { libraryHaskellDepends = [ base bytestring filepath gelatin ]; description = "Gelatin's OpenGL shaders"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gemini-router" = callPackage @@ -99336,8 +93120,6 @@ self: { ]; description = "A barebones textboard for the Gemini protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gemstone" = callPackage @@ -99355,8 +93137,6 @@ self: { ]; description = "A simple library of helpers for SDL+GL games"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gen-imports" = callPackage @@ -99372,8 +93152,6 @@ self: { ]; description = "Code to generate instances for the package \"ghc-instances\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gen-passwd" = callPackage @@ -99391,8 +93169,6 @@ self: { ]; description = "Create wordlist-based passwords easily"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gencheck" = callPackage @@ -99409,8 +93185,6 @@ self: { ]; description = "A testing framework inspired by QuickCheck and SmallCheck"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gender" = callPackage @@ -99426,8 +93200,6 @@ self: { executableHaskellDepends = [ attoparsec base text ]; description = "Identify a persons gender by their first name"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genders" = callPackage @@ -99443,8 +93215,6 @@ self: { testHaskellDepends = [ base bytestring hspec network vector ]; description = "Bindings to libgenders"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {genders = null;}; "gendocs" = callPackage @@ -99490,8 +93260,6 @@ self: { ]; description = "Prelude replacement using generalized type classes where possible"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generator" = callPackage @@ -99503,8 +93271,6 @@ self: { libraryHaskellDepends = [ base List transformers ]; description = "Python-generators notation for creation of monadic lists"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generators" = callPackage @@ -99516,8 +93282,6 @@ self: { libraryHaskellDepends = [ base mtl random ]; description = "Actually useful monadic random value generators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-accessors" = callPackage @@ -99537,8 +93301,6 @@ self: { ]; description = "stringly-named getters for generic data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-aeson" = callPackage @@ -99577,8 +93339,6 @@ self: { libraryHaskellDepends = [ base binary bytestring ghc-prim ]; description = "Generic Data.Binary derivation using GHC generics."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-church" = callPackage @@ -99594,8 +93354,6 @@ self: { ]; description = "Automatically convert Generic instances to and from church representations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-constraints" = callPackage @@ -99714,8 +93472,6 @@ self: { testHaskellDepends = [ array base bytestring hspec ]; description = "An Enum class that fixes some deficiences with Prelude's Enum"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-enumeration" = callPackage @@ -99727,8 +93483,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Generically derived enumerations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-env" = callPackage @@ -99769,8 +93523,6 @@ self: { testHaskellDepends = [ base Cabal inspection-testing ]; description = "Generically extract and replace collections of record fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-lens" = callPackage @@ -99811,8 +93563,6 @@ self: { libraryHaskellDepends = [ base generic-lens ]; description = "GHC.OverloadedLabels.IsLabel instance for lenses from ghc-generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-lens-lite" = callPackage @@ -99838,8 +93588,6 @@ self: { libraryHaskellDepends = [ base lucid text ]; description = "General-purpose web page scaffold for Lucid"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-match" = callPackage @@ -99872,8 +93620,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "A generic version of Data.Maybe"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-monoid" = callPackage @@ -99903,8 +93649,6 @@ self: { ]; description = "Generically derive traversals, lenses and prisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-optics-lite" = callPackage @@ -99942,8 +93686,6 @@ self: { testHaskellDepends = [ aeson base generic-override hspec text ]; description = "Provides orphan instances necessary for integrating generic-override and aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-pretty" = callPackage @@ -99962,8 +93704,6 @@ self: { ]; description = "Pretty printing for Generic value"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-random" = callPackage @@ -100000,8 +93740,6 @@ self: { libraryHaskellDepends = [ base bytestring network ]; description = "Simple generic TCP/IP server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-storable" = callPackage @@ -100014,8 +93752,6 @@ self: { testHaskellDepends = [ base ghc-prim hspec QuickCheck ]; description = "Generic implementation of Storable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-tree" = callPackage @@ -100027,8 +93763,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Generic Tree data type"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-trie" = callPackage @@ -100042,8 +93776,6 @@ self: { libraryHaskellDepends = [ base containers transformers ]; description = "A map, where the keys may be complex structured data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-xml" = callPackage @@ -100058,8 +93790,6 @@ self: { ]; description = "Marshalling Haskell values to/from XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generic-xmlpickler" = callPackage @@ -100074,8 +93804,6 @@ self: { testHaskellDepends = [ base hxt tasty tasty-hunit tasty-th ]; description = "Generic generation of HXT XmlPickler instances using GHC Generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generics-eot" = callPackage @@ -100108,8 +93836,6 @@ self: { ]; description = "Generic Programming with Mutually Recursive Sums of Products"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generics-mrsop-gdiff" = callPackage @@ -100121,8 +93847,6 @@ self: { libraryHaskellDepends = [ base generics-mrsop ]; description = "Reimplementation of the gdiff algorithm for generics-mrsop"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "generics-sop" = callPackage @@ -100167,8 +93891,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Serialization library using Data.Generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genesis" = callPackage @@ -100196,8 +93918,6 @@ self: { ]; description = "Opinionated bootstrapping for Haskell web services"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genesis-test" = callPackage @@ -100221,8 +93941,6 @@ self: { ]; description = "Opinionated bootstrapping for Haskell web services"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genetics" = callPackage @@ -100236,8 +93954,6 @@ self: { executableHaskellDepends = [ base random-fu ]; description = "A Genetic Algorithm library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geni-gui" = callPackage @@ -100261,8 +93977,6 @@ self: { executableHaskellDepends = [ base GenI ]; description = "GenI graphical user interface"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geni-util" = callPackage @@ -100286,8 +94000,6 @@ self: { ]; description = "Companion tools for use with the GenI surface realiser"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geniconvert" = callPackage @@ -100307,8 +94019,6 @@ self: { ]; description = "Conversion utility for the GenI generator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genifunctors" = callPackage @@ -100332,8 +94042,6 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Use Template Haskell to generate Uniplate-like functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geniplate-mirror" = callPackage @@ -100366,8 +94074,6 @@ self: { ]; description = "Simple HTTP server for GenI results"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genprog" = callPackage @@ -100379,8 +94085,6 @@ self: { libraryHaskellDepends = [ base MonadRandom syb syz ]; description = "Genetic programming library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gentlemark" = callPackage @@ -100393,8 +94097,6 @@ self: { testHaskellDepends = [ base HUnit parsec transformers ]; description = "Gentle markup language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genvalidity" = callPackage @@ -100734,8 +94436,6 @@ self: { ]; description = "GenValidity support for Persistent"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "genvalidity-property" = callPackage @@ -101021,8 +94721,6 @@ self: { ]; description = "Performs geo location lookups and parses the results"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geo-uk" = callPackage @@ -101081,8 +94779,6 @@ self: { ]; description = "Geodetic calculations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geodetic-types" = callPackage @@ -101094,8 +94790,6 @@ self: { libraryHaskellDepends = [ base dimensional lens semigroups ]; description = "Types for geodetic operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geodetics" = callPackage @@ -101174,8 +94868,6 @@ self: { libraryHaskellDepends = [ aeson base bson bytestring lens text ]; description = "GeoJSON data types including JSON/BSON conversion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geolite-csv" = callPackage @@ -101194,8 +94886,6 @@ self: { ]; description = "Geolite CSV Parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geom2d" = callPackage @@ -101208,8 +94898,6 @@ self: { testHaskellDepends = [ base ieee754 linear QuickCheck ]; description = "package for geometry in euklidean 2d space"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "geos" = callPackage @@ -101230,8 +94918,6 @@ self: { testSystemDepends = [ geos ]; description = "Bindings for GEOS"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) geos;}; "getemx" = callPackage @@ -101250,8 +94936,6 @@ self: { ]; description = "Fetch from emusic using .emx files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "getflag" = callPackage @@ -101263,8 +94947,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Command-line parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "getopt-generics" = callPackage @@ -101344,8 +95026,6 @@ self: { executableHaskellDepends = [ base containers parsec ]; description = "A type checker and runtime system of rCOS/g (impl. of ggts-FCS)."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gh-labeler" = callPackage @@ -101363,8 +95043,6 @@ self: { ]; description = "Github Standard Labeler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gh-pocket-knife" = callPackage @@ -101514,8 +95192,6 @@ self: { ]; description = "Override GHC error messages to the user's liking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-compact_0_1_0_0" = callPackage @@ -101577,8 +95253,6 @@ self: { testHaskellDepends = [ base ghc ghc-paths ]; description = "A small-step semantics for Core"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-datasize" = callPackage @@ -101592,8 +95266,6 @@ self: { ]; description = "Determine the size of data structures in GHC's memory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-dump-core" = callPackage @@ -101609,8 +95281,6 @@ self: { ]; description = "An AST and compiler plugin for dumping GHC's Core representation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-dump-tree" = callPackage @@ -101635,8 +95305,6 @@ self: { ]; description = "Dump GHC's parsed, renamed, and type checked ASTs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-dump-util" = callPackage @@ -101659,8 +95327,6 @@ self: { ]; description = "Handy tools for working with ghc-dump dumps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-dup" = callPackage @@ -101672,8 +95338,6 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Explicitly prevent sharing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-events" = callPackage @@ -101716,8 +95380,6 @@ self: { ]; description = "Analyze and visualize event logs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-events-parallel" = callPackage @@ -101741,8 +95403,6 @@ self: { ]; description = "Library and tool for parsing .eventlog files from parallel GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-exactprint" = callPackage @@ -101790,8 +95450,6 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Derived instances of GHC.Generic of the GHC AST"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-heap_9_0_1" = callPackage @@ -101871,8 +95529,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Find the Haddock documentation for a symbol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-instances" = callPackage @@ -101894,8 +95550,6 @@ self: { ]; description = "Easily import all instances contained in GHC distributed libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-justdoit" = callPackage @@ -101908,8 +95562,6 @@ self: { testHaskellDepends = [ base inspection-testing ]; description = "A magic typeclass that just does it"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-lib" = callPackage @@ -102058,8 +95710,6 @@ self: { executableHaskellDepends = [ base parsec process ]; description = "Generate a bash completion from the GHC manpage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-mod" = callPackage @@ -102106,8 +95756,6 @@ self: { ]; description = "Happy Haskell Hacking"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-mtl" = callPackage @@ -102171,8 +95819,6 @@ self: { ]; description = "A parallel wrapper for 'ghc --make'"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-parser" = callPackage @@ -102216,8 +95862,6 @@ self: { ]; description = "Simple utility to fix BROKEN package dependencies for cabal-install"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-pkg-lib" = callPackage @@ -102232,8 +95876,6 @@ self: { ]; description = "Provide library support for ghc-pkg information"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-plugs-out" = callPackage @@ -102249,8 +95891,6 @@ self: { doHaddock = false; description = "Type checker plugins without the type checking"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-prim_0_7_0" = callPackage @@ -102344,8 +95984,6 @@ self: { testHaskellDepends = [ base transformers ]; description = "GHC plugin to prove program equations by simplification"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-server" = callPackage @@ -102376,8 +96014,6 @@ self: { executableHaskellDepends = [ base transformers ]; description = "Simplified GHC API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-simple" = callPackage @@ -102393,8 +96029,6 @@ self: { ]; description = "Simplified interface to the GHC API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-source-gen" = callPackage @@ -102422,8 +96056,6 @@ self: { libraryHaskellDepends = [ array base containers ghc hpc ]; description = "Generic GHC Plugin for annotating Haskell code with source location data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-syb" = callPackage @@ -102435,8 +96067,6 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Data and Typeable instances for the GHC API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-syb-utils" = callPackage @@ -102448,8 +96078,6 @@ self: { libraryHaskellDepends = [ base bytestring ghc syb ]; description = "Scrap Your Boilerplate utilities for the GHC API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-syntax-highlighter" = callPackage @@ -102510,8 +96138,6 @@ self: { ]; description = "a library to work with tags created from Haskell parsed tree"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-tags-plugin" = callPackage @@ -102533,8 +96159,6 @@ self: { ]; description = "A compiler plugin which generates tags file from GHC parsed syntax tree"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-tcplugins-extra_0_3_2" = callPackage @@ -102577,8 +96201,6 @@ self: { ]; description = "Library for parsing GHC time and allocation profiling reports"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-timers" = callPackage @@ -102700,8 +96322,6 @@ self: { executableHaskellDepends = [ base ghc-paths unix ]; description = "Print minimal export lists"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghc-vis" = callPackage @@ -102721,8 +96341,6 @@ self: { ]; description = "Live visualization of data structures in GHCi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghcflags" = callPackage @@ -102778,8 +96396,6 @@ self: { ]; description = "ghci-dap is a GHCi having DAP interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghci-diagrams" = callPackage @@ -102791,8 +96407,6 @@ self: { libraryHaskellDepends = [ base cairo colour diagrams gtk ]; description = "Display simple diagrams from ghci"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghci-haskeline" = callPackage @@ -102811,8 +96425,6 @@ self: { ]; description = "An implementation of ghci using the Haskeline line-input library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghci-hexcalc" = callPackage @@ -102837,8 +96449,6 @@ self: { testHaskellDepends = [ base doctest hspec parsec ]; description = "parse output of ghci \":history\" command"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghci-lib" = callPackage @@ -102850,8 +96460,6 @@ self: { libraryHaskellDepends = [ base ghc MissingH ]; description = "A library for interactively evaluating Haskell code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghci-ng" = callPackage @@ -102873,8 +96481,6 @@ self: { ]; description = "Next generation GHCi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghci-pretty" = callPackage @@ -102886,8 +96492,6 @@ self: { libraryHaskellDepends = [ base hscolour ipprint ]; description = "colored pretty-printing within ghci"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghci-websockets" = callPackage @@ -103123,8 +96727,6 @@ self: { sha256 = "02m0qszdl3kxyhjrzj1ph9gwbr9jkzak2v1b47v6ywsm7hmjgn7w"; description = "DOM library using JSFFI and GHCJS"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghcjs-dom-webkit" = callPackage @@ -103157,8 +96759,6 @@ self: { ]; description = "GHCJS bindings for the JavaScript Fetch API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghcjs-hplay" = callPackage @@ -103175,8 +96775,6 @@ self: { ]; description = "Client-side web EDSL for transient nodes running in the web browser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghcjs-perch" = callPackage @@ -103199,8 +96797,6 @@ self: { libraryHaskellDepends = [ base ghcjs-base protolude ]; description = "Bidirectional bidings to javascript's promise"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghcjs-vdom" = callPackage @@ -103249,8 +96845,6 @@ self: { libraryHaskellDepends = [ base ghcjs-base text ]; description = "XmlHttpRequest (\"AJAX\") bindings for GHCJS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghclive" = callPackage @@ -103277,8 +96871,6 @@ self: { ]; description = "Interactive Haskell interpreter in a browser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghcprofview" = callPackage @@ -103297,8 +96889,6 @@ self: { ]; description = "GHC .prof files viewer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghcup" = callPackage @@ -103352,8 +96942,6 @@ self: { ]; description = "ghc toolchain installer"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ghczdecode" = callPackage @@ -103402,8 +96990,6 @@ self: { ]; description = "Trivial routines for inspecting git repositories"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gi-atk" = callPackage @@ -103505,8 +97091,6 @@ self: { ]; description = "Bridge between packages gi-* and cairo-core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gi-cairo-connector" = callPackage @@ -104022,8 +97606,6 @@ self: { libraryPkgconfigDepends = [ graphene-gobject ]; description = "Graphene bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {graphene-gobject = null;}; "gi-graphene_1_0_3" = callPackage @@ -104044,7 +97626,6 @@ self: { description = "Graphene bindings"; license = lib.licenses.lgpl21Only; hydraPlatforms = lib.platforms.none; - broken = true; }) {graphene-gobject = null;}; "gi-gsk" = callPackage @@ -104069,8 +97650,6 @@ self: { libraryPkgconfigDepends = [ gtk4 ]; description = "Gsk bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk4;}; "gi-gst" = callPackage @@ -104111,8 +97690,6 @@ self: { libraryPkgconfigDepends = [ gst-plugins-base ]; description = "GStreamerAudio bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs.gst_all_1) gst-plugins-base;}; "gi-gstbase" = callPackage @@ -104158,8 +97735,6 @@ self: { libraryPkgconfigDepends = [ gstreamer-pbutils ]; description = "GStreamer Plugins Base Utils bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gstreamer-pbutils = null;}; "gi-gsttag" = callPackage @@ -104181,8 +97756,6 @@ self: { libraryPkgconfigDepends = [ gstreamer-tag ]; description = "GStreamer Tag bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gstreamer-tag = null;}; "gi-gstvideo" = callPackage @@ -104379,8 +97952,6 @@ self: { libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ]; description = "GtkosxApplication bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gtk-mac-integration-gtk3 = null;}; "gi-gtksheet" = callPackage @@ -104405,8 +97976,6 @@ self: { libraryPkgconfigDepends = [ gtksheet ]; description = "GtkSheet bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gtksheet = null;}; "gi-gtksource" = callPackage @@ -104455,8 +98024,6 @@ self: { libraryPkgconfigDepends = [ libhandy ]; description = "libhandy bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libhandy;}; "gi-harfbuzz" = callPackage @@ -104703,8 +98270,6 @@ self: { libraryPkgconfigDepends = [ poppler_gi ]; description = "Poppler bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) poppler_gi;}; "gi-secret" = callPackage @@ -104788,8 +98353,6 @@ self: { libraryPkgconfigDepends = [ vips ]; description = "libvips GObject bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) vips;}; "gi-vte" = callPackage @@ -104938,8 +98501,6 @@ self: { libraryPkgconfigDepends = [ libwnck ]; description = "Wnck bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libwnck;}; "gi-xlib" = callPackage @@ -104998,8 +98559,6 @@ self: { ]; description = "Fuzzy finder for cabal executables"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gimlh" = callPackage @@ -105087,8 +98646,6 @@ self: { executableSystemDepends = [ openssl ]; description = "Ginsu Gale Client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "gio" = callPackage @@ -105129,8 +98686,6 @@ self: { ]; description = "Git Performance Dashboard"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "giphy-api" = callPackage @@ -105156,8 +98711,6 @@ self: { ]; description = "Giphy HTTP API wrapper and CLI search tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gist" = callPackage @@ -105175,8 +98728,6 @@ self: { ]; description = "A reliable command-line client for gist.github.com"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git" = callPackage @@ -105201,8 +98752,6 @@ self: { doCheck = false; description = "Git operations in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-all" = callPackage @@ -105221,8 +98770,6 @@ self: { ]; description = "Determine which Git repositories need actions to be taken"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-annex" = callPackage @@ -105336,8 +98883,6 @@ self: { ]; description = "Maintain per-branch checklists in Git"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-config" = callPackage @@ -105359,8 +98904,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A simple parser for Git configuration files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-cuk" = callPackage @@ -105380,8 +98923,6 @@ self: { executableHaskellDepends = [ base relude ]; description = "Haskell Git Helper Tool"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-date" = callPackage @@ -105402,8 +98943,6 @@ self: { ]; description = "Bindings to the date parsing from Git"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-embed" = callPackage @@ -105441,8 +98980,6 @@ self: { ]; description = "Custom git command for formatting code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-freq" = callPackage @@ -105485,8 +99022,6 @@ self: { ]; description = "More intelligent push-to-GitHub utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-jump" = callPackage @@ -105500,8 +99035,6 @@ self: { executableHaskellDepends = [ base base-compat process ]; description = "Move a git branch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-lfs" = callPackage @@ -105559,8 +99092,6 @@ self: { ]; description = "Passively snapshots working tree changes efficiently"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-object" = callPackage @@ -105577,8 +99108,6 @@ self: { ]; description = "Git object and its parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-remote-ipfs" = callPackage @@ -105611,7 +99140,6 @@ self: { description = "Git remote helper to store git objects on IPFS"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-repair" = callPackage @@ -105640,8 +99168,6 @@ self: { ]; description = "repairs a damaged git repository"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-sanity" = callPackage @@ -105661,8 +99187,6 @@ self: { executableHaskellDepends = [ base Cabal ]; description = "A sanity checker for your git history"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "git-vogue" = callPackage @@ -105692,8 +99216,6 @@ self: { testToolDepends = [ git ]; description = "A framework for pre-commit checks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitHUD" = callPackage @@ -105749,8 +99271,6 @@ self: { ]; description = "Create Github issues out of TODO comments in code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "githash" = callPackage @@ -105827,8 +99347,6 @@ self: { executableToolDepends = [ git ]; description = "backs up everything github knows about a repository, to the repository"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) git;}; "github-data" = callPackage @@ -105854,8 +99372,6 @@ self: { ]; description = "Access to the GitHub API, v3"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "github-post-receive" = callPackage @@ -105934,8 +99450,6 @@ self: { ]; description = "Various Github helper utilities"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "github-types" = callPackage @@ -105966,8 +99480,6 @@ self: { libraryHaskellDepends = [ base basic-prelude github text ]; description = "Useful functions that use the GitHub API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "github-webhook-handler" = callPackage @@ -105986,8 +99498,6 @@ self: { ]; description = "GitHub WebHook Handler"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "github-webhook-handler-snap" = callPackage @@ -106006,8 +99516,6 @@ self: { ]; description = "GitHub WebHook Handler implementation for Snap"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "github-webhooks" = callPackage @@ -106051,8 +99559,6 @@ self: { ]; description = "Heads up, and you see your GIT context"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitignore" = callPackage @@ -106071,8 +99577,6 @@ self: { ]; description = "Apply GitHub .gitignore templates to already existing repositories."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitit" = callPackage @@ -106126,8 +99630,6 @@ self: { testHaskellDepends = [ base hspec rio ]; description = "Gitlab Web API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlab-haskell" = callPackage @@ -106167,8 +99669,6 @@ self: { ]; description = "API library for working with Git repositories"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlib-cmdline" = callPackage @@ -106196,8 +99696,6 @@ self: { ]; description = "Gitlib repository backend that uses the git command-line tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlib-cross" = callPackage @@ -106215,8 +99713,6 @@ self: { ]; description = "Run tests between repositories"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlib-libgit2" = callPackage @@ -106243,8 +99739,6 @@ self: { ]; description = "Libgit2 backend for gitlib"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlib-s3" = callPackage @@ -106274,8 +99768,6 @@ self: { ]; description = "Gitlib repository backend for storing Git objects in Amazon S3"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlib-sample" = callPackage @@ -106289,8 +99781,6 @@ self: { ]; description = "Sample backend for gitlib showing the basic structure for any backend"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlib-test" = callPackage @@ -106309,8 +99799,6 @@ self: { ]; description = "Test library for confirming gitlib backend compliance"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitlib-utils" = callPackage @@ -106329,8 +99817,6 @@ self: { ]; description = "Generic utility functions for working with Git repositories"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitrev" = callPackage @@ -106371,8 +99857,6 @@ self: { ]; description = "A document store library for Git + JSON"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gitter" = callPackage @@ -106388,8 +99872,6 @@ self: { ]; description = "Gitter.im API client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "givegif" = callPackage @@ -106417,8 +99899,6 @@ self: { ]; description = "CLI Giphy search tool with previews in iTerm 2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gjk" = callPackage @@ -106517,8 +99997,6 @@ self: { libraryPkgconfigDepends = [ libglade ]; description = "Binding to the glade library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs.gnome2) libglade;}; "gladexml-accessor" = callPackage @@ -106530,8 +100008,6 @@ self: { libraryHaskellDepends = [ base glade HaXml template-haskell ]; description = "Automagically declares getters for widget handles in specified interface file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glambda" = callPackage @@ -106572,8 +100048,6 @@ self: { ]; description = "An OpenGL micro framework"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glasso" = callPackage @@ -106619,8 +100093,6 @@ self: { ]; description = "Extensible effects using ContT, State and variants"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glazier-pipes" = callPackage @@ -106636,8 +100108,6 @@ self: { ]; description = "A threaded rendering framework using glaizer and pipes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glazier-react" = callPackage @@ -106657,8 +100127,6 @@ self: { ]; description = "ReactJS binding using Glazier.Command."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glazier-react-examples" = callPackage @@ -106683,8 +100151,6 @@ self: { ]; description = "Examples of using glazier-react"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glazier-react-widget" = callPackage @@ -106704,8 +100170,6 @@ self: { ]; description = "Generic widget library using glazier-react"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gli" = callPackage @@ -106730,8 +100194,6 @@ self: { testHaskellDepends = [ base ]; description = "Tiny cli to fetch PR info from gitlab"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glib" = callPackage @@ -106777,8 +100239,6 @@ self: { testHaskellDepends = [ base Cabal containers hspec text ]; description = "Natural Language Processing library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glintcollider" = callPackage @@ -106858,8 +100318,6 @@ self: { benchmarkHaskellDepends = [ base criterion Glob MissingH ]; description = "Haskell bindings for POSIX glob library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "global" = callPackage @@ -106877,8 +100335,6 @@ self: { ]; description = "Library enabling unique top-level declarations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "global-config" = callPackage @@ -106899,8 +100355,6 @@ self: { ]; description = "Global mutable configuration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "global-lock" = callPackage @@ -106923,8 +100377,6 @@ self: { libraryHaskellDepends = [ base containers stm ]; description = "Namespaced, global, and top-level mutable variables without unsafePerformIO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glome-hs" = callPackage @@ -106948,8 +100400,6 @@ self: { doHaddock = false; description = "ray tracer"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gloss" = callPackage @@ -107004,8 +100454,6 @@ self: { libraryHaskellDepends = [ base gloss reactive-banana ]; description = "An Interface for gloss in terms of a reactive-banana Behavior"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gloss-devil" = callPackage @@ -107017,8 +100465,6 @@ self: { libraryHaskellDepends = [ base bytestring gloss repa repa-devil ]; description = "Display images in Gloss using libdevil for decoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gloss-examples" = callPackage @@ -107038,8 +100484,6 @@ self: { ]; description = "Examples using the gloss library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gloss-export" = callPackage @@ -107059,8 +100503,6 @@ self: { testHaskellDepends = [ base directory filepath gloss JuicyPixels ]; description = "Export Gloss pictures to png, bmp, tga, tiff, gif and juicy-pixels-image"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gloss-game" = callPackage @@ -107072,8 +100514,6 @@ self: { libraryHaskellDepends = [ base gloss gloss-juicy ]; description = "Gloss wrapper that simplifies writing games"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gloss-juicy" = callPackage @@ -107152,8 +100592,6 @@ self: { libraryHaskellDepends = [ base gloss sodium ]; description = "A Sodium interface to the Gloss drawing package"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glpk-headers" = callPackage @@ -107172,8 +100610,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Low-level Haskell bindings to GLPK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) glpk;}; "glpk-hs" = callPackage @@ -107192,8 +100628,6 @@ self: { ]; description = "Comprehensive GLPK linear programming bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) glpk;}; "glsl" = callPackage @@ -107238,8 +100672,6 @@ self: { testHaskellDepends = [ base bytestring directory filepath shower ]; description = "glTF scene loader"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glue" = callPackage @@ -107269,8 +100701,6 @@ self: { ]; description = "Make better services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "glue-common" = callPackage @@ -107391,8 +100821,6 @@ self: { ]; description = "Composable maps and generic tries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gmndl" = callPackage @@ -107411,8 +100839,6 @@ self: { ]; description = "Mandelbrot Set explorer using GTK"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gmpint" = callPackage @@ -107440,8 +100866,6 @@ self: { ]; description = "Randomly set a picture as the GNOME desktop background"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gnome-keyring" = callPackage @@ -107479,8 +100903,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GNOME Virtual File System library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gnome-vfs = null; gnome-vfs_module = null;}; "gnss-converters" = callPackage @@ -107508,8 +100930,6 @@ self: { ]; description = "GNSS Converters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gnuidn" = callPackage @@ -107532,8 +100952,6 @@ self: { testToolDepends = [ c2hs ]; description = "Bindings for GNU IDN"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libidn;}; "gnuplot" = callPackage @@ -107583,8 +101001,6 @@ self: { libraryHaskellDepends = [ base directory filepath process ]; description = "GHCi bindings to lambdabot"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "goal-core" = callPackage @@ -107604,8 +101020,6 @@ self: { executableHaskellDepends = [ base ]; description = "Core imports for Geometric Optimization Libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "goal-geometry" = callPackage @@ -107620,8 +101034,6 @@ self: { executableHaskellDepends = [ base goal-core ]; description = "Scientific computing on geometric objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "goal-probability" = callPackage @@ -107641,8 +101053,6 @@ self: { executableHaskellDepends = [ base goal-core goal-geometry vector ]; description = "Manifolds of probability distributions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "goal-simulation" = callPackage @@ -107666,8 +101076,6 @@ self: { ]; description = "Mealy based simulation tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "goat" = callPackage @@ -107702,8 +101110,6 @@ self: { testHaskellDepends = [ base containers HUnit mtl parsec ]; description = "A monadic take on a 2,500-year-old board game - library"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "goatee-gtk" = callPackage @@ -107724,8 +101130,6 @@ self: { testHaskellDepends = [ base HUnit ]; description = "A monadic take on a 2,500-year-old board game - GTK+ UI"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gochan" = callPackage @@ -107747,8 +101151,6 @@ self: { testHaskellDepends = [ base hspec hspec-core ]; description = "Go-style channels"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "godot-haskell" = callPackage @@ -107771,8 +101173,6 @@ self: { doHaddock = false; description = "Haskell bindings for the Godot game engine API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gofer-prelude" = callPackage @@ -107784,8 +101184,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "The Gofer 2.30 standard prelude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "goggles" = callPackage @@ -110065,8 +103463,6 @@ self: { ]; description = "A lightweight golden test runner"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gooey" = callPackage @@ -110078,8 +103474,6 @@ self: { libraryHaskellDepends = [ base renderable transformers varying ]; description = "Graphical user interfaces that are renderable, change over time and eventually produce a value"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-cloud" = callPackage @@ -110099,8 +103493,6 @@ self: { ]; description = "Client for the Google Cloud APIs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-dictionary" = callPackage @@ -110135,8 +103527,6 @@ self: { ]; description = "Google Drive API access"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-html5-slide" = callPackage @@ -110155,8 +103545,6 @@ self: { ]; description = "Google HTML5 Slide generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-isbn" = callPackage @@ -110187,8 +103575,6 @@ self: { testHaskellDepends = [ base google-search text time xml-conduit ]; description = "Write GMail filters and output to importable XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-maps-geocoding" = callPackage @@ -110205,8 +103591,6 @@ self: { ]; description = "Bindings to the Google Geocoding API (formerly Maps Geocoding API)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-oauth2" = callPackage @@ -110227,8 +103611,6 @@ self: { ]; description = "Google OAuth2 token negotiation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-oauth2-easy" = callPackage @@ -110248,8 +103630,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Opininated use of Google Authentication for ease"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-oauth2-for-cli" = callPackage @@ -110282,8 +103662,6 @@ self: { ]; description = "Get a signed JWT for Google Service Accounts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-search" = callPackage @@ -110295,8 +103673,6 @@ self: { libraryHaskellDepends = [ base free nats text time ]; description = "EDSL for Google and GMail search expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-server-api" = callPackage @@ -110320,8 +103696,6 @@ self: { ]; description = "Google APIs for server to server applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-static-maps" = callPackage @@ -110341,8 +103715,6 @@ self: { ]; description = "Bindings to the Google Maps Static API (formerly Static Maps API)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "google-translate" = callPackage @@ -110359,8 +103731,6 @@ self: { ]; description = "Google Translate API bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "googleplus" = callPackage @@ -110378,8 +103748,6 @@ self: { ]; description = "Haskell implementation of the Google+ API v1"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "googlepolyline" = callPackage @@ -110398,8 +103766,6 @@ self: { ]; description = "Google Polyline Encoder/Decoder"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gopher-proxy" = callPackage @@ -110438,8 +103804,6 @@ self: { ]; description = "Spidering robot to download files from Gopherspace"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gopro-plus" = callPackage @@ -110468,8 +103832,6 @@ self: { ]; description = "GoPro Plus Client API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash" = callPackage @@ -110488,8 +103850,6 @@ self: { ]; description = "Core of FRP game engine called Gore&Ash"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-actor" = callPackage @@ -110507,8 +103867,6 @@ self: { ]; description = "Gore&Ash engine extension that implements actor style of programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-async" = callPackage @@ -110531,8 +103889,6 @@ self: { ]; description = "Core module for Gore&Ash engine that embeds async IO actions into game loop"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-demo" = callPackage @@ -110558,8 +103914,6 @@ self: { ]; description = "Demonstration game for Gore&Ash game engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-glfw" = callPackage @@ -110576,8 +103930,6 @@ self: { ]; description = "Core module for Gore&Ash engine for GLFW input events"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-lambdacube" = callPackage @@ -110597,8 +103949,6 @@ self: { ]; description = "Core module for Gore&Ash engine that do something"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-logging" = callPackage @@ -110617,8 +103967,6 @@ self: { ]; description = "Core module for gore-and-ash with logging utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-network" = callPackage @@ -110640,8 +103988,6 @@ self: { ]; description = "Core module for Gore&Ash engine with low level network API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-sdl" = callPackage @@ -110660,8 +104006,6 @@ self: { ]; description = "Gore&Ash core module for integration with SDL library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gore-and-ash-sync" = callPackage @@ -110681,8 +104025,6 @@ self: { ]; description = "Gore&Ash module for high level network synchronization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gothic" = callPackage @@ -110740,8 +104082,6 @@ self: { ]; description = "Generic Programming Use in Hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gpcsets" = callPackage @@ -110806,8 +104146,6 @@ self: { ]; description = "For manipulating GPS coordinates and trails"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gps2htmlReport" = callPackage @@ -110828,8 +104166,6 @@ self: { ]; description = "GPS to HTML Summary Report"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gpx-conduit" = callPackage @@ -110846,8 +104182,6 @@ self: { ]; description = "Read GPX files using conduits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grab" = callPackage @@ -110861,8 +104195,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Applicative non-linear consumption"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grab-form" = callPackage @@ -110875,8 +104207,6 @@ self: { testHaskellDepends = [ base containers hedgehog text ]; description = "Applicative parsers for form parameter lists"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graceful" = callPackage @@ -110893,8 +104223,6 @@ self: { ]; description = "Library to write graceful shutdown / upgrade service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grafana" = callPackage @@ -110913,8 +104241,6 @@ self: { ]; description = "API for creating grafana dashboards represented as json"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graflog" = callPackage @@ -110933,8 +104259,6 @@ self: { ]; description = "Monadic correlated log events"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grakn" = callPackage @@ -110958,8 +104282,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "A Haskell client for Grakn"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grammar-combinators" = callPackage @@ -110977,8 +104299,6 @@ self: { ]; description = "A parsing library of context-free grammar combinators"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grammatical-parsers" = callPackage @@ -111014,8 +104334,6 @@ self: { ]; description = "parsers that combine into grammars"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grapefruit-examples" = callPackage @@ -111032,8 +104350,6 @@ self: { ]; description = "Examples using the Grapefruit library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grapefruit-frp" = callPackage @@ -111051,8 +104367,6 @@ self: { ]; description = "Functional Reactive Programming core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grapefruit-records" = callPackage @@ -111064,8 +104378,6 @@ self: { libraryHaskellDepends = [ arrows base grapefruit-frp ]; description = "A record system for Functional Reactive Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grapefruit-ui" = callPackage @@ -111084,8 +104396,6 @@ self: { ]; description = "Declarative user interface programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grapefruit-ui-gtk" = callPackage @@ -111105,8 +104415,6 @@ self: { ]; description = "GTK+-based backend for declarative user interface programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph" = callPackage @@ -111141,8 +104449,6 @@ self: { ]; description = "Fast, memory efficient and persistent graph implementation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-generators" = callPackage @@ -111178,8 +104484,6 @@ self: { libraryHaskellDepends = [ base containers fgl ]; description = "An implementation of algorithms for matchings in graphs"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting" = callPackage @@ -111193,8 +104497,6 @@ self: { ]; description = "Monadic graph rewriting of hypergraphs with ports and multiedges"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-cl" = callPackage @@ -111214,8 +104516,6 @@ self: { ]; description = "Interactive graph rewriting system implementing various well-known combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-gl" = callPackage @@ -111232,8 +104532,6 @@ self: { ]; description = "OpenGL interface for interactive port graph rewriting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-lambdascope" = callPackage @@ -111255,8 +104553,6 @@ self: { ]; description = "Lambdascope, an optimal evaluator of the lambda calculus, as an interactive graph-rewriting system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-layout" = callPackage @@ -111272,8 +104568,6 @@ self: { ]; description = "Force-directed node placement intended for incremental graph drawing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-ski" = callPackage @@ -111293,8 +104587,6 @@ self: { ]; description = "Two evalutors of the SKI combinator calculus as interactive graph rewrite systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-strategies" = callPackage @@ -111310,8 +104602,6 @@ self: { ]; description = "Evaluation strategies for port-graph rewriting systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-trs" = callPackage @@ -111333,8 +104623,6 @@ self: { ]; description = "Evaluate first-order applicative term rewrite systems interactively using graph reduction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-rewriting-ww" = callPackage @@ -111355,8 +104643,6 @@ self: { ]; description = "Evaluator of the lambda-calculus in an interactive graph rewriting system with explicit sharing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-serialize" = callPackage @@ -111368,8 +104654,6 @@ self: { libraryHaskellDepends = [ array base bytestring containers ]; description = "Serialization of data structures with references"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-utils" = callPackage @@ -111385,8 +104669,6 @@ self: { ]; description = "A simple wrapper & quasi quoter for fgl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-visit" = callPackage @@ -111402,8 +104684,6 @@ self: { ]; description = "Graph walk abstraction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graph-wrapper" = callPackage @@ -111437,8 +104717,6 @@ self: { ]; description = "A declarative, monadic graph construction language for small graphs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphene" = callPackage @@ -111455,8 +104733,6 @@ self: { ]; description = "A minimal Graph Theory library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphics-drawingcombinators" = callPackage @@ -111474,8 +104750,6 @@ self: { ]; description = "A functional interface to 2D drawing in OpenGL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphics-formats-collada" = callPackage @@ -111491,8 +104765,6 @@ self: { ]; description = "Load 3D geometry in the COLLADA format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphicsFormats" = callPackage @@ -111504,8 +104776,6 @@ self: { libraryHaskellDepends = [ base haskell98 OpenGL QuickCheck ]; description = "Classes for renderable objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphicstools" = callPackage @@ -111524,8 +104794,6 @@ self: { executableHaskellDepends = [ base CV wx wxcore ]; description = "Tools for creating graphical UIs, based on wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphite" = callPackage @@ -111582,8 +104850,6 @@ self: { executableHaskellDepends = [ base ]; description = "A reimplementation of graphmod as a source plugin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphql" = callPackage @@ -111608,8 +104874,6 @@ self: { ]; description = "Haskell GraphQL implementation"; license = "MPL-2.0 AND BSD-3-Clause"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphql-api" = callPackage @@ -111639,8 +104903,6 @@ self: { ]; description = "GraphQL API"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphql-client" = callPackage @@ -111671,8 +104933,6 @@ self: { ]; description = "A client for Haskell programs to query a GraphQL API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphql-utils" = callPackage @@ -111688,8 +104948,6 @@ self: { ]; description = "GraphQL Utils"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphql-w-persistent" = callPackage @@ -111701,8 +104959,6 @@ self: { libraryHaskellDepends = [ base containers json text ]; description = "GraphQL interface middleware for SQL databases"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphs" = callPackage @@ -111731,8 +104987,6 @@ self: { libraryHaskellDepends = [ base indexed ]; description = "Graph indexed monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphtype" = callPackage @@ -111750,8 +105004,6 @@ self: { ]; description = "A simple tool to illustrate dependencies between Haskell types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphula" = callPackage @@ -111779,8 +105031,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "A declarative library for describing dependencies between data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphula-core" = callPackage @@ -111810,8 +105060,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "A declarative library for describing dependencies between data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "graphviz" = callPackage @@ -111855,8 +105103,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Execute Graql queries on a Grakn graph"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grasp" = callPackage @@ -111881,8 +105127,6 @@ self: { testHaskellDepends = [ base ]; description = "GRASP implementation for the AMMM project"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gravatar" = callPackage @@ -111911,8 +105155,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Gray code encoder/decoder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gray-extended" = callPackage @@ -111965,8 +105207,6 @@ self: { executableHaskellDepends = [ array base containers pretty ]; description = "GreenCard, a foreign function pre-processor for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "greencard-lib" = callPackage @@ -111979,8 +105219,6 @@ self: { libraryHaskellDepends = [ array base containers greencard pretty ]; description = "A foreign function interface pre-processor library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "greenclip" = callPackage @@ -112017,8 +105255,6 @@ self: { ]; description = "A scalable distributed logger with a high-precision global time axis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gremlin-haskell" = callPackage @@ -112042,8 +105278,6 @@ self: { testHaskellDepends = [ aeson-qq base hspec lens lens-aeson mtl ]; description = "Graph database client for TinkerPop3 Gremlin Server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grenade" = callPackage @@ -112067,8 +105301,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion hmatrix ]; description = "Practical Deep Learning in Haskell"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "greplicate" = callPackage @@ -112189,8 +105421,6 @@ self: { ]; description = "Grid-based prototyping framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gridbounds" = callPackage @@ -112203,8 +105433,6 @@ self: { testHaskellDepends = [ base earclipper gjk gridbox hspec ]; description = "Collision detection for GridBox"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gridbox" = callPackage @@ -112253,8 +105481,6 @@ self: { ]; description = "Grid-based multimedia engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grids" = callPackage @@ -112298,8 +105524,6 @@ self: { executableToolDepends = [ happy ]; description = "grm grammar converter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "groom" = callPackage @@ -112363,8 +105587,6 @@ self: { ]; description = "Command line utility to manage AWS ECS resources"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gross" = callPackage @@ -112379,8 +105601,6 @@ self: { executableHaskellDepends = [ base lens mtl ncurses ]; description = "A spoof on gloss for terminal animation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "groundhog" = callPackage @@ -112418,8 +105638,6 @@ self: { ]; description = "Extended Converter Library for groundhog embedded types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "groundhog-inspector" = callPackage @@ -112460,8 +105678,6 @@ self: { ]; description = "MySQL backend for the groundhog library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "groundhog-postgresql" = callPackage @@ -112542,8 +105758,6 @@ self: { libraryHaskellDepends = [ base containers groups ]; description = "The theory of groups"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "group-with" = callPackage @@ -112560,8 +105774,6 @@ self: { ]; description = "Classify objects by key-generating function, like SQL GROUP BY"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "groupBy" = callPackage @@ -112594,8 +105806,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Grouped lists. Equal consecutive elements are grouped."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "groupoid" = callPackage @@ -112641,8 +105851,6 @@ self: { libraryHaskellDepends = [ base generic-data groups ]; description = "Generically derive Group instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grow-vector" = callPackage @@ -112683,8 +105891,6 @@ self: { ]; description = "A revised version of the scotty library that attempts to be simpler and more performant"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grpc-api-etcd" = callPackage @@ -112696,8 +105902,6 @@ self: { libraryHaskellDepends = [ base proto-lens proto-lens-runtime ]; description = "Generated messages and instances for etcd gRPC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grpc-etcd-client" = callPackage @@ -112714,8 +105918,6 @@ self: { ]; description = "gRPC client for etcd"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grpc-haskell" = callPackage @@ -112746,8 +105948,6 @@ self: { ]; description = "Haskell implementation of gRPC layered on shared C library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "grpc-haskell-core" = callPackage @@ -112773,8 +105973,6 @@ self: { ]; description = "Haskell implementation of gRPC layered on shared C library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gpr = null; inherit (pkgs) grpc;}; "gruff" = callPackage @@ -112796,8 +105994,6 @@ self: { ]; description = "fractal explorer GUI using the ruff library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gruff-examples" = callPackage @@ -112816,8 +106012,6 @@ self: { ]; description = "Mandelbrot Set examples using ruff and gruff"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gsasl" = callPackage @@ -112863,8 +106057,6 @@ self: { ]; description = "scrapes google scholar, provides RSS feed"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gsl-random" = callPackage @@ -112877,8 +106069,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Bindings the the GSL random number generation facilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gsl-random-fu" = callPackage @@ -112890,8 +106080,6 @@ self: { libraryHaskellDepends = [ base gsl-random random-fu ]; description = "Instances for using gsl-random with random-fu"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gsmenu" = callPackage @@ -112956,8 +106144,6 @@ self: { ]; description = "Generic implementation of Storable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gstreamer" = callPackage @@ -112977,8 +106163,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GStreamer open source multimedia framework"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gst-plugins-base = null; gstreamer = null;}; "gt-tools" = callPackage @@ -113012,8 +106196,6 @@ self: { ]; description = "The General Transit Feed Specification format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gtfs-realtime" = callPackage @@ -113029,8 +106211,6 @@ self: { ]; description = "GTFS RealTime protobafs library (autogenerated from .proto file)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gtk" = callPackage @@ -113125,8 +106305,6 @@ self: { libraryPkgconfigDepends = [ gtk2 ]; description = "GTK+ Serialized event"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk2;}; "gtk-simple-list-view" = callPackage @@ -113204,8 +106382,6 @@ self: { libraryHaskellDepends = [ base containers gtk ]; description = "Convenient Gtk canvas with mouse and keyboard input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gtk-traymanager" = callPackage @@ -113357,8 +106533,6 @@ self: { executableHaskellDepends = [ base glib gtk3 transformers ]; description = "Gtk2Hs Hello World, an example package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gtk2hs-rpn" = callPackage @@ -113370,8 +106544,6 @@ self: { libraryHaskellDepends = [ base cairo glib gtk mtl ]; description = "Adds a module to gtk2hs allowing layouts to be defined using reverse polish notation"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gtk3" = callPackage @@ -113423,8 +106595,6 @@ self: { libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ]; description = "Bindings for the Gtk/OS X integration library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gtk-mac-integration-gtk3 = null;}; "gtkglext" = callPackage @@ -113443,8 +106613,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GTK+ OpenGL Extension"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk2; inherit (pkgs.gnome2) gtkglext; inherit (pkgs) libGLU; inherit (pkgs.xorg) libICE; inherit (pkgs.xorg) libSM; inherit (pkgs.xorg) libXmu; @@ -113466,8 +106634,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GtkImageView library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtkimageview;}; "gtkrsync" = callPackage @@ -113486,8 +106652,6 @@ self: { ]; description = "Gnome rsync progress display"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gtksourceview2" = callPackage @@ -113507,8 +106671,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GtkSourceView library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtksourceview;}; "gtksourceview3" = callPackage @@ -113528,8 +106690,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GtkSourceView library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtksourceview3;}; "guarded-allocation" = callPackage @@ -113552,8 +106712,6 @@ self: { libraryHaskellDepends = [ base instant-generics ]; description = "Datatype-generic rewriting with preconditions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "guess-combinator" = callPackage @@ -113565,8 +106723,6 @@ self: { libraryHaskellDepends = [ base HList ]; description = "Generate simple combinators given their type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "guid" = callPackage @@ -113593,8 +106749,6 @@ self: { executableHaskellDepends = [ base cairo containers filepath gtk ]; description = "graphical untyped lambda calculus interactive interpreter"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gutenberg-fibonaccis" = callPackage @@ -113619,8 +106773,6 @@ self: { executableHaskellDepends = [ base unix ]; description = "ghcWithPackages cmdline util"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gyah-bin" = callPackage @@ -113634,8 +106786,6 @@ self: { executableHaskellDepends = [ base extra GiveYouAHead ]; description = "A binary version of GiveYouAHead"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "gym-http-api" = callPackage @@ -113657,8 +106807,6 @@ self: { ]; description = "REST client to the gym-http-api project"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "h-booru" = callPackage @@ -113682,8 +106830,6 @@ self: { ]; description = "Haskell library for retrieving data from various booru image sites"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "h-gpgme" = callPackage @@ -113707,8 +106853,6 @@ self: { ]; description = "High Level Binding for GnuPG Made Easy (gpgme)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "h-reversi" = callPackage @@ -113732,8 +106876,6 @@ self: { ]; description = "Reversi game in haskell/blank-canvas"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "h2048" = callPackage @@ -113760,8 +106902,6 @@ self: { ]; description = "An Implementation of Game 2048"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "h2c" = callPackage @@ -113773,8 +106913,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl resourcet ]; description = "Bindings to Linux I2C with support for repeated-start transactions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hArduino" = callPackage @@ -113790,8 +106928,6 @@ self: { ]; description = "Control your Arduino board from Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hBDD" = callPackage @@ -113818,8 +106954,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "An FFI binding to CMU/Long's BDD library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {bdd = null; mem = null;}; "hBDD-CUDD" = callPackage @@ -113835,8 +106969,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "An FFI binding to the CUDD library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) cudd; epd = null; inherit (pkgs) mtr; inherit (pkgs) st; util = null;}; @@ -113853,8 +106985,6 @@ self: { testHaskellDepends = [ base hashable ]; description = "Conceptual modelling support for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hCsound" = callPackage @@ -113870,8 +107000,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "interface to CSound API"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {csound64 = null; inherit (pkgs) libsndfile;}; "hDFA" = callPackage @@ -113883,8 +107011,6 @@ self: { libraryHaskellDepends = [ base containers directory process ]; description = "A simple library for representing and minimising DFAs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hF2" = callPackage @@ -113897,8 +107023,6 @@ self: { libraryHaskellDepends = [ base cereal vector ]; description = "F(2^e) math for cryptography"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hGelf" = callPackage @@ -113915,8 +107039,6 @@ self: { ]; description = "Haskell GELF library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hLLVM" = callPackage @@ -113959,8 +107081,6 @@ self: { ]; description = "Library to interact with the @Mollom anti-spam service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hOff-display" = callPackage @@ -113975,8 +107095,6 @@ self: { executableHaskellDepends = [ base GLFW hOff-parser OpenGL parsec ]; description = "The tool to transform the OFF to other image format"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hOff-parser" = callPackage @@ -114054,8 +107172,6 @@ self: { ]; description = "Protein Databank file format library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hPDB-examples" = callPackage @@ -114082,8 +107198,6 @@ self: { ]; description = "Examples for hPDB library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hPushover" = callPackage @@ -114099,8 +107213,6 @@ self: { ]; description = "Pushover.net API functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hR" = callPackage @@ -114112,8 +107224,6 @@ self: { libraryHaskellDepends = [ array base containers unix ]; description = "R bindings and interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hRESP" = callPackage @@ -114160,8 +107270,6 @@ self: { ]; description = "A Haskell library to scrape and crawl web-pages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hSimpleDB" = callPackage @@ -114178,8 +107286,6 @@ self: { ]; description = "Interface to Amazon's SimpleDB service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hTalos" = callPackage @@ -114193,8 +107299,6 @@ self: { testHaskellDepends = [ base ]; description = "Parser, print and manipulate structures in PDB file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hTensor" = callPackage @@ -114206,8 +107310,6 @@ self: { libraryHaskellDepends = [ base containers hmatrix random ]; description = "Multidimensional arrays and simple tensor computations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hVOIDP" = callPackage @@ -114223,8 +107325,6 @@ self: { executableSystemDepends = [ blas liblapack ]; description = "Optimal variable selection in chain graphical model"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) blas; liblapack = null;}; "hXmixer" = callPackage @@ -114258,8 +107358,6 @@ self: { ]; description = "Haar wavelet transforms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "habit" = callPackage @@ -114284,8 +107382,6 @@ self: { executableHaskellDepends = [ base text ]; description = "Haskell message bot framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hable" = callPackage @@ -114321,8 +107417,6 @@ self: { ]; description = "A minimalist static blog generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hablog" = callPackage @@ -114345,8 +107439,6 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "A blog system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hacanon-light" = callPackage @@ -114389,8 +107481,6 @@ self: { ]; description = "Hack contrib"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-contrib-press" = callPackage @@ -114407,8 +107497,6 @@ self: { ]; description = "Hack helper that renders Press templates"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-frontend-happstack" = callPackage @@ -114426,8 +107514,6 @@ self: { ]; description = "hack-frontend-happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-frontend-monadcgi" = callPackage @@ -114450,8 +107536,6 @@ self: { libraryHaskellDepends = [ base bytestring hack ]; description = "Hack handler using CGI protocol. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-handler-epoll" = callPackage @@ -114470,8 +107554,6 @@ self: { ]; description = "hack handler implementation using epoll"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-handler-evhttp" = callPackage @@ -114490,8 +107572,6 @@ self: { librarySystemDepends = [ event ]; description = "Hack EvHTTP (libevent) Handler"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {event = null;}; "hack-handler-fastcgi" = callPackage @@ -114504,8 +107584,6 @@ self: { librarySystemDepends = [ fcgi ]; description = "Hack handler direct to fastcgi (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fcgi;}; "hack-handler-happstack" = callPackage @@ -114523,8 +107601,6 @@ self: { ]; description = "Hack Happstack server handler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-handler-hyena" = callPackage @@ -114541,8 +107617,6 @@ self: { ]; description = "Hyena hack handler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-handler-kibro" = callPackage @@ -114557,8 +107631,6 @@ self: { ]; description = "Hack Kibro handler"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-handler-simpleserver" = callPackage @@ -114574,8 +107646,6 @@ self: { ]; description = "A simplistic HTTP server handler for Hack. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-middleware-cleanpath" = callPackage @@ -114589,8 +107659,6 @@ self: { ]; description = "Applies some basic redirect rules to get cleaner paths. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-middleware-clientsession" = callPackage @@ -114606,8 +107674,6 @@ self: { ]; description = "Middleware for easily keeping session data in client cookies. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack-middleware-gzip" = callPackage @@ -114634,8 +107700,6 @@ self: { ]; description = "Automatic wrapping of JSON responses to convert into JSONP. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack2" = callPackage @@ -114698,8 +107762,6 @@ self: { ]; description = "Hack2 Happstack server handler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack2-handler-mongrel2-http" = callPackage @@ -114720,8 +107782,6 @@ self: { ]; description = "Hack2 Mongrel2 HTTP handler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack2-handler-snap-server" = callPackage @@ -114740,8 +107800,6 @@ self: { ]; description = "Hack2 Snap server handler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack2-handler-warp" = callPackage @@ -114758,8 +107816,6 @@ self: { ]; description = "Hack2 warp handler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hack2-interface-wai" = callPackage @@ -114794,8 +107850,6 @@ self: { testHaskellDepends = [ base http-client-tls servant-client ]; description = "An API binding to Hackage API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage-db" = callPackage @@ -114836,8 +107890,6 @@ self: { ]; description = "Compare the public API of different versions of a Hackage library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage-mirror" = callPackage @@ -114867,8 +107919,6 @@ self: { ]; description = "Simple mirroring utility for Hackage"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage-plot" = callPackage @@ -114900,8 +107950,6 @@ self: { executableHaskellDepends = [ base Cabal containers hackage-db ]; description = "Process 00-index.tar.gz from Hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage-proxy" = callPackage @@ -114925,8 +107973,6 @@ self: { ]; description = "Provide a proxy for Hackage which modifies responses in some way. (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage-repo-tool" = callPackage @@ -114949,8 +107995,6 @@ self: { ]; description = "Manage secure file-based package repositories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage-security" = callPackage @@ -115035,8 +108079,6 @@ self: { ]; description = "The Hackage web server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage-sparks" = callPackage @@ -115073,8 +108115,6 @@ self: { ]; description = "Check for differences between working directory and hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage2hwn" = callPackage @@ -115088,8 +108128,6 @@ self: { executableHaskellDepends = [ base download feed tagsoup ]; description = "Convert Hackage RSS feeds to wiki format for publishing on Haskell.org"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackage2twitter" = callPackage @@ -115103,8 +108141,6 @@ self: { executableHaskellDepends = [ base feed feed2twitter ]; description = "Send new Hackage releases to Twitter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackager" = callPackage @@ -115122,8 +108158,6 @@ self: { ]; description = "Hackage testing tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackernews" = callPackage @@ -115148,8 +108182,6 @@ self: { ]; description = "API for Hacker News"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackertyper" = callPackage @@ -115186,8 +108218,6 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "Generate useful files for Haskell projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hackport" = callPackage @@ -115223,8 +108253,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Hackage and Portage integration tool"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hactor" = callPackage @@ -115241,8 +108269,6 @@ self: { ]; description = "Lightweight Erlang-style actors for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hactors" = callPackage @@ -115254,8 +108280,6 @@ self: { libraryHaskellDepends = [ base stm ]; description = "Practical actors for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddock_2_23_1" = callPackage @@ -115273,7 +108297,6 @@ self: { description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddock" = callPackage @@ -115290,8 +108313,6 @@ self: { preCheck = "unset GHC_PACKAGE_PATH"; description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddock-api_2_23_1" = callPackage @@ -115317,7 +108338,6 @@ self: { description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddock-api" = callPackage @@ -115344,8 +108364,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddock-cheatsheet" = callPackage @@ -115357,8 +108375,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A documentation-only package exemplifying haddock markup features"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddock-leksah" = callPackage @@ -115377,8 +108393,6 @@ self: { ]; description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddock-library_1_7_0" = callPackage @@ -115460,8 +108474,6 @@ self: { ]; description = "Test utilities for Haddock"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haddocset" = callPackage @@ -115483,8 +108495,6 @@ self: { ]; description = "Generate docset of Dash by Haddock haskell documentation tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hadolint" = callPackage @@ -115534,8 +108544,6 @@ self: { testHaskellDepends = [ base bytestring filepath text vector ]; description = "Read/write file formats commonly used by Hadoop"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) snappy;}; "hadoop-rpc" = callPackage @@ -115556,8 +108564,6 @@ self: { testHaskellDepends = [ base protobuf tasty tasty-hunit vector ]; description = "Use the Hadoop RPC interface from Haskell"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hadoop-streaming" = callPackage @@ -115599,8 +108605,6 @@ self: { ]; description = "Fast command line tools for working with Hadoop"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haeredes" = callPackage @@ -115631,8 +108635,6 @@ self: { testHaskellDepends = [ base intervals mtl QuickCheck ]; description = "Affine arithmetic library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haggis" = callPackage @@ -115659,8 +108661,6 @@ self: { ]; description = "A static site generator with blogging/comments support"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haggle" = callPackage @@ -115713,8 +108713,6 @@ self: { executableHaskellDepends = [ base time ]; description = "Analytic Hierarchy Process"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haiji" = callPackage @@ -115737,8 +108735,6 @@ self: { ]; description = "A typed template engine, subset of jinja2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hail" = callPackage @@ -115792,8 +108788,6 @@ self: { ]; description = "A program to send emails throught the Mailgun api"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hailgun-simple" = callPackage @@ -115871,7 +108865,6 @@ self: { description = "Dynamic launcher of Hails applications"; license = lib.licenses.gpl2Only; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hairy" = callPackage @@ -115900,8 +108893,6 @@ self: { ]; description = "A JSON REST API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakaru" = callPackage @@ -115931,8 +108922,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ghc-prim ]; description = "A probabilistic programming embedded DSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hake" = callPackage @@ -115960,8 +108949,6 @@ self: { libraryHaskellDepends = [ base HTTP network ]; description = "Akismet spam protection library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakka" = callPackage @@ -115976,8 +108963,6 @@ self: { executableHaskellDepends = [ base ]; description = "Minimal akka-inspired actor library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hako" = callPackage @@ -115994,8 +108979,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "A mako-like quasi-quoter template library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll" = callPackage @@ -116033,8 +109016,6 @@ self: { testToolDepends = [ utillinux ]; description = "A static website compiler library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) utillinux;}; "hakyll-R" = callPackage @@ -116049,8 +109030,6 @@ self: { ]; description = "A package allowing to write Hakyll blog posts in Rmd"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-agda" = callPackage @@ -116067,8 +109046,6 @@ self: { ]; description = "Wrapper to integrate literate Agda files with Hakyll"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-alectryon" = callPackage @@ -116085,8 +109062,6 @@ self: { ]; description = "Hakyll extension for rendering Coq code using Alectryon"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-blaze-templates" = callPackage @@ -116098,8 +109073,6 @@ self: { libraryHaskellDepends = [ base blaze-html blaze-markup hakyll ]; description = "Blaze templates for Hakyll"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-contrib" = callPackage @@ -116115,8 +109088,6 @@ self: { executableHaskellDepends = [ base directory filepath hakyll ]; description = "Extra modules for the hakyll website compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-contrib-csv" = callPackage @@ -116133,8 +109104,6 @@ self: { testHaskellDepends = [ base blaze-html bytestring cassava hspec ]; description = "Generate Html tables from Csv files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-contrib-elm" = callPackage @@ -116153,8 +109122,6 @@ self: { executableHaskellDepends = [ base hakyll ]; description = "Compile Elm code for inclusion in Hakyll static site"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-contrib-hyphenation" = callPackage @@ -116166,8 +109133,6 @@ self: { libraryHaskellDepends = [ base hakyll hyphenation split tagsoup ]; description = "automatic hyphenation for Hakyll"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-contrib-i18n" = callPackage @@ -116212,8 +109177,6 @@ self: { ]; description = "A hakyll library that helps maintain a separate links database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-convert" = callPackage @@ -116262,8 +109225,6 @@ self: { executableHaskellDepends = [ base dhall hakyll ]; description = "Dhall compiler for Hakyll"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-dir-list" = callPackage @@ -116278,8 +109239,6 @@ self: { ]; description = "Allow Hakyll to create hierarchical menues from directories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-elm" = callPackage @@ -116295,7 +109254,6 @@ self: { description = "Hakyll wrapper for the Elm compiler"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-favicon" = callPackage @@ -116310,8 +109268,6 @@ self: { executableHaskellDepends = [ base hakyll ]; testHaskellDepends = [ base ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-filestore" = callPackage @@ -116326,8 +109282,6 @@ self: { ]; description = "FileStore utilities for Hakyll"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-images" = callPackage @@ -116349,8 +109303,6 @@ self: { ]; description = "Hakyll utilities to work with images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-ogmarkup" = callPackage @@ -116362,8 +109314,6 @@ self: { libraryHaskellDepends = [ base hakyll ogmarkup ]; description = "Integrate ogmarkup document with Hakyll"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-process" = callPackage @@ -116375,8 +109325,6 @@ self: { libraryHaskellDepends = [ base bytestring hakyll typed-process ]; description = "Hakyll compiler for arbitrary external processes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-sass" = callPackage @@ -116392,8 +109340,6 @@ self: { ]; description = "Hakyll SASS compiler over hsass"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-series" = callPackage @@ -116405,8 +109351,6 @@ self: { libraryHaskellDepends = [ base containers hakyll ]; description = "Adds series functionality to hakyll"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-shakespeare" = callPackage @@ -116424,8 +109368,6 @@ self: { ]; description = "Hakyll Hamlet compiler"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-shortcode" = callPackage @@ -116447,8 +109389,6 @@ self: { ]; description = "A shortcode extension module for Hakyll"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-shortcut-links" = callPackage @@ -116465,8 +109405,6 @@ self: { testHaskellDepends = [ base hspec mtl pandoc text ]; description = "Use shortcut-links in markdown file for Hakyll"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hakyll-typescript" = callPackage @@ -116483,8 +109421,6 @@ self: { testHaskellDepends = [ base directory hakyll tasty tasty-hunit ]; description = "Typescript and javascript hakyll compilers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hal" = callPackage @@ -116509,8 +109445,6 @@ self: { ]; description = "A runtime environment for Haskell applications running on AWS Lambda"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "halberd" = callPackage @@ -116539,8 +109473,6 @@ self: { ]; description = "A tool to generate missing import statements for Haskell modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "half" = callPackage @@ -116581,8 +109513,6 @@ self: { ]; description = "The HAskelL File System (\"halfs\" -- intended for use on the HaLVM)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "halipeto" = callPackage @@ -116596,8 +109526,6 @@ self: { libraryHaskellDepends = [ base directory HaXml pandoc ]; description = "Haskell Static Web Page Generator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "halive" = callPackage @@ -116627,8 +109555,6 @@ self: { ]; description = "A live recompiler"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hall-symbols" = callPackage @@ -116645,8 +109571,6 @@ self: { ]; description = "Symmetry operations generater of Hall Symbols"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "halma" = callPackage @@ -116667,8 +109591,6 @@ self: { ]; description = "Library implementing Halma rules"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "halma-gui" = callPackage @@ -116687,8 +109609,6 @@ self: { ]; description = "GTK application for playing Halma"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "halma-telegram-bot" = callPackage @@ -116713,8 +109633,6 @@ self: { ]; description = "Telegram bot for playing Halma"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haltavista" = callPackage @@ -116740,8 +109658,6 @@ self: { testHaskellDepends = [ base hedgehog lens ]; description = "Split or combine data structures to and from halves, quarters, eighths"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "halvm-web" = callPackage @@ -116788,8 +109704,6 @@ self: { ]; testHaskellDepends = [ base bytestring ]; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hamid" = callPackage @@ -116856,8 +109770,6 @@ self: { ]; description = "Haskell macro preprocessor"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hamsql" = callPackage @@ -116881,8 +109793,6 @@ self: { testHaskellDepends = [ base ]; description = "Interpreter for SQL-structure definitions in YAML (YamSql)"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hamtmap" = callPackage @@ -116896,8 +109806,6 @@ self: { libraryHaskellDepends = [ array base deepseq hashable ]; description = "A purely functional and persistent hash map"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hamtsolo" = callPackage @@ -116938,8 +109846,6 @@ self: { executableHaskellDepends = [ filepath ]; description = "Library to handle abstract music"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "han2zen" = callPackage @@ -116965,8 +109871,6 @@ self: { libraryHaskellDepends = [ base containers random ]; description = "Hanabi card game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "handa-data" = callPackage @@ -117007,8 +109911,6 @@ self: { ]; description = "Library and command-line utility for accessing Google services and APIs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "handa-geodata" = callPackage @@ -117055,8 +109957,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "HandleLike class"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "handsy" = callPackage @@ -117077,8 +109977,6 @@ self: { ]; description = "A DSL to describe common shell operations and interpeters for running them locally and remotely"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "handwriting" = callPackage @@ -117137,8 +110035,6 @@ self: { ]; description = "Simple Continuous Integration/Deployment System"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hans" = callPackage @@ -117162,8 +110058,6 @@ self: { ]; description = "Network Stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hans-pcap" = callPackage @@ -117175,8 +110069,6 @@ self: { libraryHaskellDepends = [ base bytestring hans pcap ]; description = "Driver for real ethernet devices for HaNS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hans-pfq" = callPackage @@ -117221,8 +110113,6 @@ self: { ]; description = "Korean spell checker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haphviz" = callPackage @@ -117241,8 +110131,6 @@ self: { ]; description = "Graphviz code generation with Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hapistrano" = callPackage @@ -117291,8 +110179,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the appindicator library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libappindicator-gtk2;}; "happindicator3" = callPackage @@ -117307,8 +110193,6 @@ self: { libraryPkgconfigDepends = [ libappindicator-gtk3 ]; description = "Binding to the appindicator library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libappindicator-gtk3;}; "happlets" = callPackage @@ -117326,8 +110210,6 @@ self: { ]; description = "\"Haskell Applets\" provides an event handler and a canvas for building simple GUI apps"; license = "AGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happlets-lib-gtk" = callPackage @@ -117349,8 +110231,6 @@ self: { ]; description = "The \"Haskell Applets\" Gtk+ ver. 2 back-end for \"happlets\"."; license = "AGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happraise" = callPackage @@ -117364,8 +110244,6 @@ self: { executableHaskellDepends = [ base directory filepath ]; description = "A small program for counting the comments in haskell source"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happs-hsp" = callPackage @@ -117379,8 +110257,6 @@ self: { base bytestring HAppS-Server hsp mtl plugins ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happs-hsp-template" = callPackage @@ -117397,8 +110273,6 @@ self: { ]; description = "Utilities for using HSP templates in HAppS applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happs-tutorial" = callPackage @@ -117423,8 +110297,6 @@ self: { ]; description = "A Happstack Tutorial that is its own web 2.0-type demo."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack" = callPackage @@ -117439,8 +110311,6 @@ self: { doHaddock = false; description = "The haskell application server stack + code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-auth" = callPackage @@ -117459,8 +110329,6 @@ self: { ]; description = "A Happstack Authentication Suite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-authenticate" = callPackage @@ -117490,8 +110358,6 @@ self: { ]; description = "Happstack Authentication Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-clientsession" = callPackage @@ -117528,8 +110394,6 @@ self: { ]; description = "Web related tools and services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-data" = callPackage @@ -117551,8 +110415,6 @@ self: { ]; description = "Happstack data manipulation libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-dlg" = callPackage @@ -117570,8 +110432,6 @@ self: { ]; description = "Cross-request user interactions for Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-facebook" = callPackage @@ -117597,8 +110457,6 @@ self: { ]; description = "A package for building Facebook applications using Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-fastcgi" = callPackage @@ -117630,8 +110488,6 @@ self: { ]; description = "Support for using Fay with Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-fay-ajax" = callPackage @@ -117644,8 +110500,6 @@ self: { libraryHaskellDepends = [ fay-base fay-jquery ]; description = "Support for using Fay with Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-foundation" = callPackage @@ -117666,8 +110520,6 @@ self: { ]; description = "Glue code for using Happstack with acid-state, web-routes, reform, and HSP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-hamlet" = callPackage @@ -117679,8 +110531,6 @@ self: { libraryHaskellDepends = [ base happstack-server shakespeare text ]; description = "Support for Hamlet HTML templates in Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-heist" = callPackage @@ -117697,8 +110547,6 @@ self: { ]; description = "Support for using Heist templates in Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-helpers" = callPackage @@ -117722,8 +110570,6 @@ self: { ]; description = "Convenience functions for Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-hsp" = callPackage @@ -117755,8 +110601,6 @@ self: { ]; description = "Support for using HStringTemplate in Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-ixset" = callPackage @@ -117775,8 +110619,6 @@ self: { ]; description = "Efficient relational queries on Haskell sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-jmacro" = callPackage @@ -117794,8 +110636,6 @@ self: { ]; description = "Support for using JMacro with Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-lite" = callPackage @@ -117809,8 +110649,6 @@ self: { ]; description = "Happstack minus the useless stuff"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-monad-peel" = callPackage @@ -117826,8 +110664,6 @@ self: { ]; description = "monad-peel instances for Happstack types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-plugins" = callPackage @@ -117843,8 +110679,6 @@ self: { ]; description = "The haskell application server stack + reload"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-server" = callPackage @@ -117908,8 +110742,6 @@ self: { ]; description = "Extend happstack-server with native HTTPS support (TLS/SSL)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-state" = callPackage @@ -117930,8 +110762,6 @@ self: { ]; description = "Event-based distributed state"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-static-routing" = callPackage @@ -117970,8 +110800,6 @@ self: { ]; description = "Web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happstack-yui" = callPackage @@ -117993,8 +110821,6 @@ self: { ]; description = "Utilities for using YUI3 with Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happy_1_19_9" = callPackage @@ -118059,8 +110885,6 @@ self: { libraryHaskellDepends = [ base Chart Chart-diagrams ]; description = "Generate simple okay-looking bar plots without much effort"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happy-meta" = callPackage @@ -118095,8 +110919,6 @@ self: { ]; description = "Acceptance test framework for web applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happybara-webkit" = callPackage @@ -118116,8 +110938,6 @@ self: { ]; description = "WebKit Happybara driver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "happybara-webkit-server" = callPackage @@ -118129,8 +110949,6 @@ self: { libraryHaskellDepends = [ base directory filepath process ]; description = "WebKit Server binary for Happybara (taken from capybara-webkit)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hapstone" = callPackage @@ -118149,8 +110967,6 @@ self: { ]; description = "Capstone bindings for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) capstone;}; "haquery" = callPackage @@ -118166,8 +110982,6 @@ self: { ]; description = "jQuery for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haquil" = callPackage @@ -118189,8 +111003,6 @@ self: { ]; description = "A Haskell implementation of the Quil instruction set for quantum computing"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "har" = callPackage @@ -118223,8 +111035,6 @@ self: { executableSystemDepends = [ openssl sqlite ]; description = "Networked content addressed backup and restore software"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl; inherit (pkgs) sqlite;}; "hardware-edsl" = callPackage @@ -118242,8 +111052,6 @@ self: { ]; description = "Deep embedding of hardware descriptions with code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "harg" = callPackage @@ -118261,8 +111069,6 @@ self: { testHaskellDepends = [ base ]; description = "Haskell program configuration using higher kinded data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hark" = callPackage @@ -118281,8 +111087,6 @@ self: { ]; description = "A Gentoo package query tool"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "harmony" = callPackage @@ -118308,8 +111112,6 @@ self: { ]; description = "A web service specification compiler that generates implementation and tests"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haroonga" = callPackage @@ -118326,8 +111128,6 @@ self: { libraryPkgconfigDepends = [ groonga ]; description = "Low level bindings for Groonga"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) groonga;}; "haroonga-httpd" = callPackage @@ -118346,8 +111146,6 @@ self: { ]; description = "Yet another Groonga http server"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "harp" = callPackage @@ -118375,8 +111173,6 @@ self: { ]; description = "Runtime code generation for x86 machine code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "harvest-api" = callPackage @@ -118397,8 +111193,6 @@ self: { ]; description = "Bindings for Harvest API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "has" = callPackage @@ -118412,8 +111206,6 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Entity based records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "has-th" = callPackage @@ -118425,8 +111217,6 @@ self: { libraryHaskellDepends = [ base has template-haskell ]; description = "Template Haskell function for Has records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasbolt" = callPackage @@ -118447,8 +111237,6 @@ self: { ]; description = "Haskell driver for Neo4j 3+ (BOLT protocol)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasbolt-extras" = callPackage @@ -118474,8 +111262,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Extras for hasbolt library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hascal" = callPackage @@ -118552,8 +111338,6 @@ self: { ]; description = "A TUI for reviewing notes using 'flashcards' written with markdown-like syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hascas" = callPackage @@ -118575,8 +111359,6 @@ self: { ]; description = "Cassandra driver for haskell"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hascat" = callPackage @@ -118671,8 +111453,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Hashing tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hash-store" = callPackage @@ -118786,8 +111566,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Higher-rank Hashable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hashable-generics" = callPackage @@ -118806,8 +111584,6 @@ self: { benchmarkHaskellDepends = [ base criterion ghc-prim hashable ]; description = "Automatically generates Hashable instances with GHC.Generics."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hashable-orphans" = callPackage @@ -118821,8 +111597,6 @@ self: { libraryHaskellDepends = [ base hashable sorted-list time ]; description = "Provides instances missing from Hashable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hashable-time" = callPackage @@ -118852,8 +111626,6 @@ self: { ]; description = "Principled, portable & extensible hashing of data and types, including an implementation of the FNV-1a and SipHash algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hashed-storage" = callPackage @@ -118872,8 +111644,6 @@ self: { ]; description = "Hashed file storage support code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hashflare" = callPackage @@ -118887,8 +111657,6 @@ self: { libraryHaskellDepends = [ base containers simple-money ]; description = "A library for working with HashFlare.io contracts and hashrates"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hashids" = callPackage @@ -118989,8 +111757,6 @@ self: { ]; description = "Efficient consistent hashing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hashtable-benchmark" = callPackage @@ -119051,8 +111817,6 @@ self: { ]; description = "Extensions for a \"hashtables\" library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasim" = callPackage @@ -119064,8 +111828,6 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Process-Based Discrete Event Simulation library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hask" = callPackage @@ -119083,8 +111845,6 @@ self: { ]; description = "Categories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hask-home" = callPackage @@ -119103,8 +111863,6 @@ self: { ]; description = "Generate homepages for cabal packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskades" = callPackage @@ -119184,8 +111942,6 @@ self: { ]; description = "A dialect of haskell with order of execution based on dependency resolution"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskbot-core" = callPackage @@ -119206,8 +111962,6 @@ self: { ]; description = "Easily-extensible chatbot for Slack messaging service"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskdeep" = callPackage @@ -119232,8 +111986,6 @@ self: { ]; description = "Computes and audits file hashes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskdogs" = callPackage @@ -119270,8 +112022,6 @@ self: { ]; description = "A small scheme interpreter"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskeline_0_8_1_2" = callPackage @@ -119308,8 +112058,6 @@ self: { libraryHaskellDepends = [ base haskeline mtl ]; description = "Class interface for working with Haskeline"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskeline-repl" = callPackage @@ -119333,8 +112081,6 @@ self: { libraryHaskellDepends = [ base containers mtl protolude text ]; description = "Write Emacs module in Haskell, using Emacs 25's Dynamic Module feature"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-abci" = callPackage @@ -119360,8 +112106,6 @@ self: { ]; description = "Haskell Application BlockChain Interface (ABCI) Server Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-aliyun" = callPackage @@ -119384,8 +112128,6 @@ self: { ]; description = "haskell client of aliyun service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-awk" = callPackage @@ -119421,8 +112163,6 @@ self: { ]; description = "Transform text from the command-line using Haskell expressions"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-bcrypt" = callPackage @@ -119461,8 +112201,6 @@ self: { ]; description = "Complete BitMEX Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-bitmex-rest" = callPackage @@ -119490,8 +112228,6 @@ self: { ]; description = "Auto-generated bitmex API Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-brainfuck" = callPackage @@ -119511,8 +112247,6 @@ self: { ]; description = "BrainFuck interpreter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-ci" = callPackage @@ -119547,8 +112281,6 @@ self: { doHaddock = false; description = "Cabal package script generator for Travis-CI"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-cnc" = callPackage @@ -119569,8 +112301,6 @@ self: { executableHaskellDepends = [ base directory process ]; description = "Library for parallel programming in the Intel Concurrent Collections paradigm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-coffee" = callPackage @@ -119582,8 +112312,6 @@ self: { libraryHaskellDepends = [ base process ]; description = "Simple CoffeeScript API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-compression" = callPackage @@ -119603,8 +112331,6 @@ self: { ]; description = "compress files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-conll" = callPackage @@ -119620,8 +112346,6 @@ self: { ]; description = "Core Types for NLP"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-course-preludes" = callPackage @@ -119633,8 +112357,6 @@ self: { libraryHaskellDepends = [ base deepseq ]; description = "Small modules for a Haskell course in which Haskell is taught by implementing Prelude functionality"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-dap" = callPackage @@ -119681,8 +112403,6 @@ self: { ]; description = "Haskell Debug Adapter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-disque" = callPackage @@ -119699,8 +112419,6 @@ self: { testHaskellDepends = [ base ]; description = "Client library for the Disque datastore"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-docs" = callPackage @@ -119723,8 +112441,6 @@ self: { testHaskellDepends = [ base ]; description = "A program to find and display the docs and type of a name"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-eigen-util" = callPackage @@ -119737,8 +112453,6 @@ self: { testHaskellDepends = [ base eigen vector ]; description = "Some utility functions for haskell-eigen library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-exp-parser" = callPackage @@ -119791,8 +112505,6 @@ self: { ]; description = "Haskell source code formatter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-ftp" = callPackage @@ -119819,8 +112531,6 @@ self: { ]; description = "A Haskell ftp server with configurable backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-generate" = callPackage @@ -119837,8 +112547,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Typesafe generation of haskell source code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-gettext" = callPackage @@ -119954,8 +112662,6 @@ self: { executableHaskellDepends = [ base containers gloss ]; description = "Go and Checkers game in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-google-trends" = callPackage @@ -119986,8 +112692,6 @@ self: { testHaskellDepends = [ base template-haskell transformers ]; description = "Infer haskell code by given type"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-igraph" = callPackage @@ -120010,8 +112714,6 @@ self: { ]; description = "Bindings to the igraph C library (v0.8.0)."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-import-graph" = callPackage @@ -120043,8 +112745,6 @@ self: { executableHaskellDepends = [ base HGL random ]; description = "'Asteroids' arcade games"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-kubernetes" = callPackage @@ -120064,8 +112764,6 @@ self: { ]; description = "Haskell bindings to the Kubernetes API (via swagger-codegen)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-language-server" = callPackage @@ -120207,8 +112905,6 @@ self: { ]; description = "A haskell package to build your own Language Server client"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-lsp-types" = callPackage @@ -120274,8 +112970,6 @@ self: { testHaskellDepends = [ base MonadRandom ]; description = "Machine learning in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-modbus" = callPackage @@ -120299,8 +112993,6 @@ self: { libraryHaskellDepends = [ base ghc-prim integer-gmp ]; description = "Correctly-rounded arbitrary-precision floating-point arithmetic"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-mpi" = callPackage @@ -120320,8 +113012,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Distributed parallel programming in Haskell using MPI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {open-pal = null; open-rte = null; openmpi = null;}; "haskell-names" = callPackage @@ -120345,8 +113035,6 @@ self: { ]; description = "Name resolution library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-neo4j-client" = callPackage @@ -120378,8 +113066,6 @@ self: { ]; description = "A Haskell neo4j client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-openflow" = callPackage @@ -120394,8 +113080,6 @@ self: { testHaskellDepends = [ base ]; description = "OpenFlow protocol in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-overridez" = callPackage @@ -120417,8 +113101,6 @@ self: { ]; description = "Manage nix overrides for haskell packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-packages" = callPackage @@ -120437,8 +113119,6 @@ self: { ]; description = "Haskell suite library for package management and integration with Cabal"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-pdf-presenter" = callPackage @@ -120458,8 +113138,6 @@ self: { ]; description = "Tool for presenting PDF-based presentations"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-platform-test" = callPackage @@ -120488,8 +113166,6 @@ self: { executableToolDepends = [ alex happy ]; description = "A test system for the Haskell Platform environment"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-player" = callPackage @@ -120511,8 +113187,6 @@ self: { testHaskellDepends = [ base ]; description = "A terminal music player based on afplay"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-plot" = callPackage @@ -120529,8 +113203,6 @@ self: { ]; description = "A library for generating 2D plots painlessly"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-postal" = callPackage @@ -120546,8 +113218,6 @@ self: { testPkgconfigDepends = [ libpostal ]; description = "Haskell binding for the libpostal library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libpostal;}; "haskell-postgis" = callPackage @@ -120613,8 +113283,6 @@ self: { testHaskellDepends = [ base directory hspec process ]; description = "Opens a temporary file on the system's EDITOR and returns the resulting edits"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-reflect" = callPackage @@ -120631,8 +113299,6 @@ self: { ]; description = "Reflect Haskell types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-rules" = callPackage @@ -120644,8 +113310,6 @@ self: { libraryHaskellDepends = [ base syb ]; description = "A DSL for expressing natural deduction rules in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-say" = callPackage @@ -120699,8 +113363,6 @@ self: { ]; description = "Client API for Rocket Scissor Spacegoo"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-src" = callPackage @@ -120748,8 +113410,6 @@ self: { libraryHaskellDepends = [ base haskell-src-exts Hoed ]; description = "Observable orphan instances for haskell-src-exts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-src-exts-prisms" = callPackage @@ -120763,8 +113423,6 @@ self: { ]; description = "Prisms with newtype wrappers for haskell-src-exts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-src-exts-qq" = callPackage @@ -120781,8 +113439,6 @@ self: { testHaskellDepends = [ base haskell-src-exts hspec ]; description = "A quasiquoter for haskell-src-exts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-src-exts-sc" = callPackage @@ -120796,8 +113452,6 @@ self: { libraryHaskellDepends = [ base haskell-src-exts ]; description = "Pretty print haskell code with comments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-src-exts-simple" = callPackage @@ -120845,8 +113499,6 @@ self: { ]; description = "Testing code generators piece by piece"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-src-meta" = callPackage @@ -120882,8 +113534,6 @@ self: { ]; description = "Parse source to template-haskell abstract syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-stack-trace-plugin" = callPackage @@ -120902,8 +113552,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "haskell-stack-trace-plugin"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-time-range" = callPackage @@ -120961,8 +113609,6 @@ self: { ]; description = "Utilities to tie up tokens to an AST"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-ast" = callPackage @@ -120979,8 +113625,6 @@ self: { ]; description = "Haskell AST for efficient tooling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-ast-fromghc" = callPackage @@ -120998,8 +113642,6 @@ self: { ]; description = "Creating the Haskell-Tools AST from GHC's representations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-ast-gen" = callPackage @@ -121016,8 +113658,6 @@ self: { ]; description = "Facilities for generating new parts of the Haskell-Tools AST"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-ast-trf" = callPackage @@ -121033,8 +113673,6 @@ self: { ]; description = "Conversions on Haskell-Tools AST to prepare for refactorings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-backend-ghc" = callPackage @@ -121052,8 +113690,6 @@ self: { ]; description = "Creating the Haskell-Tools AST from GHC's representations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-builtin-refactorings" = callPackage @@ -121085,8 +113721,6 @@ self: { ]; description = "Refactoring Tool for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-cli" = callPackage @@ -121122,8 +113756,6 @@ self: { ]; description = "Command-line frontend for Haskell-tools Refact"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-daemon" = callPackage @@ -121157,8 +113789,6 @@ self: { ]; description = "Background process for Haskell-tools that editors can connect to"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-debug" = callPackage @@ -121183,8 +113813,6 @@ self: { executableHaskellDepends = [ base ]; description = "Debugging Tools for Haskell-tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-demo" = callPackage @@ -121215,8 +113843,6 @@ self: { ]; description = "A web-based demo for Haskell-tools Refactor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-experimental-refactorings" = callPackage @@ -121247,8 +113873,6 @@ self: { ]; description = "Refactoring Tool for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-prettyprint" = callPackage @@ -121265,8 +113889,6 @@ self: { ]; description = "Pretty printing of Haskell-Tools AST"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-refactor" = callPackage @@ -121296,8 +113918,6 @@ self: { ]; description = "Refactoring Tool for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tools-rewrite" = callPackage @@ -121319,8 +113939,6 @@ self: { ]; description = "Facilities for generating new parts of the Haskell-Tools AST"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tor" = callPackage @@ -121354,8 +113972,6 @@ self: { ]; description = "A Haskell Tor Node"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-type-exts" = callPackage @@ -121369,8 +113985,6 @@ self: { ]; description = "A type checker for Haskell/haskell-src-exts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-typescript" = callPackage @@ -121382,8 +113996,6 @@ self: { libraryHaskellDepends = [ base process ]; description = "Simple TypeScript API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-tyrant" = callPackage @@ -121395,8 +114007,6 @@ self: { libraryHaskellDepends = [ base binary bytestring network ]; description = "Haskell implementation of the Tokyo Tyrant binary protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell-updater" = callPackage @@ -121450,8 +114060,6 @@ self: { libraryHaskellDepends = [ array base ghc-prim ]; description = "Compatibility with Haskell 2010"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell2020" = callPackage @@ -121463,8 +114071,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Haskell 2020[draft] Standard Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell98" = callPackage @@ -121480,8 +114086,6 @@ self: { ]; description = "Compatibility with Haskell 98"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskell98libraries" = callPackage @@ -121497,8 +114101,6 @@ self: { ]; description = "Compatibility with Haskell 98"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb" = callPackage @@ -121514,8 +114116,6 @@ self: { ]; description = "A library of combinators for generating and executing SQL statements"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-connect-hdbc" = callPackage @@ -121527,8 +114127,6 @@ self: { libraryHaskellDepends = [ base containers haskelldb HDBC ]; description = "Bracketed HDBC session for HaskellDB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-connect-hdbc-catchio-mtl" = callPackage @@ -121544,8 +114142,6 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using MonadCatchIO-mtl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-connect-hdbc-catchio-tf" = callPackage @@ -121562,8 +114158,6 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using MonadCatchIO-transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-connect-hdbc-catchio-transformers" = callPackage @@ -121580,8 +114174,6 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using MonadCatchIO-transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-connect-hdbc-lifted" = callPackage @@ -121598,8 +114190,6 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using lifted-base"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-dynamic" = callPackage @@ -121614,8 +114204,6 @@ self: { executableHaskellDepends = [ haskelldb ]; description = "HaskellDB support for the dynamically loaded drivers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-flat" = callPackage @@ -121633,8 +114221,6 @@ self: { ]; description = "An experimental HaskellDB back-end in pure Haskell (no SQL)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hdbc" = callPackage @@ -121650,8 +114236,6 @@ self: { ]; description = "HaskellDB support for HDBC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hdbc-mysql" = callPackage @@ -121669,8 +114253,6 @@ self: { ]; description = "HaskellDB support for the HDBC MySQL driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hdbc-odbc" = callPackage @@ -121688,8 +114270,6 @@ self: { ]; description = "HaskellDB support for the HDBC ODBC driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hdbc-postgresql" = callPackage @@ -121708,8 +114288,6 @@ self: { executableSystemDepends = [ postgresql ]; description = "HaskellDB support for the HDBC PostgreSQL driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) postgresql;}; "haskelldb-hdbc-sqlite3" = callPackage @@ -121727,8 +114305,6 @@ self: { ]; description = "HaskellDB support for the HDBC SQLite driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hsql" = callPackage @@ -121740,8 +114316,6 @@ self: { libraryHaskellDepends = [ base haskelldb hsql mtl old-time ]; description = "HaskellDB support for HSQL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hsql-mysql" = callPackage @@ -121759,8 +114333,6 @@ self: { ]; description = "HaskellDB support for the HSQL MySQL driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hsql-odbc" = callPackage @@ -121778,8 +114350,6 @@ self: { ]; description = "HaskellDB support for the HSQL ODBC driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hsql-oracle" = callPackage @@ -121816,8 +114386,6 @@ self: { ]; description = "HaskellDB support for the HSQL PostgreSQL driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-hsql-sqlite" = callPackage @@ -121854,8 +114422,6 @@ self: { ]; description = "HaskellDB support for the HSQL SQLite3 driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-th" = callPackage @@ -121867,8 +114433,6 @@ self: { libraryHaskellDepends = [ base haskelldb mtl template-haskell ]; description = "Template Haskell utilities for HaskellDB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelldb-wx" = callPackage @@ -121879,8 +114443,6 @@ self: { sha256 = "01652m0bym80400navqlpdv5n0gfgnfzd1d0857f3kd13ksqk2hy"; description = "HaskellDB support for WXHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskellish" = callPackage @@ -121896,8 +114458,6 @@ self: { ]; description = "For parsing Haskell-ish languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskellscrabble" = callPackage @@ -121921,8 +114481,6 @@ self: { ]; description = "A scrabble library capturing the core game logic of scrabble"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskellscript" = callPackage @@ -121940,8 +114498,6 @@ self: { ]; description = "Command line tool for running Haskell scripts with a hashbang"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelm" = callPackage @@ -121975,7 +114531,6 @@ self: { description = "Elm to Haskell translation"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskelzinc" = callPackage @@ -121992,8 +114547,6 @@ self: { ]; description = "CP in Haskell through MiniZinc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskeme" = callPackage @@ -122008,8 +114561,6 @@ self: { executableHaskellDepends = [ base ]; description = "Compiler from I- to S-Expressions for the Scheme Programming Language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskey" = callPackage @@ -122037,8 +114588,6 @@ self: { ]; description = "A transactional, ACID compliant, embeddable key-value store"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskey-btree" = callPackage @@ -122082,8 +114631,6 @@ self: { ]; description = "A monad transformer supporting Haskey transactions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskgame" = callPackage @@ -122095,8 +114642,6 @@ self: { libraryHaskellDepends = [ base containers haskell98 SDL SDL-ttf ]; description = "Haskell game library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskheap" = callPackage @@ -122113,8 +114658,6 @@ self: { ]; description = "Haskell bindings to refheap"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskhol-core" = callPackage @@ -122134,8 +114677,6 @@ self: { ]; description = "The core logical system of HaskHOL, an EDSL for HOL theorem proving"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskintex" = callPackage @@ -122172,8 +114713,6 @@ self: { ]; description = "A haskell wrapper for PokeAPI.co (www.pokeapi.co)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin" = callPackage @@ -122199,8 +114738,6 @@ self: { ]; description = "Implementation of the Bitcoin protocol"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-bitcoind" = callPackage @@ -122218,8 +114755,6 @@ self: { ]; description = "An adapter for haskoin to network-bitcoin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-core" = callPackage @@ -122251,8 +114786,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bitcoin & Bitcoin Cash library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-crypto" = callPackage @@ -122275,8 +114808,6 @@ self: { ]; description = "Implementation of Bitcoin cryptographic primitives"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-node" = callPackage @@ -122308,8 +114839,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "P2P library for Bitcoin and Bitcoin Cash"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-protocol" = callPackage @@ -122332,8 +114861,6 @@ self: { ]; description = "Implementation of the Bitcoin network protocol messages"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-script" = callPackage @@ -122358,8 +114885,6 @@ self: { ]; description = "Implementation of Bitcoin script parsing and evaluation"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-store" = callPackage @@ -122409,8 +114934,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Storage and index for Bitcoin and Bitcoin Cash"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-store-data" = callPackage @@ -122439,8 +114962,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Data for Haskoin Store"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-util" = callPackage @@ -122463,8 +114984,6 @@ self: { ]; description = "Utility functions for the Network.Haskoin project"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoin-wallet" = callPackage @@ -122507,8 +115026,6 @@ self: { ]; description = "Implementation of a Bitcoin SPV Wallet with BIP32 and multisig support"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoon" = callPackage @@ -122526,8 +115043,6 @@ self: { ]; description = "Web Application Abstraction"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoon-httpspec" = callPackage @@ -122543,8 +115058,6 @@ self: { ]; description = "Integrating HttpSpec with Haskoon"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskoon-salvia" = callPackage @@ -122562,8 +115075,6 @@ self: { ]; description = "Integrating HttpSpec with Haskoon"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskore" = callPackage @@ -122588,8 +115099,6 @@ self: { ]; description = "The Haskore Computer Music System"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskore-realtime" = callPackage @@ -122607,8 +115116,6 @@ self: { ]; description = "Routines for realtime playback of Haskore songs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskore-supercollider" = callPackage @@ -122630,8 +115137,6 @@ self: { ]; description = "Haskore back-end for SuperCollider"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskore-synthesizer" = callPackage @@ -122651,8 +115156,6 @@ self: { ]; description = "Music rendering coded in Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskore-vintage" = callPackage @@ -122746,8 +115249,6 @@ self: { doHaddock = false; description = "Torch for tensors and neural networks in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasktorch-codegen" = callPackage @@ -122777,8 +115278,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Code generation tools for Hasktorch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasktorch-ffi-tests" = callPackage @@ -122813,8 +115312,6 @@ self: { ]; description = "Bindings to Torch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ATen = null;}; "hasktorch-ffi-thc" = callPackage @@ -122837,8 +115334,6 @@ self: { ]; description = "Bindings to Cutorch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ATen = null;}; "hasktorch-indef" = callPackage @@ -122867,8 +115362,6 @@ self: { doHaddock = false; description = "Core Hasktorch abstractions wrapping FFI bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasktorch-signatures" = callPackage @@ -122894,8 +115387,6 @@ self: { doHaddock = false; description = "Backpack signatures for Tensor operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasktorch-signatures-partial" = callPackage @@ -122911,8 +115402,6 @@ self: { ]; description = "Functions to partially satisfy tensor signatures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasktorch-signatures-support" = callPackage @@ -122929,8 +115418,6 @@ self: { doHaddock = false; description = "Signatures for support tensors in hasktorch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasktorch-signatures-types" = callPackage @@ -122991,8 +115478,6 @@ self: { ]; description = "Neural architectures in hasktorch"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-binary" = callPackage @@ -123017,8 +115502,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Haskus binary format manipulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-system-build" = callPackage @@ -123038,8 +115521,6 @@ self: { ]; description = "Haskus system build tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-utils" = callPackage @@ -123062,8 +115543,6 @@ self: { ]; description = "Haskus utility modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-utils-compat" = callPackage @@ -123080,8 +115559,6 @@ self: { ]; description = "Compatibility modules with other external packages (ByteString, etc.)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-utils-data" = callPackage @@ -123099,8 +115576,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Haskus data utility modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-utils-types" = callPackage @@ -123113,8 +115588,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Haskus types utility modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-utils-variant" = callPackage @@ -123137,8 +115610,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq QuickCheck ]; description = "Variant and EADT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskus-web" = callPackage @@ -123155,8 +115626,6 @@ self: { ]; description = "Haskus web"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haskyapi" = callPackage @@ -123188,8 +115657,6 @@ self: { ]; description = "HTTP server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haslo" = callPackage @@ -123204,8 +115671,6 @@ self: { executableHaskellDepends = [ mtl old-time QuickCheck time wtk ]; description = "Loan calculator engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasloGUI" = callPackage @@ -123224,8 +115689,6 @@ self: { ]; description = "Loan calculator Gtk GUI. Based on haslo (Haskell Loan) library."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasmin" = callPackage @@ -123256,8 +115719,6 @@ self: { benchmarkHaskellDepends = [ base criterion directory text ]; description = "CSS Minifier"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasparql-client" = callPackage @@ -123269,8 +115730,6 @@ self: { libraryHaskellDepends = [ base HTTP monads-fd network xml ]; description = "This package enables to write SPARQL queries to remote endpoints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haspell" = callPackage @@ -123325,8 +115784,6 @@ self: { ]; description = "API for backends of \"hasql\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-class" = callPackage @@ -123349,8 +115806,6 @@ self: { ]; description = "Encodable and Decodable classes for hasql"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-cursor-query" = callPackage @@ -123373,8 +115828,6 @@ self: { ]; description = "A declarative abstraction over PostgreSQL Cursor"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-cursor-transaction" = callPackage @@ -123392,8 +115845,6 @@ self: { ]; description = "An abstraction for simultaneous fetching from multiple PostgreSQL cursors"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-dynamic-statements" = callPackage @@ -123414,8 +115865,6 @@ self: { ]; description = "Toolkit for constructing Hasql statements dynamically"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-generic" = callPackage @@ -123434,8 +115883,6 @@ self: { ]; description = "Generic encoder and decoder deriving for Hasql"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-implicits" = callPackage @@ -123569,8 +116016,6 @@ self: { ]; description = "A \"PostgreSQL\" backend for the \"hasql\" library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-postgres-options" = callPackage @@ -123585,8 +116030,6 @@ self: { ]; description = "An \"optparse-applicative\" parser for \"hasql-postgres\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-queue" = callPackage @@ -123621,8 +116064,6 @@ self: { ]; description = "A PostgreSQL backed queue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-simple" = callPackage @@ -123639,8 +116080,6 @@ self: { ]; description = "A somewhat opinionated \"simpler\" API to hasql"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-th" = callPackage @@ -123659,8 +116098,6 @@ self: { ]; description = "Template Haskell utilities for Hasql"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasql-transaction" = callPackage @@ -123695,8 +116132,6 @@ self: { testHaskellDepends = [ base hasql tasty tasty-quickcheck ]; description = "Parse PostgreSQL connection URI into Hasql.Connection Settings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hasqly-mysql" = callPackage @@ -123740,8 +116175,6 @@ self: { ]; description = "Haskell implementation of Mustache templates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hastache-aeson" = callPackage @@ -123758,8 +116191,6 @@ self: { ]; description = "render hastache templates using aeson values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haste" = callPackage @@ -123773,8 +116204,6 @@ self: { executableHaskellDepends = [ base curl filepath mtl ]; description = "A universal pastebin tool, written in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haste-app" = callPackage @@ -123794,8 +116223,6 @@ self: { ]; description = "Framework for type-safe, distributed web applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haste-compiler" = callPackage @@ -123858,8 +116285,6 @@ self: { ]; description = "Base libraries for haste-compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haste-markup" = callPackage @@ -123874,8 +116299,6 @@ self: { ]; description = "A port of blaze-markup and blaze-html to Haste"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haste-perch" = callPackage @@ -123899,8 +116322,6 @@ self: { libraryHaskellDepends = [ base ghc-prim integer-gmp ]; description = "Low level primitives for the Haste compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hastily" = callPackage @@ -123983,8 +116404,6 @@ self: { ]; description = "HaTeX User's Guide"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hatexmpp3" = callPackage @@ -124058,8 +116477,6 @@ self: { ]; description = "Haskell client for the NATS messaging system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hatt" = callPackage @@ -124082,8 +116499,6 @@ self: { ]; description = "A truth table generator for classical propositional logic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haveibeenpwned" = callPackage @@ -124125,8 +116540,6 @@ self: { ]; description = "Recursively retrieve maven dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haverer" = callPackage @@ -124151,8 +116564,6 @@ self: { ]; description = "Implementation of the rules of Love Letter"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hawitter" = callPackage @@ -124174,8 +116585,6 @@ self: { ]; description = "A twitter client for GTK+. Beta version."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hax" = callPackage @@ -124201,8 +116610,6 @@ self: { ]; description = "Haskell cash-flow and tax simulation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haxl" = callPackage @@ -124245,8 +116652,6 @@ self: { ]; description = "Haxl data source for accessing AWS services through amazonka"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haxl-facebook" = callPackage @@ -124269,8 +116674,6 @@ self: { ]; description = "An example Haxl data source for accessing the Facebook Graph API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haxparse" = callPackage @@ -124295,8 +116698,6 @@ self: { ]; description = "Readable HaxBall replays"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haxr" = callPackage @@ -124328,8 +116729,6 @@ self: { libraryHaskellDepends = [ base haxr template-haskell ]; description = "Automatic deriving of XML-RPC structs for Haskell records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "haxy" = callPackage @@ -124346,8 +116745,6 @@ self: { ]; description = "A simple HTTP proxy server library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hayland" = callPackage @@ -124368,8 +116765,6 @@ self: { testHaskellDepends = [ base process xml ]; description = "Haskell bindings for the C Wayland library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libGL; inherit (pkgs) wayland;}; "hayoo-cli" = callPackage @@ -124388,8 +116783,6 @@ self: { ]; description = "Hayoo CLI"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hback" = callPackage @@ -124408,8 +116801,6 @@ self: { ]; description = "N-back memory game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hbayes" = callPackage @@ -124439,8 +116830,6 @@ self: { ]; description = "Bayesian Networks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hbb" = callPackage @@ -124457,8 +116846,6 @@ self: { ]; description = "Haskell Busy Bee, a backend for text editors"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hbcd" = callPackage @@ -124470,8 +116857,6 @@ self: { libraryHaskellDepends = [ base bytestring Decimal digits split ]; description = "Packed binary-coded decimal (BCD) serialization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hbeanstalk" = callPackage @@ -124487,8 +116872,6 @@ self: { ]; description = "Client for the beanstalkd workqueue service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hbeat" = callPackage @@ -124507,8 +116890,6 @@ self: { executableSystemDepends = [ SDL_mixer ]; description = "A simple step sequencer GUI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) SDL_mixer;}; "hbf" = callPackage @@ -124545,8 +116926,6 @@ self: { ]; description = "An optimizing Brainfuck compiler and evaluator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hblas" = callPackage @@ -124564,8 +116943,6 @@ self: { testHaskellDepends = [ base hspec primitive vector ]; description = "Human friendly BLAS and Lapack bindings for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) blas; liblapack = null;}; "hblock" = callPackage @@ -124585,8 +116962,6 @@ self: { ]; description = "A mutable vector that provides indexation on the datatype fields it stores"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hbro" = callPackage @@ -124674,8 +117049,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Haskell Bottom Up Rewrite Generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcad" = callPackage @@ -124687,8 +117060,6 @@ self: { libraryHaskellDepends = [ base containers gasp mtl ]; description = "Haskell CAD library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcc" = callPackage @@ -124702,8 +117073,6 @@ self: { executableHaskellDepends = [ base bytestring language-c ]; description = "A toy C compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcg-minus" = callPackage @@ -124716,8 +117085,6 @@ self: { libraryHaskellDepends = [ base colour random ]; description = "haskell cg (minus)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcg-minus-cairo" = callPackage @@ -124733,8 +117100,6 @@ self: { ]; description = "haskell cg (minus) (cairo rendering)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcheat" = callPackage @@ -124747,8 +117112,6 @@ self: { libraryHaskellDepends = [ base mps ]; description = "A collection of code cheatsheet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcheckers" = callPackage @@ -124782,8 +117145,6 @@ self: { ]; description = "Implementation of checkers (\"draughts\") board game - server application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hchesslib" = callPackage @@ -124800,8 +117161,6 @@ self: { ]; description = "Chess library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcltest" = callPackage @@ -124822,8 +117181,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "A testing library for command line applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcoap" = callPackage @@ -124846,8 +117203,6 @@ self: { ]; description = "CoAP implementation for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcobs" = callPackage @@ -124882,8 +117237,6 @@ self: { doHaddock = false; description = "Haskell COM support library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcoord" = callPackage @@ -124921,8 +117274,6 @@ self: { ]; description = "Haskell name counts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcron" = callPackage @@ -124939,8 +117290,6 @@ self: { ]; description = "A simple job scheduler, which just runs some IO action at a given time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcube" = callPackage @@ -124961,8 +117310,6 @@ self: { ]; description = "Virtual Rubik's cube of arbitrary size"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hcwiid" = callPackage @@ -125008,8 +117355,6 @@ self: { ]; description = "Library to handle the details of writing daemons for UNIX"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdbc-aeson" = callPackage @@ -125026,8 +117371,6 @@ self: { ]; description = "Deserialize from HDBC rows to FromJSON instances"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdbc-postgresql-hstore" = callPackage @@ -125039,8 +117382,6 @@ self: { libraryHaskellDepends = [ attoparsec base containers HDBC text ]; description = "Manipulate data in PostgreSQL \"hstore\" columns"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdbc-tuple" = callPackage @@ -125079,8 +117420,6 @@ self: { ]; description = "Haskell Database Independent interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdbi-conduit" = callPackage @@ -125101,8 +117440,6 @@ self: { ]; description = "Conduit glue for HDBI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdbi-postgresql" = callPackage @@ -125130,8 +117467,6 @@ self: { ]; description = "PostgreSQL driver for hdbi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdbi-sqlite" = callPackage @@ -125151,8 +117486,6 @@ self: { ]; description = "SQlite driver for HDBI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdbi-tests" = callPackage @@ -125172,8 +117505,6 @@ self: { ]; description = "test suite for testing HDBI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdevtools" = callPackage @@ -125193,8 +117524,6 @@ self: { ]; description = "Persistent GHC powered background server for FAST haskell development tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdf" = callPackage @@ -125212,8 +117541,6 @@ self: { ]; description = "HDF: Uniform Rate Audio Signal Processing in Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdf5-lite" = callPackage @@ -125266,8 +117593,6 @@ self: { ]; description = "Pattern-Expression-based differencing of arbitrary types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdigest" = callPackage @@ -125282,8 +117607,6 @@ self: { ]; description = "Server-side HTTP Digest (RFC2617) in the CGI monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdirect" = callPackage @@ -125302,8 +117625,6 @@ self: { executableToolDepends = [ happy ]; description = "An IDL compiler for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdis86" = callPackage @@ -125315,8 +117636,6 @@ self: { libraryHaskellDepends = [ base bytestring containers QuickCheck ]; description = "Interface to the udis86 disassembler for x86 and x86-64 / AMD64"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdiscount" = callPackage @@ -125329,8 +117648,6 @@ self: { librarySystemDepends = [ markdown ]; description = "Haskell bindings to the Discount markdown library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {markdown = null;}; "hdm" = callPackage @@ -125344,8 +117661,6 @@ self: { executableHaskellDepends = [ base directory process unix vty ]; description = "a small display manager"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdo" = callPackage @@ -125373,8 +117688,6 @@ self: { ]; description = "A Digital Ocean client in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdocs" = callPackage @@ -125399,8 +117712,6 @@ self: { testHaskellDepends = [ base containers mtl ]; description = "Haskell docs tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdph" = callPackage @@ -125427,8 +117738,6 @@ self: { ]; description = "Haskell distributed parallel Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdph-closure" = callPackage @@ -125444,8 +117753,6 @@ self: { ]; description = "Explicit closures in Haskell distributed parallel Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hdr-histogram" = callPackage @@ -125465,8 +117772,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq primitive ]; description = "Haskell implementation of High Dynamic Range (HDR) Histograms"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "headed-megaparsec" = callPackage @@ -125501,8 +117806,6 @@ self: { ]; description = "Creates a header for a haskell source file"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "headroom" = callPackage @@ -125560,8 +117863,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "interactively inspect Haskell values at runtime"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heaps" = callPackage @@ -125604,8 +117905,6 @@ self: { executableHaskellDepends = [ array base ]; description = "Heapsort of MArrays as a demo of imperative programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heart-app" = callPackage @@ -125621,8 +117920,6 @@ self: { ]; description = "An opinionated app prelude and framework in the UnliftIO style"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heart-core" = callPackage @@ -125642,8 +117939,6 @@ self: { ]; description = "An opinionated library prelude in the UnliftIO style"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heartbeat-streams" = callPackage @@ -125655,8 +117950,6 @@ self: { libraryHaskellDepends = [ async base io-streams time ]; description = "Heartbeats for io-streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heatitup" = callPackage @@ -125686,8 +117979,6 @@ self: { ]; description = "Find and annotate ITDs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heatitup-complete" = callPackage @@ -125711,8 +118002,6 @@ self: { ]; description = "Find and annotate ITDs with assembly or read pair joining"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heatshrink" = callPackage @@ -125746,8 +118035,6 @@ self: { ]; description = "Simle api for heavy logger"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heavy-logger" = callPackage @@ -125769,8 +118056,6 @@ self: { ]; description = "Full-weight logging based on fast-logger"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heavy-logger-amazon" = callPackage @@ -125786,8 +118071,6 @@ self: { ]; description = "heavy-logger compatibility with amazonka-core logging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heavy-logger-instances" = callPackage @@ -125808,8 +118091,6 @@ self: { ]; description = "Orphan instances for data types in heavy-logger package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hebrew-time" = callPackage @@ -125822,8 +118103,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck time ]; description = "Hebrew dates and prayer times"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hecc" = callPackage @@ -125836,8 +118115,6 @@ self: { libraryHaskellDepends = [ base cereal crypto-api hF2 ]; description = "Elliptic Curve Cryptography for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heckin" = callPackage @@ -125869,8 +118146,6 @@ self: { executableHaskellDepends = [ base directory process split ]; description = "Jekyll in Haskell (feat. LaTeX)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedgehog" = callPackage @@ -125910,8 +118185,6 @@ self: { ]; testHaskellDepends = [ base either hedgehog ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedgehog-checkers-lens" = callPackage @@ -125923,8 +118196,6 @@ self: { libraryHaskellDepends = [ base hedgehog hedgehog-checkers lens ]; testHaskellDepends = [ base hedgehog hedgehog-checkers lens ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedgehog-classes" = callPackage @@ -125968,8 +118239,6 @@ self: { testHaskellDepends = [ base containers fakedata hedgehog ]; description = "Use 'fakedata' with 'hedgehog'"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedgehog-fn" = callPackage @@ -126022,8 +118291,6 @@ self: { ]; description = "JSON generators for Hedgehog"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedgehog-generic" = callPackage @@ -126035,8 +118302,6 @@ self: { libraryHaskellDepends = [ base hedgehog ]; description = "GHC Generics automatically derived hedgehog generators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedgehog-golden" = callPackage @@ -126054,8 +118319,6 @@ self: { testHaskellDepends = [ base hedgehog ]; description = "Golden testing capabilities for hedgehog using Aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedgehog-quickcheck" = callPackage @@ -126092,8 +118355,6 @@ self: { ]; description = "Hedgehog property testing for Servant APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedis" = callPackage @@ -126134,8 +118395,6 @@ self: { ]; description = "Easy trivial configuration for Redis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedis-envy" = callPackage @@ -126177,8 +118436,6 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedis-pile" = callPackage @@ -126200,8 +118457,6 @@ self: { ]; description = "Caching mandatory data with Redis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedis-simple" = callPackage @@ -126213,8 +118468,6 @@ self: { libraryHaskellDepends = [ base bytestring either hedis mtl ]; description = "A simplified API for hedis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedis-tags" = callPackage @@ -126232,8 +118485,6 @@ self: { ]; description = "Tags for hedis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedn" = callPackage @@ -126272,8 +118523,6 @@ self: { ]; description = "Base functor for EDN AST"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hedra" = callPackage @@ -126289,8 +118538,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "A small library and executable for generating dice rolls"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heidi" = callPackage @@ -126318,8 +118565,6 @@ self: { benchmarkHaskellDepends = [ base criterion weigh ]; description = "Tidy data in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hein" = callPackage @@ -126338,8 +118583,6 @@ self: { ]; description = "An extensible build helper for haskell, in the vein of leiningen"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heist" = callPackage @@ -126398,8 +118641,6 @@ self: { ]; description = "Use JSON directly from Heist templates"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heist-async" = callPackage @@ -126413,8 +118654,6 @@ self: { ]; description = "Adding support for asynchronous updates (\"AJAX\") with heist"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "helf" = callPackage @@ -126460,8 +118699,6 @@ self: { ]; description = "New Relic® agent SDK wrapper for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {newrelic-collector-client = null; newrelic-common = null; newrelic-transaction = null;}; @@ -126480,8 +118717,6 @@ self: { ]; description = "New Relic® agent SDK wrapper for wai"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "helisp" = callPackage @@ -126495,8 +118730,6 @@ self: { executableHaskellDepends = [ base containers mtl parsec process ]; description = "An incomplete Elisp compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "helium" = callPackage @@ -126520,8 +118753,6 @@ self: { ]; description = "The Helium Compiler"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "helium-overture" = callPackage @@ -126561,8 +118792,6 @@ self: { ]; description = "Web development micro framework for haskell with typesafe URLs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hell" = callPackage @@ -126587,8 +118816,6 @@ self: { executableHaskellDepends = [ base transformers utf8-string ]; description = "A Haskell shell based on shell-conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hellage" = callPackage @@ -126608,8 +118835,6 @@ self: { ]; description = "Distributed hackage mirror"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hellnet" = callPackage @@ -126634,8 +118859,6 @@ self: { ]; description = "Simple, distributed, anonymous data sharing network"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hello" = callPackage @@ -126687,8 +118910,6 @@ self: { ]; description = "A Haskell client for the Help.com team's ESB."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hemkay" = callPackage @@ -126706,8 +118927,6 @@ self: { ]; description = "A module music mixer and player"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hemkay-core" = callPackage @@ -126748,8 +118967,6 @@ self: { benchmarkHaskellDepends = [ base conduit criterion mtl ]; description = "Haskell port of the Emokit EEG project"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hen" = callPackage @@ -126770,8 +118987,6 @@ self: { ]; description = "Haskell bindings to Xen hypervisor interface"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {xenctrl = null;}; "henet" = callPackage @@ -126786,8 +119001,6 @@ self: { ]; description = "Bindings and high level interface for to ENet v1.3.9"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hepevt" = callPackage @@ -126799,8 +119012,6 @@ self: { libraryHaskellDepends = [ bytestring haskell2010 lha ]; description = "HEPEVT parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "her-lexer" = callPackage @@ -126812,8 +119023,6 @@ self: { libraryHaskellDepends = [ base mtl split ]; description = "A lexer for Haskell source code"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "her-lexer-parsec" = callPackage @@ -126825,8 +119034,6 @@ self: { libraryHaskellDepends = [ base her-lexer parsec transformers ]; description = "Parsec frontend to \"her-lexer\" for Haskell source code"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "herbalizer" = callPackage @@ -126844,8 +119051,6 @@ self: { ]; description = "HAML to ERB translator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hercules-ci-agent" = callPackage @@ -127110,8 +119315,6 @@ self: { testHaskellDepends = [ base bytestring doctest text ]; description = "Heredocument on Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "herf-time" = callPackage @@ -127153,8 +119356,6 @@ self: { ]; description = "Haskell Equational Reasoning Model-to-Implementation Tunnel"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hermit-syb" = callPackage @@ -127170,8 +119371,6 @@ self: { ]; description = "HERMIT plugin for optimizing Scrap-Your-Boilerplate traversals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "herms" = callPackage @@ -127192,8 +119391,6 @@ self: { ]; description = "A command-line manager for delicious kitchen recipes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hero-club-five-tenets" = callPackage @@ -127255,8 +119452,6 @@ self: { ]; description = "A library for compiling and serving static web assets"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "herringbone-embed" = callPackage @@ -127273,8 +119468,6 @@ self: { ]; description = "Embed preprocessed web assets in your executable with Template Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "herringbone-wai" = callPackage @@ -127291,8 +119484,6 @@ self: { ]; description = "Wai adapter for the Herringbone web asset preprocessor"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hesh" = callPackage @@ -127319,8 +119510,6 @@ self: { ]; description = "the Haskell Extensible Shell: Haskell for Bash-style scripts"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hesql" = callPackage @@ -127338,8 +119527,6 @@ self: { ]; description = "Haskell's embedded SQL"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hetero-dict" = callPackage @@ -127360,8 +119547,6 @@ self: { ]; description = "Fast heterogeneous data structures"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hetero-map" = callPackage @@ -127403,8 +119588,6 @@ self: { testHaskellDepends = [ base ]; description = "Allows the use of tuples as literals for Heterogeneous collections"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heterolist" = callPackage @@ -127422,8 +119605,6 @@ self: { ]; description = "A heterogeneous list type"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hetris" = callPackage @@ -127440,8 +119621,6 @@ self: { executableSystemDepends = [ ncurses ]; description = "Text Tetris"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses;}; "heukarya" = callPackage @@ -127456,8 +119635,6 @@ self: { ]; description = "A genetic programming based on tree structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hevm" = callPackage @@ -127505,8 +119682,6 @@ self: { testSystemDepends = [ secp256k1 ]; description = "Ethereum virtual machine evaluator"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;}; "hevolisa" = callPackage @@ -127523,8 +119698,6 @@ self: { ]; description = "Genetic Mona Lisa problem in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hevolisa-dph" = callPackage @@ -127543,8 +119716,6 @@ self: { ]; description = "Genetic Mona Lisa problem in Haskell - using Data Parallel Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hex" = callPackage @@ -127568,8 +119739,6 @@ self: { testHaskellDepends = [ base bytestring text ]; description = "ByteString-Text hexidecimal conversions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexchat" = callPackage @@ -127581,8 +119750,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Haskell scripting interface for HexChat"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexdump" = callPackage @@ -127606,8 +119773,6 @@ self: { libraryHaskellDepends = [ base binary bytestring filepath ]; description = "Reading Exif data form a JPEG file with Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexmino" = callPackage @@ -127626,8 +119791,6 @@ self: { ]; description = "A small game based on domino-like hexagonal tiles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexml" = callPackage @@ -127660,8 +119823,6 @@ self: { ]; description = "Lenses for the hexml package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexpat" = callPackage @@ -127711,8 +119872,6 @@ self: { ]; description = "Chunked XML parsing using iteratees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexpat-lens" = callPackage @@ -127761,8 +119920,6 @@ self: { ]; description = "Picklers for de/serialising Generic data types to and from XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexpat-streamparser" = callPackage @@ -127804,8 +119961,6 @@ self: { ]; description = "A framework for symbolic, homoiconic languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexpress" = callPackage @@ -127823,8 +119978,6 @@ self: { ]; description = "An express-like http framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexquote" = callPackage @@ -127840,8 +119993,6 @@ self: { ]; description = "Hexadecimal ByteString literals, with placeholders that bind variables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hexstring" = callPackage @@ -127859,8 +120010,6 @@ self: { testHaskellDepends = [ base binary bytestring hspec text ]; description = "Fast and safe representation of a hex string"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hext" = callPackage @@ -127877,8 +120026,6 @@ self: { executableHaskellDepends = [ base text ]; description = "a text classification library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hextra" = callPackage @@ -127913,8 +120060,6 @@ self: { ]; description = "Streaming-friendly XML parsers"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heyefi" = callPackage @@ -127946,8 +120091,6 @@ self: { ]; description = "A server for Eye-Fi SD cards"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "heyting-algebras" = callPackage @@ -127969,8 +120112,6 @@ self: { ]; description = "Heyting and Boolean algebras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hfann" = callPackage @@ -127986,8 +120127,6 @@ self: { libraryPkgconfigDepends = [ fann ]; description = "Haskell binding to the FANN library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {doublefann = null; fann = null;}; "hfd" = callPackage @@ -128006,8 +120145,6 @@ self: { ]; description = "Flash debugger"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hfiar" = callPackage @@ -128023,8 +120160,6 @@ self: { executableHaskellDepends = [ wx wxcore ]; description = "Four in a Row in Haskell!!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hflags" = callPackage @@ -128065,8 +120200,6 @@ self: { ]; description = "Haskell source code formatter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hfoil" = callPackage @@ -128086,8 +120219,6 @@ self: { executableHaskellDepends = [ base ]; description = "Hess-Smith panel code for inviscid 2-d airfoil analysis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hformat" = callPackage @@ -128115,8 +120246,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Field-of-view calculation for low-resolution 2D raster grids"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hfractal" = callPackage @@ -128135,8 +120264,6 @@ self: { ]; description = "OpenGL fractal renderer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hfsevents" = callPackage @@ -128167,8 +120294,6 @@ self: { ]; description = "A library for fusing a subset of Haskell programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hg-buildpackage" = callPackage @@ -128187,8 +120312,6 @@ self: { ]; description = "Tools to help manage Debian packages with Mercurial"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgal" = callPackage @@ -128211,8 +120334,6 @@ self: { libraryHaskellDepends = [ array base haskell98 mtl ]; description = "Haskell Genetic Algorithm Library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgdbmi" = callPackage @@ -128231,8 +120352,6 @@ self: { ]; description = "GDB Machine Interface: program-driven control of GDB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgearman" = callPackage @@ -128250,8 +120369,6 @@ self: { ]; description = "A Gearman client for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgen" = callPackage @@ -128267,8 +120384,6 @@ self: { ]; description = "Random generation of modal and hybrid logic formulas"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgeometric" = callPackage @@ -128280,8 +120395,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A geometric library with bindings to GPC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgeometry" = callPackage @@ -128382,8 +120495,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Reading and Writing ipe7 files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgeometry-svg" = callPackage @@ -128404,8 +120515,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Writing geometric primitives from HGeometry as SVG Files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgeos" = callPackage @@ -128420,8 +120529,6 @@ self: { testHaskellDepends = [ base MissingH ]; description = "Simple Haskell bindings to GEOS C API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) geos;}; "hgettext" = callPackage @@ -128444,8 +120551,6 @@ self: { ]; description = "Bindings to libintl.h (gettext, bindtextdomain)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgis" = callPackage @@ -128469,8 +120574,6 @@ self: { doHaddock = false; description = "Library and for GIS with Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgithub" = callPackage @@ -128491,8 +120594,6 @@ self: { executableHaskellDepends = [ base cmdargs directory ]; description = "Haskell bindings to the GitHub API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgl-example" = callPackage @@ -128522,8 +120623,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Haskell interface to GMP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgom" = callPackage @@ -128542,8 +120641,6 @@ self: { ]; description = "An haskell port of the java version of gom"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgopher" = callPackage @@ -128555,8 +120652,6 @@ self: { libraryHaskellDepends = [ base bytestring network ]; description = "Gopher server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgrep" = callPackage @@ -128579,8 +120674,6 @@ self: { ]; description = "Search Haskell source code from the command line"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hgrev" = callPackage @@ -128614,8 +120707,6 @@ self: { testHaskellDepends = [ base directory hspec ]; description = "Unofficial bindings for GRIB API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {grib_api = null;}; "hharp" = callPackage @@ -128628,8 +120719,6 @@ self: { librarySystemDepends = [ harp ]; description = "Binding to libharp"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {harp = null;}; "hhp" = callPackage @@ -128656,8 +120745,6 @@ self: { ]; description = "Happy Haskell Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hhwloc" = callPackage @@ -128671,8 +120758,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Bindings to https://www.open-mpi.org/projects/hwloc"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hi" = callPackage @@ -128703,8 +120788,6 @@ self: { ]; description = "Generate scaffold for cabal project"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hi-file-parser" = callPackage @@ -128740,8 +120823,6 @@ self: { executableHaskellDepends = [ base dbus process ]; description = "Status line for i3bar"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hiccup" = callPackage @@ -128761,8 +120842,6 @@ self: { ]; description = "Relatively efficient Tcl interpreter with support for basic operations"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hichi" = callPackage @@ -128776,8 +120855,6 @@ self: { executableHaskellDepends = [ array base bytestring mtl network ]; description = "haskell robot for IChat protocol"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hid" = callPackage @@ -128825,8 +120902,6 @@ self: { doHaddock = false; description = "Examples to accompany the book \"Haskell in Depth\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hidapi" = callPackage @@ -128860,8 +120935,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Provides cross-platform getHiddenChar function"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hie-bios" = callPackage @@ -128946,8 +121019,6 @@ self: { ]; description = "The core of an IDE"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hiedb" = callPackage @@ -128984,8 +121055,6 @@ self: { libraryHaskellDepends = [ base containers HUnit mtl multiset ]; description = "Automated clustering of arbitrary elements in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hierarchical-clustering" = callPackage @@ -129051,8 +121120,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Template Haskell functions to easily create exception hierarchies"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hierarchical-spectral-clustering" = callPackage @@ -129083,8 +121150,6 @@ self: { ]; description = "Hierarchical spectral clustering of a graph"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hierarchy" = callPackage @@ -129107,8 +121172,6 @@ self: { ]; description = "Predicated traversal of generated trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hiernotify" = callPackage @@ -129124,8 +121187,6 @@ self: { ]; description = "Notification library for a filesystem hierarchy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hifi" = callPackage @@ -129168,8 +121229,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Partial types as a type constructor"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "highWaterMark" = callPackage @@ -129184,8 +121243,6 @@ self: { executableHaskellDepends = [ base ghc ]; description = "Memory usage statistics"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "higher-leveldb" = callPackage @@ -129222,8 +121279,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Some higher order functions for Bool and []"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "highjson" = callPackage @@ -129241,8 +121296,6 @@ self: { ]; description = "Spec based JSON parsing/serialisation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "highjson-swagger" = callPackage @@ -129261,8 +121314,6 @@ self: { ]; description = "Derive swagger instances from highjson specs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "highjson-th" = callPackage @@ -129283,8 +121334,6 @@ self: { ]; description = "Template Haskell helpers for highjson specs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "highlight" = callPackage @@ -129332,8 +121381,6 @@ self: { ]; description = "Highlight package versions which differ from the latest version on Hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "highlighter" = callPackage @@ -129451,8 +121498,6 @@ self: { ]; description = "Simple gtk2hs image viewer. Point it at an image and fire away."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "himpy" = callPackage @@ -129474,8 +121519,6 @@ self: { ]; description = "multithreaded snmp poller for riemann"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hindent" = callPackage @@ -129510,8 +121553,6 @@ self: { ]; description = "Extensible Haskell pretty printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hindley-milner" = callPackage @@ -129528,8 +121569,6 @@ self: { testHaskellDepends = [ base containers hspec ]; description = "Template for Hindley-Milner based languages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinduce-associations-apriori" = callPackage @@ -129556,8 +121595,6 @@ self: { libraryHaskellDepends = [ base hinduce-missingh layout ]; description = "Interface and utilities for classifiers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinduce-classifier-decisiontree" = callPackage @@ -129575,8 +121612,6 @@ self: { ]; description = "Decision Tree Classifiers for hInduce"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinduce-examples" = callPackage @@ -129596,8 +121631,6 @@ self: { ]; description = "Example data for hInduce"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinduce-missingh" = callPackage @@ -129726,8 +121759,6 @@ self: { ]; description = "Generate armet style query strings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinstaller" = callPackage @@ -129743,8 +121774,6 @@ self: { ]; description = "Installer wrapper for Haskell applications"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hint" = callPackage @@ -129780,8 +121809,6 @@ self: { ]; description = "A server process that runs hint"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinter" = callPackage @@ -129803,8 +121830,6 @@ self: { ]; description = "Runtime Haskell interpreter (GHC API wrapper)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinterface" = callPackage @@ -129831,8 +121856,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell / Erlang interoperability library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinvaders" = callPackage @@ -129847,8 +121870,6 @@ self: { executableHaskellDepends = [ base haskell98 random ]; description = "Space Invaders"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hinze-streams" = callPackage @@ -129860,8 +121881,6 @@ self: { libraryHaskellDepends = [ base haskell98 Stream ]; description = "Streams and Unique Fixed Points"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hip" = callPackage @@ -129886,8 +121905,6 @@ self: { ]; description = "Haskell Image Processing (HIP) Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hipbot" = callPackage @@ -129912,8 +121929,6 @@ self: { ]; description = "A library for building HipChat Bots"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hipchat-hs" = callPackage @@ -129932,8 +121947,6 @@ self: { ]; description = "Hipchat API bindings in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hipe" = callPackage @@ -129949,8 +121962,6 @@ self: { ]; description = "Support for reading and writing ipe7 files (http://ipe7.sourceforge.net)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hips" = callPackage @@ -129976,8 +121987,6 @@ self: { sha256 = "18hwc5x902k2dsk8895sr8nil4445b9lazzdzbjzpllx4smf0lvz"; libraryHaskellDepends = [ aeson base bytestring servant ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hipsql-client" = callPackage @@ -130000,8 +122009,6 @@ self: { http-types mtl servant-client servant-client-core ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hipsql-monad" = callPackage @@ -130033,8 +122040,6 @@ self: { servant-server warp ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hircules" = callPackage @@ -130053,8 +122058,6 @@ self: { ]; description = "IRC client"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hirt" = callPackage @@ -130075,8 +122078,6 @@ self: { ]; description = "Calculates IRT 2PL and 3PL models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hissmetrics" = callPackage @@ -130092,8 +122093,6 @@ self: { ]; description = "Unofficial API bindings to KISSmetrics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hist-pl" = callPackage @@ -130117,8 +122116,6 @@ self: { ]; description = "Umbrella package for the historical dictionary of Polish"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hist-pl-dawg" = callPackage @@ -130133,8 +122130,6 @@ self: { ]; description = "A generic, DAWG-based dictionary"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hist-pl-fusion" = callPackage @@ -130151,8 +122146,6 @@ self: { ]; description = "Merging historical dictionary with PoliMorf"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hist-pl-lexicon" = callPackage @@ -130169,8 +122162,6 @@ self: { ]; description = "A binary representation of the historical dictionary of Polish"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hist-pl-lmf" = callPackage @@ -130182,8 +122173,6 @@ self: { libraryHaskellDepends = [ base hist-pl-types polysoup text ]; description = "LMF parsing for the historical dictionary of Polish"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hist-pl-transliter" = callPackage @@ -130206,8 +122195,6 @@ self: { libraryHaskellDepends = [ base binary text text-binary ]; description = "Types in the historical dictionary of Polish"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "histogram-fill" = callPackage @@ -130272,8 +122259,6 @@ self: { ]; description = "Extract the interesting bits from shell history"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hit" = callPackage @@ -130292,8 +122277,6 @@ self: { ]; description = "Git like program in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hit-graph" = callPackage @@ -130309,8 +122292,6 @@ self: { ]; description = "Use graph algorithms to access and manipulate Git repos"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hit-on" = callPackage @@ -130332,8 +122313,6 @@ self: { testHaskellDepends = [ base github hspec text ]; description = "Haskell Git Helper Tool"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hjcase" = callPackage @@ -130350,8 +122329,6 @@ self: { ]; description = "Jcase library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hjpath" = callPackage @@ -130381,8 +122358,6 @@ self: { ]; description = "JavaScript Parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hjsmin" = callPackage @@ -130428,8 +122403,6 @@ self: { libraryHaskellDepends = [ base containers hjson ]; description = "library for querying from JSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hjsonpointer" = callPackage @@ -130451,8 +122424,6 @@ self: { ]; description = "JSON Pointer library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hjsonschema" = callPackage @@ -130483,8 +122454,6 @@ self: { ]; description = "JSON Schema library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hjugement" = callPackage @@ -130534,8 +122503,6 @@ self: { ]; description = "Majority Judgment and Helios-C command line tool"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hjugement-protocol" = callPackage @@ -130600,8 +122567,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Definition of \"Delta structures\" for higher kinded data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hkd-lens" = callPackage @@ -130613,8 +122578,6 @@ self: { libraryHaskellDepends = [ base profunctors ]; description = "Generic lens/prism/traversal-kinded data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hkdf" = callPackage @@ -130681,8 +122644,6 @@ self: { ]; description = "A library for higher kinded types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hlatex" = callPackage @@ -130720,8 +122681,6 @@ self: { ]; description = "Haskell binding to L-BFGS-B version 3.0"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gfortran;}; "hlcm" = callPackage @@ -130743,8 +122702,6 @@ self: { ]; description = "Fast algorithm for mining closed frequent itemsets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hleap" = callPackage @@ -130835,8 +122792,6 @@ self: { ]; description = "Web API server for the hledger accounting tool"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hledger-chart" = callPackage @@ -130855,8 +122810,6 @@ self: { ]; description = "A pie chart image generator for the hledger accounting tool"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hledger-diff" = callPackage @@ -130963,8 +122916,6 @@ self: { ]; description = "computes the internal rate of return of an investment"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hledger-lib" = callPackage @@ -131086,8 +123037,6 @@ self: { ]; description = "A curses-style console interface for the hledger accounting tool"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hledger-web" = callPackage @@ -131138,8 +123087,6 @@ self: { testHaskellDepends = [ base hlint ]; description = "Haskell binding to libBladeRF SDR library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libbladeRF;}; "hlibcpuid" = callPackage @@ -131167,8 +123114,6 @@ self: { librarySystemDepends = [ ev ]; description = "FFI interface to libev"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ev = null;}; "hlibfam" = callPackage @@ -131181,8 +123126,6 @@ self: { librarySystemDepends = [ fam ]; description = "FFI interface to libFAM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fam;}; "hlibgit2" = callPackage @@ -131307,8 +123250,6 @@ self: { ]; description = "Client library for the Apache Livy REST API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hlogger" = callPackage @@ -131320,8 +123261,6 @@ self: { libraryHaskellDepends = [ base old-locale time ]; description = "Simple, concurrent, extendable and easy-to-use logging library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hlongurl" = callPackage @@ -131340,8 +123279,6 @@ self: { ]; description = "Library and utility interfacing to longurl.org"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hlrdb" = callPackage @@ -131361,8 +123298,6 @@ self: { ]; description = "High-level Redis Database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hlrdb-core" = callPackage @@ -131381,8 +123316,6 @@ self: { ]; description = "High-level Redis Database Core API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hls" = callPackage @@ -131395,8 +123328,6 @@ self: { libraryHaskellDepends = [ base containers hcg-minus hps ]; description = "Haskell Lindenmayer Systems"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hls-brittany-plugin" = callPackage @@ -131481,8 +123412,6 @@ self: { ]; description = "Common utilities to interaction between ghc-exactprint and HLS plugins"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hls-explicit-imports-plugin" = callPackage @@ -131683,8 +123612,6 @@ self: { libraryHaskellDepends = [ base stm transformers unix X11 ]; description = "Bindings to the herbstluftwm window manager"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hly" = callPackage @@ -131699,8 +123626,6 @@ self: { ]; description = "Haskell LilyPond"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmark" = callPackage @@ -131719,8 +123644,6 @@ self: { executableHaskellDepends = [ base ]; description = "A tool and library for Markov chains based text generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmarkup" = callPackage @@ -131734,8 +123657,6 @@ self: { ]; description = "Simple wikitext-like markup format implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmatrix" = callPackage @@ -131791,8 +123712,6 @@ self: { librarySystemDepends = [ liblapack ]; description = "HMatrix interface to LAPACK functions for banded matrices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {liblapack = null;}; "hmatrix-csv" = callPackage @@ -131858,8 +123777,6 @@ self: { libraryHaskellDepends = [ base hmatrix mmap ]; description = "Memory map Vector from disk into memory efficiently"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmatrix-morpheus" = callPackage @@ -131893,8 +123810,6 @@ self: { libraryHaskellDepends = [ base hmatrix ]; description = "NIPALS method for Principal Components Analysis on large data-sets"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmatrix-nlopt" = callPackage @@ -131943,8 +123858,6 @@ self: { librarySystemDepends = [ mkl_core mkl_intel mkl_sequential ]; description = "Sparse linear solver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {mkl_core = null; mkl_intel = null; mkl_sequential = null;}; "hmatrix-special" = callPackage @@ -131971,8 +123884,6 @@ self: { ]; description = "hmatrix with vector and matrix sizes encoded in types"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmatrix-sundials" = callPackage @@ -132000,8 +123911,6 @@ self: { ]; description = "hmatrix interface to sundials"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {sundials_arkode = null; sundials_cvode = null;}; "hmatrix-svdlibc" = callPackage @@ -132017,8 +123926,6 @@ self: { benchmarkHaskellDepends = [ base criterion hmatrix vector ]; description = "SVDLIBC bindings for HMatrix"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmatrix-syntax" = callPackage @@ -132034,8 +123941,6 @@ self: { ]; description = "MATLAB-like syntax for hmatrix vectors and matrices"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmatrix-tests" = callPackage @@ -132053,8 +123958,6 @@ self: { benchmarkHaskellDepends = [ base HUnit QuickCheck random ]; description = "Tests for hmatrix"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmatrix-vector-sized" = callPackage @@ -132086,8 +123989,6 @@ self: { ]; description = "Haskell Meapsoft Parser"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmeap-utils" = callPackage @@ -132107,8 +124008,6 @@ self: { ]; description = "Haskell Meapsoft Parser Utilities"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmemdb" = callPackage @@ -132137,8 +124036,6 @@ self: { executableHaskellDepends = [ base MissingH process ]; description = "CLI fuzzy finder and launcher"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmep" = callPackage @@ -132158,8 +124055,6 @@ self: { testHaskellDepends = [ base HUnit vector ]; description = "HMEP Multi Expression Programming – a genetic programming variant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmidi" = callPackage @@ -132190,8 +124085,6 @@ self: { ]; description = "A make alternative based on Plan9's mk"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmm" = callPackage @@ -132207,8 +124100,6 @@ self: { ]; description = "A hidden markov model library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmm-hmatrix" = callPackage @@ -132227,8 +124118,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Hidden Markov Models using HMatrix primitives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmm-lapack" = callPackage @@ -132251,8 +124140,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Hidden Markov Models using LAPACK primitives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmp3" = callPackage @@ -132273,8 +124160,6 @@ self: { executableSystemDepends = [ ncurses ]; description = "An ncurses mp3 player written in Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses;}; "hmp3-ng" = callPackage @@ -132328,8 +124213,6 @@ self: { ]; description = "Haskell Music Theory"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmt-diagrams" = callPackage @@ -132347,8 +124230,6 @@ self: { ]; description = "Haskell Music Theory Diagrams"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hmumps" = callPackage @@ -132367,8 +124248,6 @@ self: { ]; description = "Interpreter for the MUMPS langugae"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hnetcdf" = callPackage @@ -132398,8 +124277,6 @@ self: { testSystemDepends = [ netcdf ]; description = "Haskell NetCDF library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) netcdf;}; "hnix" = callPackage @@ -132593,8 +124470,6 @@ self: { ]; description = "Log message normalisation tool producing structured JSON messages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ho-rewriting" = callPackage @@ -132610,8 +124485,6 @@ self: { testHaskellDepends = [ base compdata patch-combinators ]; description = "Generic rewrite rules with safe treatment of variables and binders"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoauth" = callPackage @@ -132629,8 +124502,6 @@ self: { ]; description = "A Haskell implementation of OAuth 1.0a protocol."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoauth2" = callPackage @@ -132678,8 +124549,6 @@ self: { ]; description = "A source code editor aiming for the convenience of use"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hobbes" = callPackage @@ -132697,8 +124566,6 @@ self: { ]; description = "A small file watcher for OSX"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hobbits" = callPackage @@ -132716,8 +124583,6 @@ self: { ]; description = "A library for canonically representing terms with binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hocilib" = callPackage @@ -132737,8 +124602,6 @@ self: { testSystemDepends = [ ocilib ]; description = "FFI binding to OCILIB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ocilib = null;}; "hocker" = callPackage @@ -132781,8 +124644,6 @@ self: { ]; description = "Interact with the docker registry and generate nix build instructions"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hocon" = callPackage @@ -132818,8 +124679,6 @@ self: { benchmarkHaskellDepends = [ base criterion random ]; description = "A fully featured date/time library based on Nodatime"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoe" = callPackage @@ -132838,8 +124697,6 @@ self: { ]; description = "hoe: Haskell One-liner Evaluator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hofix-mtl" = callPackage @@ -132869,8 +124726,6 @@ self: { ]; description = "Simple IRC logger bot"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hogg" = callPackage @@ -132888,8 +124743,6 @@ self: { ]; description = "Library and tools to manipulate the Ogg container format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoggl" = callPackage @@ -132915,8 +124768,6 @@ self: { ]; description = "Bindings to the Toggl.com REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hogre" = callPackage @@ -132932,8 +124783,6 @@ self: { doHaddock = false; description = "Haskell binding to a subset of OGRE"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {OGRE = null; OgreMain = null; cgen-hs = null; grgen = null;}; "hogre-examples" = callPackage @@ -132949,8 +124798,6 @@ self: { executableSystemDepends = [ OgreMain ]; description = "Examples for using Hogre"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {OgreMain = null;}; "hois" = callPackage @@ -132966,8 +124813,6 @@ self: { executableHaskellDepends = [ base X11 ]; description = "OIS bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {OIS = null;}; "hoist-error" = callPackage @@ -133011,8 +124856,6 @@ self: { ]; description = "Higher order logic"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hold-em" = callPackage @@ -133024,8 +124867,6 @@ self: { libraryHaskellDepends = [ base random safe ]; description = "An engine for Texas hold'em Poker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hole" = callPackage @@ -133037,8 +124878,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Higher kinded type removal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "holey-format" = callPackage @@ -133074,8 +124913,6 @@ self: { testToolDepends = [ markdown-unlit tasty-discover ]; description = "Tools and combinators for solving constraint problems"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "holy-project" = callPackage @@ -133110,8 +124947,6 @@ self: { doCheck = false; description = "Start your Haskell project with cabal, git and tests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "homeomorphic" = callPackage @@ -133123,8 +124958,6 @@ self: { libraryHaskellDepends = [ base containers mtl QuickCheck ]; description = "Homeomorphic Embedding Test"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hommage" = callPackage @@ -133138,8 +124971,6 @@ self: { ]; description = "Haskell Offline Music Manipulation And Generation EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hommage-ds" = callPackage @@ -133166,8 +124997,6 @@ self: { testHaskellDepends = [ base ]; description = "Constructs FAlgebras from typeclasses, making Haskell functions homoiconic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "homotuple" = callPackage @@ -133211,8 +125040,6 @@ self: { ]; description = "Haskell code quality tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "homura-stopwatch" = callPackage @@ -133242,8 +125069,6 @@ self: { testSystemDepends = [ freenect OpenNI2 ]; description = "OpenNI 2 binding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {OpenNI2 = null; inherit (pkgs) freenect;}; "honk" = callPackage @@ -133273,8 +125098,6 @@ self: { ]; description = "Simple tool for fetching and merging hoogle data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hood" = callPackage @@ -133287,8 +125110,6 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "Debugging by observing in place"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hood-off" = callPackage @@ -133300,8 +125121,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Dummy package to disable Hood without having to remove all the calls to observe"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hood2" = callPackage @@ -133313,8 +125132,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Debugging by observing in place"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodie" = callPackage @@ -133332,8 +125149,6 @@ self: { ]; description = "A small, toy roguelike"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodle" = callPackage @@ -133354,8 +125169,6 @@ self: { executableHaskellDepends = [ base cmdargs hoodle-core ]; description = "Executable for hoodle"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodle-builder" = callPackage @@ -133372,8 +125185,6 @@ self: { ]; description = "text builder for hoodle file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodle-core" = callPackage @@ -133406,8 +125217,6 @@ self: { librarySystemDepends = [ libX11 libXi ]; description = "Core library for hoodle"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXi;}; "hoodle-extra" = callPackage @@ -133433,8 +125242,6 @@ self: { ]; description = "extra hoodle tools"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodle-parser" = callPackage @@ -133452,8 +125259,6 @@ self: { ]; description = "Hoodle file parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodle-publish" = callPackage @@ -133480,8 +125285,6 @@ self: { ]; description = "publish hoodle files as a static web site"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodle-render" = callPackage @@ -133502,8 +125305,6 @@ self: { ]; description = "Hoodle file renderer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoodle-types" = callPackage @@ -133520,8 +125321,6 @@ self: { ]; description = "Data types for programs for hoodle file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoogle" = callPackage @@ -133573,8 +125372,6 @@ self: { ]; description = "Easily generate Hoogle indices for installed packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hooks-dir" = callPackage @@ -133586,8 +125383,6 @@ self: { libraryHaskellDepends = [ base directory process text ]; description = "run executables in a directory as hooks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hookup" = callPackage @@ -133625,8 +125420,6 @@ self: { ]; description = "Object-Oriented Programming in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoopl" = callPackage @@ -133646,8 +125439,6 @@ self: { ]; description = "A library to support dataflow analysis and optimization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoovie" = callPackage @@ -133671,8 +125462,6 @@ self: { ]; description = "Haskell Media Server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hopencc" = callPackage @@ -133689,8 +125478,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Haskell binding to libopencc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) opencc;}; "hopencl" = callPackage @@ -133710,8 +125497,6 @@ self: { ]; description = "Haskell bindings for OpenCL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {OpenCL = null;}; "hopenpgp-tools" = callPackage @@ -133790,8 +125575,6 @@ self: { ]; description = "Hopfield Networks, Boltzmann Machines and Clusters"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {MagickCore = null; inherit (pkgs) imagemagick;}; "hopfield-networks" = callPackage @@ -133919,8 +125702,6 @@ self: { ]; description = "Handy Operations on Power Series"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hoq" = callPackage @@ -133940,8 +125721,6 @@ self: { executableToolDepends = [ alex happy ]; description = "A language based on homotopy type theory with an interval type"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hora" = callPackage @@ -133970,8 +125749,6 @@ self: { libraryHaskellDepends = [ AC-Angle base time ]; description = "Sunrise and sunset UTC approximations from latitude and longitude coordinates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "horname" = callPackage @@ -133990,8 +125767,6 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "Rename function definitions returned by SMT solvers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hosc" = callPackage @@ -134027,8 +125802,6 @@ self: { ]; description = "Haskell Open Sound Control JSON Serialisation"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hosc-utils" = callPackage @@ -134108,8 +125881,6 @@ self: { ]; description = "An dns server which is extremely easy to config"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hothasktags" = callPackage @@ -134128,8 +125899,6 @@ self: { ]; description = "Generates ctags for Haskell, incorporating import lists and qualified imports"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hotswap" = callPackage @@ -134141,8 +125910,6 @@ self: { libraryHaskellDepends = [ base plugins ]; description = "Simple code hotswapping"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hourglass" = callPackage @@ -134173,8 +125940,6 @@ self: { libraryHaskellDepends = [ base hourglass parsec ]; description = "A small library for parsing more human friendly date/time formats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hourglass-orphans" = callPackage @@ -134220,8 +125985,6 @@ self: { ]; description = "A Haskell implementation of Foreman"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hout" = callPackage @@ -134250,8 +126013,6 @@ self: { ]; description = "Heap profiling helper library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hp2any-graph" = callPackage @@ -134273,8 +126034,6 @@ self: { executableSystemDepends = [ freeglut libGL libGLU ]; description = "Real-time heap graphing utility and profile stream server with a reusable graphing module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) freeglut; inherit (pkgs) libGL; inherit (pkgs) libGLU;}; @@ -134296,8 +126055,6 @@ self: { ]; description = "A utility to visualise and compare heap profiles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hp2html" = callPackage @@ -134399,8 +126156,6 @@ self: { ]; description = "Convert Cabal manifests into hpack's package.yamls"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpack-dhall" = callPackage @@ -134431,8 +126186,6 @@ self: { ]; description = "hpack's dhalling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpaco" = callPackage @@ -134450,8 +126203,6 @@ self: { ]; description = "Modular template compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpaco-lib" = callPackage @@ -134469,8 +126220,6 @@ self: { ]; description = "Modular template compiler library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpage" = callPackage @@ -134492,8 +126241,6 @@ self: { ]; description = "A scrapbook for Haskell developers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpapi" = callPackage @@ -134506,8 +126253,6 @@ self: { librarySystemDepends = [ papi ]; description = "Binding for the PAPI library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) papi;}; "hpaste" = callPackage @@ -134535,8 +126280,6 @@ self: { ]; description = "Haskell paste web site"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpasteit" = callPackage @@ -134556,8 +126299,6 @@ self: { ]; description = "A command-line client for hpaste.org"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpath" = callPackage @@ -134698,8 +126439,6 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Coveralls.io support for Haskell."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpc-lcov" = callPackage @@ -134772,8 +126511,6 @@ self: { ]; description = "Tracer with AJAX interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpdft" = callPackage @@ -134810,8 +126547,6 @@ self: { executableHaskellDepends = [ base random ]; description = "a simple password generator"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpio" = callPackage @@ -134841,8 +126576,6 @@ self: { ]; description = "Monads for GPIO in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hplayground" = callPackage @@ -134874,8 +126607,6 @@ self: { executableHaskellDepends = [ base directory filepath process ]; description = "Application for managing playlist files on a music player"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpodder" = callPackage @@ -134895,8 +126626,6 @@ self: { ]; description = "Podcast Aggregator (downloader)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpp" = callPackage @@ -134946,8 +126675,6 @@ self: { ]; description = "Haskell bindings to libpqtypes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) postgresql;}; "hpqtypes-extras" = callPackage @@ -134973,8 +126700,6 @@ self: { benchmarkHaskellDepends = [ base deepseq tasty-bench ]; description = "Extra utilities for hpqtypes library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hprotoc" = callPackage @@ -135004,8 +126729,6 @@ self: { executableToolDepends = [ alex ]; description = "Parse Google Protocol Buffer specifications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hprotoc-fork" = callPackage @@ -135034,8 +126757,6 @@ self: { executableToolDepends = [ alex ]; description = "Parse Google Protocol Buffer specifications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hprox" = callPackage @@ -135070,8 +126791,6 @@ self: { libraryHaskellDepends = [ base filepath hcg-minus process ]; description = "Haskell Postscript"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hps-cairo" = callPackage @@ -135087,8 +126806,6 @@ self: { executableHaskellDepends = [ base cairo gtk hps random ]; description = "Cairo rendering for the haskell postscript library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hps-kmeans" = callPackage @@ -135100,8 +126817,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "A nice implementation of the k-Means algorithm"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpuz" = callPackage @@ -135130,8 +126845,6 @@ self: { ]; description = "Highlight source code using Pygments"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpylos" = callPackage @@ -135147,8 +126860,6 @@ self: { ]; description = "AI of Pylos game with GLUT interface"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpyrg" = callPackage @@ -135164,8 +126875,6 @@ self: { ]; description = "pyrg utility done right"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hpython" = callPackage @@ -135195,8 +126904,6 @@ self: { ]; description = "Python language tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hquantlib" = callPackage @@ -135226,8 +126933,6 @@ self: { ]; description = "HQuantLib is a port of essencial parts of QuantLib to Haskell"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hquantlib-time" = callPackage @@ -135239,8 +126944,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "HQuantLib Time is a business calendar functions extracted from HQuantLib"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hquery" = callPackage @@ -135271,8 +126974,6 @@ self: { executableHaskellDepends = [ base HCL NonEmpty ]; description = "Basic utility for ranking a list of items"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hreader" = callPackage @@ -135292,8 +126993,6 @@ self: { testHaskellDepends = [ base hset transformers-base ]; description = "Generalization of MonadReader and ReaderT using hset"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hreader-lens" = callPackage @@ -135309,8 +127008,6 @@ self: { ]; description = "Optics for hreader package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hreq-client" = callPackage @@ -135339,8 +127036,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A Type dependent Highlevel HTTP client library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hreq-conduit" = callPackage @@ -135365,8 +127060,6 @@ self: { testToolDepends = [ hspec-discover markdown-unlit ]; description = "Conduit streaming support for Hreq"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hreq-core" = callPackage @@ -135387,8 +127080,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Core functionality for Hreq Http client library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hrfsize" = callPackage @@ -135414,8 +127105,6 @@ self: { executableHaskellDepends = [ base containers ]; description = "A Cricket scoring application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hriemann" = callPackage @@ -135441,8 +127130,6 @@ self: { ]; description = "A Riemann Client for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hruby" = callPackage @@ -135527,8 +127214,6 @@ self: { benchmarkSystemDepends = [ libb2 ]; description = "A cryptohash-inspired library for blake2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libb2;}; "hs-brotli" = callPackage @@ -135547,8 +127232,6 @@ self: { ]; description = "Compression and decompression in the brotli format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {brotlidec = null; brotlienc = null;}; "hs-captcha" = callPackage @@ -135589,8 +127272,6 @@ self: { ]; description = "Example Monte Carlo simulations implemented with Carbon"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-cdb" = callPackage @@ -135606,8 +127287,6 @@ self: { ]; description = "A library for reading CDB (Constant Database) files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-conllu" = callPackage @@ -135628,8 +127307,6 @@ self: { ]; description = "Conllu validating parser and utils"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-di" = callPackage @@ -135659,8 +127336,6 @@ self: { ]; description = "Dependency Injection library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-dotnet" = callPackage @@ -135673,8 +127348,6 @@ self: { librarySystemDepends = [ ole32 oleaut32 ]; description = "Pragmatic .NET interop for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ole32 = null; oleaut32 = null;}; "hs-duktape" = callPackage @@ -135712,8 +127385,6 @@ self: { ]; description = "HS-Excelx provides basic read-only access to Excel 2007 and 2010 documents in XLSX format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-ffmpeg" = callPackage @@ -135725,8 +127396,6 @@ self: { libraryHaskellDepends = [ base bytestring haskell98 ]; description = "Bindings to FFMPEG library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-fltk" = callPackage @@ -135740,8 +127409,6 @@ self: { librarySystemDepends = [ fltk fltk_images ]; description = "Binding to GUI library FLTK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fltk; fltk_images = null;}; "hs-functors" = callPackage @@ -135783,8 +127450,6 @@ self: { ]; description = "Utility to generate haskell-names interface files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-gizapp" = callPackage @@ -135800,8 +127465,6 @@ self: { ]; description = "Haskell wrapper around the GIZA++ toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-inspector" = callPackage @@ -135814,8 +127477,6 @@ self: { testHaskellDepends = [ base haskell-src hspec ]; description = "Haskell source code analyzer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-ix" = callPackage @@ -135846,8 +127507,6 @@ self: { ]; description = "Java .class files assembler/disassembler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-json-rpc" = callPackage @@ -135861,8 +127520,6 @@ self: { ]; description = "JSON-RPC client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-logo" = callPackage @@ -135889,8 +127546,6 @@ self: { ]; description = "Logo interpreter written in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-mesos" = callPackage @@ -135949,8 +127604,6 @@ self: { executableHaskellDepends = [ base HandsomeSoup hxt random ]; description = "Name generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-openmoji-data" = callPackage @@ -135990,8 +127643,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "DSL for musical patterns and transformation, based on contravariant functors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-pgms" = callPackage @@ -136011,8 +127662,6 @@ self: { ]; description = "Programmer's Mine Sweeper in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-php-session" = callPackage @@ -136037,8 +127686,6 @@ self: { libraryHaskellDepends = [ base data-default-class text ]; description = "Create pkg-config configuration files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-pkpass" = callPackage @@ -136059,8 +127706,6 @@ self: { ]; description = "A library for Passbook pass creation & signing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-popen" = callPackage @@ -136097,8 +127742,6 @@ self: { libraryHaskellDepends = [ array base regex-base regex-posix ]; description = "Easy to use Regex"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-rqlite" = callPackage @@ -136115,8 +127758,6 @@ self: { ]; description = "A Haskell client for RQlite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-rs-notify" = callPackage @@ -136137,8 +127778,6 @@ self: { testHaskellDepends = [ base protolude ]; description = "Experimental! Wraps this awesome rust library so you can use it in haskell. https://docs.rs/crate/notify"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {notifier = null;}; "hs-scrape" = callPackage @@ -136159,8 +127798,6 @@ self: { ]; description = "Simple and easy web scraping and automation in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-server-starter" = callPackage @@ -136192,8 +127829,6 @@ self: { ]; description = "snowtify send your result of `stack build` (`stack test`) to notify-daemon :dog2:"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-speedscope" = callPackage @@ -136212,8 +127847,6 @@ self: { executableHaskellDepends = [ base ]; description = "Convert an eventlog into the speedscope json format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-swisstable-hashtables-class" = callPackage @@ -136243,8 +127876,6 @@ self: { ]; description = "Create tag files (ctags and etags) for Haskell code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-twitter" = callPackage @@ -136262,8 +127893,6 @@ self: { ]; description = "Haskell binding to the Twitter API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-twitterarchiver" = callPackage @@ -136278,8 +127907,6 @@ self: { executableHaskellDepends = [ base HTTP json mtl network pretty ]; description = "Commandline Twitter feed archiver"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-vcard" = callPackage @@ -136291,8 +127918,6 @@ self: { libraryHaskellDepends = [ base old-locale time ]; description = "Implements the RFC 2426 vCard 3.0 spec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-watchman" = callPackage @@ -136312,8 +127937,6 @@ self: { ]; description = "Client library for Facebook's Watchman tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs-zstd" = callPackage @@ -136400,8 +128023,6 @@ self: { ]; description = "Haskell to Brainfuck compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hs2dot" = callPackage @@ -136432,8 +128053,6 @@ self: { testHaskellDepends = [ base hspec template-haskell ]; description = "Translate Haskell types to PureScript"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsConfigure" = callPackage @@ -136458,8 +128077,6 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "I2C access for Haskell and Linux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsPID" = callPackage @@ -136488,8 +128105,6 @@ self: { ]; description = "Sqlite3 bindings"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsXenCtrl" = callPackage @@ -136502,8 +128117,6 @@ self: { librarySystemDepends = [ xenctrl ]; description = "FFI bindings to the Xen Control library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {xenctrl = null;}; "hsakamai" = callPackage @@ -136563,8 +128176,6 @@ self: { ]; description = "OASIS Security Assertion Markup Language (SAML) V2.0"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libxml2;}; "hsass" = callPackage @@ -136605,8 +128216,6 @@ self: { testHaskellDepends = [ base cpython hspec ]; description = "Haskell bindings for PyAutoGUI, a library for automating user interaction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsay" = callPackage @@ -136621,8 +128230,6 @@ self: { executableHaskellDepends = [ base Hclip HTTP process unix ]; description = "(ab)Use Google Translate as a speech synthesiser"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsb2hs" = callPackage @@ -136658,8 +128265,6 @@ self: { ]; description = "simple utility for rolling filesystem backups"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsbc" = callPackage @@ -136673,8 +128278,6 @@ self: { executableHaskellDepends = [ attoparsec base text vector ]; description = "A command line calculator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsbencher" = callPackage @@ -136697,8 +128300,6 @@ self: { ]; description = "Launch and gather data from Haskell and non-Haskell benchmarks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsbencher-codespeed" = callPackage @@ -136717,8 +128318,6 @@ self: { ]; description = "Backend for uploading benchmark data to CodeSpeed"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsbencher-fusion" = callPackage @@ -136742,8 +128341,6 @@ self: { ]; description = "Backend for uploading benchmark data to Google Fusion Tables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc2hs" = callPackage @@ -136784,8 +128381,6 @@ self: { ]; description = "Haskell SuperCollider"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-auditor" = callPackage @@ -136801,8 +128396,6 @@ self: { ]; description = "Haskell SuperCollider Auditor"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-cairo" = callPackage @@ -136815,8 +128408,6 @@ self: { libraryHaskellDepends = [ base cairo gtk hosc hsc3 split ]; description = "haskell supercollider cairo drawing"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-data" = callPackage @@ -136834,8 +128425,6 @@ self: { ]; description = "haskell supercollider data"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-db" = callPackage @@ -136848,8 +128437,6 @@ self: { libraryHaskellDepends = [ base hsc3 safe ]; description = "Haskell SuperCollider Unit Generator Database"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-dot" = callPackage @@ -136862,8 +128449,6 @@ self: { libraryHaskellDepends = [ base directory filepath hsc3 process ]; description = "haskell supercollider graph drawing"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-forth" = callPackage @@ -136883,8 +128468,6 @@ self: { ]; description = "FORTH SUPERCOLLIDER"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-graphs" = callPackage @@ -136909,8 +128492,6 @@ self: { executableHaskellDepends = [ base ]; description = "Haskell SuperCollider Graphs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-lang" = callPackage @@ -136931,8 +128512,6 @@ self: { ]; description = "Haskell SuperCollider Language"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-lisp" = callPackage @@ -136952,8 +128531,6 @@ self: { ]; description = "LISP SUPERCOLLIDER"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-plot" = callPackage @@ -136971,8 +128548,6 @@ self: { ]; description = "Haskell SuperCollider Plotting"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-process" = callPackage @@ -136992,8 +128567,6 @@ self: { ]; description = "Create and control scsynth processes"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-rec" = callPackage @@ -137006,8 +128579,6 @@ self: { libraryHaskellDepends = [ base hsc3 ]; description = "Haskell SuperCollider Record Variants"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-rw" = callPackage @@ -137025,8 +128596,6 @@ self: { ]; description = "hsc3 re-writing"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-server" = callPackage @@ -137053,8 +128622,6 @@ self: { ]; description = "SuperCollider server resource management and synchronization"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-sf" = callPackage @@ -137067,8 +128634,6 @@ self: { libraryHaskellDepends = [ base bytestring hosc ]; description = "Haskell SuperCollider SoundFile"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-sf-hsndfile" = callPackage @@ -137085,8 +128650,6 @@ self: { ]; description = "Haskell SuperCollider SoundFile"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-unsafe" = callPackage @@ -137099,8 +128662,6 @@ self: { libraryHaskellDepends = [ base hsc3 ]; description = "Unsafe Haskell SuperCollider"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsc3-utils" = callPackage @@ -137122,8 +128683,6 @@ self: { ]; description = "Haskell SuperCollider Utilities"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hscaffold" = callPackage @@ -137150,8 +128709,6 @@ self: { ]; description = "Very simple file/directory structure scaffolding writer monad EDSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hscamwire" = callPackage @@ -137166,8 +128723,6 @@ self: { librarySystemDepends = [ camwire_1394 dc1394_control raw1394 ]; description = "Haskell bindings to IIDC1394 cameras, via Camwire"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {camwire_1394 = null; dc1394_control = null; raw1394 = null;}; "hscassandra" = callPackage @@ -137184,8 +128739,6 @@ self: { ]; description = "cassandra database interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hscd" = callPackage @@ -137200,8 +128753,6 @@ self: { executableHaskellDepends = [ aeson base bytestring ghc-prim HTTP ]; description = "Command line client and library for SoundCloud.com"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hscharm" = callPackage @@ -137310,8 +128861,6 @@ self: { executableHaskellDepends = [ base cairo glib gtk old-time ]; description = "An elegant analog clock using Haskell, GTK and Cairo"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hscolour" = callPackage @@ -137349,8 +128898,6 @@ self: { ]; description = "cscope like browser for Haskell code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hscrtmpl" = callPackage @@ -137385,8 +128932,6 @@ self: { testHaskellDepends = [ base containers text ]; description = "Collision-resistant IDs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hscurses" = callPackage @@ -137460,8 +129005,6 @@ self: { ]; description = "Haskell development library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsdif" = callPackage @@ -137474,8 +129017,6 @@ self: { libraryHaskellDepends = [ base bytestring hosc ]; description = "Haskell SDIF"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsdip" = callPackage @@ -137490,8 +129031,6 @@ self: { libraryHaskellDepends = [ base cairo containers HUnit parsec ]; description = "hsdip - a Diplomacy parser/renderer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsdns" = callPackage @@ -137524,8 +129063,6 @@ self: { ]; description = "Caching asynchronous DNS resolver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hse-cpp" = callPackage @@ -137597,8 +129134,6 @@ self: { ]; description = "sendxmpp clone, sending XMPP messages via CLI"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsenv" = callPackage @@ -137619,8 +129154,6 @@ self: { ]; description = "Virtual Haskell Environment builder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hserv" = callPackage @@ -137646,8 +129179,6 @@ self: { testHaskellDepends = [ base HUnit tagged ]; description = "Primitive list with elements of unique types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsexif" = callPackage @@ -137677,8 +129208,6 @@ self: { libraryHaskellDepends = [ base containers language-puppet text ]; description = "A small and ugly library that emulates the output of the puppet facter program"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsfcsh" = callPackage @@ -137694,8 +129223,6 @@ self: { ]; description = "Incremental builder for flash"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsfilt" = callPackage @@ -137709,8 +129236,6 @@ self: { executableHaskellDepends = [ base ghc ]; description = "Z-decoder"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsforce" = callPackage @@ -137734,8 +129259,6 @@ self: { ]; description = "Salesforce API Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsgnutls" = callPackage @@ -137748,8 +129271,6 @@ self: { librarySystemDepends = [ gcrypt gnutls ]; description = "Library wrapping the GnuTLS API"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gcrypt = null; inherit (pkgs) gnutls;}; "hsgnutls-yj" = callPackage @@ -137762,8 +129283,6 @@ self: { librarySystemDepends = [ gcrypt gnutls ]; description = "Library wrapping the GnuTLS API"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gcrypt = null; inherit (pkgs) gnutls;}; "hsgsom" = callPackage @@ -137776,8 +129295,6 @@ self: { libraryHaskellDepends = [ base containers random stm time ]; description = "An implementation of the GSOM clustering algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsgtd" = callPackage @@ -137868,8 +129385,6 @@ self: { doHaddock = false; description = "Extend the import list of a Haskell source file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsini" = callPackage @@ -137911,8 +129426,6 @@ self: { ]; description = "Inspect Haskell source files"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsinspect-lsp" = callPackage @@ -137943,8 +129456,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "LSP interface over the hsinspect binary"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsinstall" = callPackage @@ -137976,8 +129487,6 @@ self: { libraryHaskellDepends = [ base Cabal ]; description = "Skeleton for new Haskell programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hslackbuilder" = callPackage @@ -137993,8 +129502,6 @@ self: { ]; description = "HSlackBuilder automatically generates slackBuild scripts from a cabal package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hslibsvm" = callPackage @@ -138008,8 +129515,6 @@ self: { librarySystemDepends = [ svm ]; description = "A FFI binding to libsvm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {svm = null;}; "hslinks" = callPackage @@ -138026,8 +129531,6 @@ self: { ]; description = "Resolves links to Haskell identifiers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hslogger" = callPackage @@ -138065,8 +129568,6 @@ self: { ]; description = "Parsing hslogger-produced logs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hslogger-template" = callPackage @@ -138078,8 +129579,6 @@ self: { libraryHaskellDepends = [ base hslogger mtl template-haskell ]; description = "Automatic generation of hslogger functions"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hslogger4j" = callPackage @@ -138118,8 +129617,6 @@ self: { ]; description = "A library to work with, or as, a logstash server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hslua" = callPackage @@ -138263,8 +129760,6 @@ self: { testHaskellDepends = [ aeson base bytestring colour containers ]; description = "HSLuv conversion utility"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsmagick" = callPackage @@ -138288,8 +129783,6 @@ self: { ]; description = "FFI bindings for the GraphicsMagick library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {GraphicsMagick = null; inherit (pkgs) bzip2; freetype2 = null; inherit (pkgs) jasper; inherit (pkgs) lcms; inherit (pkgs) libjpeg; inherit (pkgs) libpng; @@ -138327,8 +129820,6 @@ self: { ]; description = "Tool for generating .dir-locals.el for intero"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsmtpclient" = callPackage @@ -138340,8 +129831,6 @@ self: { libraryHaskellDepends = [ array base directory network old-time ]; description = "Simple SMTP Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsndfile" = callPackage @@ -138398,8 +129887,6 @@ self: { ]; description = "Nock 5K interpreter"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsnoise" = callPackage @@ -138424,8 +129911,6 @@ self: { executableHaskellDepends = [ base network pcap ]; description = "a miniature network sniffer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsnsq" = callPackage @@ -138444,8 +129929,6 @@ self: { ]; description = "Haskell NSQ client"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsntp" = callPackage @@ -138462,8 +129945,6 @@ self: { executableHaskellDepends = [ unix ]; description = "Libraries to use SNTP protocol and small client/server implementations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsoptions" = callPackage @@ -138488,8 +129969,6 @@ self: { ]; description = "Haskell library that supports command-line flag processing"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsoz" = callPackage @@ -138528,8 +130007,6 @@ self: { ]; description = "Iron, Hawk, Oz: Web auth protocols"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsp" = callPackage @@ -138552,8 +130029,6 @@ self: { libraryHaskellDepends = [ base containers harp hsp network ]; description = "Facilitates running Haskell Server Pages web pages as CGI programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsparklines" = callPackage @@ -138586,8 +130061,6 @@ self: { ]; description = "A SPARQL query generator and DSL, and a client to query a SPARQL server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspear" = callPackage @@ -138603,8 +130076,6 @@ self: { ]; description = "Haskell Spear Parser"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec" = callPackage @@ -138768,8 +130239,6 @@ self: { testHaskellDepends = [ aeson-qq base hspec ]; description = "Hspec expectations for JSON Values"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-expectations-lens" = callPackage @@ -138813,8 +130282,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "An hspec expectation that asserts a value matches a pattern"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-expectations-pretty" = callPackage @@ -138830,8 +130297,6 @@ self: { ]; description = "hspec-expectations with pretty printing on failure"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-expectations-pretty-diff" = callPackage @@ -138860,8 +130325,6 @@ self: { testHaskellDepends = [ base hspec-meta ]; description = "An experimental DSL for testing on top of Hspec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-golden" = callPackage @@ -138938,8 +130401,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-hedgehog" = callPackage @@ -138969,8 +130430,6 @@ self: { libraryHaskellDepends = [ base blaze-markup hspec ]; description = "Jenkins-friendly XML formatter for Hspec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-junit-formatter" = callPackage @@ -139069,8 +130528,6 @@ self: { ]; description = "Orphan instances of MonadBase and MonadBaseControl for SpecM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-multicheck" = callPackage @@ -139132,8 +130589,6 @@ self: { ]; description = "Helpers for creating database tests with hspec and pg-transact"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-server" = callPackage @@ -139181,8 +130636,6 @@ self: { ]; description = "Add an hspec test-suite in one command"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-shouldbe" = callPackage @@ -139194,8 +130647,6 @@ self: { libraryHaskellDepends = [ hspec test-shouldbe ]; description = "Convenience wrapper and utilities for hspec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-slow" = callPackage @@ -139254,8 +130705,6 @@ self: { ]; description = "A library for testing with Hspec and the Snap Web Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-stack-rerun" = callPackage @@ -139277,8 +130726,6 @@ self: { sha256 = "008gm0qvhvp6z6a9sq5vpljqb90258apd83rkzy47k3bczy1sgmj"; libraryHaskellDepends = [ base hspec ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-tables" = callPackage @@ -139336,8 +130783,6 @@ self: { testHaskellDepends = [ base hspec test-sandbox ]; description = "Hspec convenience functions for use with test-sandbox"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec-wai" = callPackage @@ -139419,8 +130864,6 @@ self: { ]; description = "Write end2end web application tests using webdriver and hspec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspec2" = callPackage @@ -139434,8 +130877,6 @@ self: { libraryHaskellDepends = [ base hspec hspec-discover ]; description = "Alpha version of Hspec 2.0"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspecVariant" = callPackage @@ -139447,8 +130888,6 @@ self: { libraryHaskellDepends = [ base hspec QuickCheckVariant ]; description = "Spec for testing properties for variant types"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspkcs11" = callPackage @@ -139467,8 +130906,6 @@ self: { ]; description = "Wrapper for PKCS #11 interface"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspr-sh" = callPackage @@ -139495,8 +130932,6 @@ self: { ]; description = "A client library for the spread toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hspresent" = callPackage @@ -139511,8 +130946,6 @@ self: { doHaddock = false; description = "A terminal presentation tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsprocess" = callPackage @@ -139538,8 +130971,6 @@ self: { ]; description = "The Haskell Stream Processor command line utility"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsql" = callPackage @@ -139551,8 +130982,6 @@ self: { libraryHaskellDepends = [ base old-time ]; description = "Database access from Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsql-mysql" = callPackage @@ -139567,8 +130996,6 @@ self: { librarySystemDepends = [ mysqlclient ]; description = "MySQL driver for HSQL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {mysqlclient = null;}; "hsql-odbc" = callPackage @@ -139581,8 +131008,6 @@ self: { librarySystemDepends = [ unixODBC ]; description = "A Haskell Interface to ODBC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) unixODBC;}; "hsql-postgresql" = callPackage @@ -139595,8 +131020,6 @@ self: { librarySystemDepends = [ postgresql ]; description = "A Haskell Interface to PostgreSQL via the PQ library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) postgresql;}; "hsql-sqlite3" = callPackage @@ -139609,8 +131032,6 @@ self: { librarySystemDepends = [ sqlite ]; description = "SQLite3 driver for HSQL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) sqlite;}; "hsqml" = callPackage @@ -139774,8 +131195,6 @@ self: { ]; description = "Access to the Readability API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsrelp" = callPackage @@ -139790,8 +131209,6 @@ self: { ]; description = "RELP (Reliable Event Logging Protocol) server implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsseccomp" = callPackage @@ -139805,8 +131222,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit unix ]; description = "Haskell bindings to libseccomp"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {seccomp = null;}; "hssh" = callPackage @@ -139878,8 +131293,6 @@ self: { ]; description = "SQL parser and type checker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hssqlppp-th" = callPackage @@ -139898,8 +131311,6 @@ self: { ]; description = "hssqlppp extras which need template-haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstar" = callPackage @@ -139922,8 +131333,6 @@ self: { executableToolDepends = [ cpphs ]; description = "Haskell version of tar CLI utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstatistics" = callPackage @@ -139950,8 +131359,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Statistical Computing in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstatsd" = callPackage @@ -139963,8 +131370,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl network text ]; description = "Quick and dirty statsd interface"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstest" = callPackage @@ -139982,8 +131387,6 @@ self: { ]; description = "Runs tests via QuickCheck1 and HUnit; like quickCheck-script but uses GHC api"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstidy" = callPackage @@ -139997,8 +131400,6 @@ self: { executableHaskellDepends = [ base haskell-src-exts ]; description = "Takes haskell source on stdin, parses it, then prettyprints it to stdout"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstorchat" = callPackage @@ -140055,8 +131456,6 @@ self: { testHaskellDepends = [ async base ]; description = "A Tox protocol implementation in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstradeking" = callPackage @@ -140081,8 +131480,6 @@ self: { ]; description = "Tradeking API bindings for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstyle" = callPackage @@ -140100,8 +131497,6 @@ self: { ]; description = "Checks Haskell source code for style compliance"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hstzaar" = callPackage @@ -140122,8 +131517,6 @@ self: { ]; description = "A two player abstract strategy game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsubconvert" = callPackage @@ -140145,8 +131538,6 @@ self: { ]; description = "One-time, faithful conversion of Subversion repositories to Git"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsudoku" = callPackage @@ -140175,8 +131566,6 @@ self: { ]; description = "Sudoku game with a GTK3 interface"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsverilog" = callPackage @@ -140208,8 +131597,6 @@ self: { librarySystemDepends = [ ncurses readline swipl ]; description = "embedding prolog in haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses; inherit (pkgs) readline; swipl = null;}; @@ -140226,8 +131613,6 @@ self: { libraryHaskellDepends = [ base haskell-src-exts mtl utf8-string ]; description = "HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsx-jmacro" = callPackage @@ -140241,8 +131626,6 @@ self: { ]; description = "hsp+jmacro support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsx-xhtml" = callPackage @@ -140254,8 +131637,6 @@ self: { libraryHaskellDepends = [ base hsx mtl ]; description = "XHTML utilities to use together with HSX"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsx2hs" = callPackage @@ -140289,8 +131670,6 @@ self: { libraryHaskellDepends = [ base ]; description = "FFI to syscalls"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsyslog" = callPackage @@ -140322,8 +131701,6 @@ self: { ]; description = "syslog over TCP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsyslog-udp" = callPackage @@ -140352,8 +131729,6 @@ self: { librarySystemDepends = [ com_err zephyr ]; description = "Simple libzephyr bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {com_err = null; zephyr = null;}; "htaglib" = callPackage @@ -140388,8 +131763,6 @@ self: { ]; description = "A Haskell98 parsing tags program similar to ctags"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htar" = callPackage @@ -140407,8 +131780,6 @@ self: { ]; description = "Command-line tar archive utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htaut" = callPackage @@ -140436,8 +131807,6 @@ self: { ]; description = "Beginner friendly graphics library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htestu" = callPackage @@ -140453,8 +131822,6 @@ self: { executableHaskellDepends = [ base ]; description = "A library for testing correctness of pseudo random number generators in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gcc;}; "htiled" = callPackage @@ -140471,8 +131838,6 @@ self: { ]; description = "Import from the Tiled map editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htime" = callPackage @@ -140513,8 +131878,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Heterogenous Set"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "html" = callPackage @@ -140550,8 +131913,6 @@ self: { ]; description = "Determine character encoding of HTML documents/fragments"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "html-conduit" = callPackage @@ -140649,8 +132010,6 @@ self: { libraryHaskellDepends = [ base hxt kure ]; description = "HTML rewrite engine, using KURE"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "html-minimalist" = callPackage @@ -140700,8 +132059,6 @@ self: { libraryHaskellDepends = [ base lens mtl tagsoup transformers ]; description = "Perform traversals of HTML structures using sets of rules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "html-tokenizer" = callPackage @@ -140724,8 +132081,6 @@ self: { ]; description = "An \"attoparsec\"-based HTML tokenizer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "html-truncate" = callPackage @@ -140894,8 +132249,6 @@ self: { libraryHaskellDepends = [ base hmt xml ]; description = "Haskell Music Typesetting"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htsn" = callPackage @@ -140919,8 +132272,6 @@ self: { ]; description = "Parse XML files from The Sports Network feed"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htsn-common" = callPackage @@ -140963,8 +132314,6 @@ self: { ]; description = "Import XML files from The Sports Network into an RDBMS"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htssets" = callPackage @@ -140976,8 +132325,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Heterogenous Sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-accept" = callPackage @@ -141054,8 +132401,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring http-types ]; description = "Attoparsec parsers for http-types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-client" = callPackage @@ -141130,8 +132475,6 @@ self: { ]; description = "HTTP authorization (both basic and digest) done right"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-client-conduit" = callPackage @@ -141178,8 +132521,6 @@ self: { ]; description = "Optics for http-client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-client-multipart" = callPackage @@ -141269,8 +132610,6 @@ self: { ]; description = "Convenient monadic HTTP request modifiers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-client-restricted" = callPackage @@ -141302,8 +132641,6 @@ self: { ]; description = "A simple abstraction over the \"http-client\" connection manager"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-client-streams" = callPackage @@ -141320,8 +132657,6 @@ self: { ]; description = "http-client for io-streams supporting openssl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-client-tls" = callPackage @@ -141366,8 +132701,6 @@ self: { ]; description = "Glue code for http-client and websockets"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-common" = callPackage @@ -141439,8 +132772,6 @@ self: { ]; description = "Browser interface to the http-conduit package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-conduit-downloader" = callPackage @@ -141458,8 +132789,6 @@ self: { ]; description = "HTTP downloader tailored for web-crawler needs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-date" = callPackage @@ -141494,8 +132823,6 @@ self: { testHaskellDepends = [ base hspec text ]; description = "http directory listing library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-dispatch" = callPackage @@ -141513,8 +132840,6 @@ self: { testHaskellDepends = [ aeson base hspec ]; description = "High level HTTP client for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-download" = callPackage @@ -141582,8 +132907,6 @@ self: { ]; description = "HTTP client package with enumerator interface and HTTPS support. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-grammar" = callPackage @@ -141595,8 +132918,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring ]; description = "Attoparsec-based parsers for the RFC-2616 HTTP grammar rules"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-io-streams" = callPackage @@ -141618,8 +132939,6 @@ self: { ]; description = "HTTP and WebSocket client based on io-streams"; license = "BSD-3-Clause AND GPL-2.0-or-later"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-kinder" = callPackage @@ -141642,8 +132961,6 @@ self: { ]; description = "Generic kinds and types for working with HTTP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-kit" = callPackage @@ -141703,8 +133020,6 @@ self: { ]; description = "Listen to HTTP requests and handle them in arbitrary ways"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-media" = callPackage @@ -141762,8 +133077,6 @@ self: { ]; description = "Monad abstraction for HTTP allowing lazy transfer and non-I/O simulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-pony" = callPackage @@ -141780,8 +133093,6 @@ self: { ]; description = "A type unsafe http library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-pony-serve-wai" = callPackage @@ -141801,8 +133112,6 @@ self: { ]; description = "Serve a WAI application with http-pony"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-pony-transformer-case-insensitive" = callPackage @@ -141873,8 +133182,6 @@ self: { ]; description = "A library for writing HTTP and HTTPS proxies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-query" = callPackage @@ -141906,8 +133213,6 @@ self: { ]; description = "The HTTP query builder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-response-decoder" = callPackage @@ -141927,8 +133232,6 @@ self: { ]; description = "Declarative DSL for parsing an HTTP response"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-reverse-proxy" = callPackage @@ -141973,8 +133276,6 @@ self: { ]; description = "RFC7807 style response messages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-server" = callPackage @@ -141990,8 +133291,6 @@ self: { ]; description = "A library for writing Haskell web servers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-shed" = callPackage @@ -142005,8 +133304,6 @@ self: { libraryHaskellDepends = [ base network ]; description = "A simple websever with an interact style API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http-streams" = callPackage @@ -142105,8 +133402,6 @@ self: { libraryHaskellDepends = [ base failure process transformers ]; description = "Provide a simple HTTP client interface by wrapping the wget command line tool. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http2" = callPackage @@ -142159,8 +133454,6 @@ self: { testHaskellDepends = [ base ]; description = "A native HTTP2 client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http2-client-exe" = callPackage @@ -142180,8 +133473,6 @@ self: { ]; description = "A command-line http2 client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http2-client-grpc" = callPackage @@ -142201,8 +133492,6 @@ self: { testHaskellDepends = [ base ]; description = "Implement gRPC-over-HTTP2 clients"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http2-grpc-proto-lens" = callPackage @@ -142219,8 +133508,6 @@ self: { ]; description = "Encoders based on `proto-lens` for gRPC over HTTP2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http2-grpc-proto3-wire" = callPackage @@ -142239,8 +133526,6 @@ self: { ]; description = "Encoders based on `proto3-wire` for gRPC over HTTP2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "http2-grpc-types" = callPackage @@ -142291,8 +133576,6 @@ self: { ]; description = "High-level access to HTTPS Everywhere rulesets"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "https-everywhere-rules-raw" = callPackage @@ -142307,8 +133590,6 @@ self: { ]; description = "Low-level (i.e. XML) access to HTTPS Everywhere rulesets."; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "httpspec" = callPackage @@ -142326,8 +133607,6 @@ self: { ]; description = "Specification of HTTP request/response generators and parsers"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htune" = callPackage @@ -142341,8 +133620,6 @@ self: { executableHaskellDepends = [ alsa-pcm base carray fft gloss ]; description = "harmonic analyser and tuner for musical instruments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "htvm" = callPackage @@ -142370,8 +133647,6 @@ self: { testSystemDepends = [ tvm_runtime ]; description = "Bindings for TVM machine learning framework"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {tvm_runtime = null;}; "htzaar" = callPackage @@ -142385,8 +133660,6 @@ self: { executableHaskellDepends = [ base OpenGL random SDL ]; description = "A two player abstract strategy game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hub" = callPackage @@ -142462,8 +133735,6 @@ self: { ]; description = "huck"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "huckleberry" = callPackage @@ -142495,8 +133766,6 @@ self: { executableHaskellDepends = [ base ]; description = "A fast-foward-based planner"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "huffman" = callPackage @@ -142508,8 +133777,6 @@ self: { libraryHaskellDepends = [ base containers fingertree ]; description = "Pure Haskell implementation of the Huffman encoding algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hugs2yc" = callPackage @@ -142526,8 +133793,6 @@ self: { ]; description = "Hugs Front-end to Yhc Core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hulk" = callPackage @@ -142554,8 +133819,6 @@ self: { ]; description = "IRC server written in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hum" = callPackage @@ -142600,8 +133863,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "A lawless typeclass for parsing text entered by humans"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "human-readable-duration" = callPackage @@ -142626,8 +133887,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "A lawless typeclass for converting values to human-friendly text"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "humble-prelude" = callPackage @@ -142639,8 +133898,6 @@ self: { libraryHaskellDepends = [ base bytestring deepseq ghc text ]; description = "Redefinition-free prelude alternative"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hums" = callPackage @@ -142665,8 +133922,6 @@ self: { ]; description = "Haskell UPnP Media Server"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hunch" = callPackage @@ -142689,8 +133944,6 @@ self: { ]; description = "CSS-like syntax for file system manipulation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hunit-dejafu" = callPackage @@ -142717,8 +133970,6 @@ self: { executableHaskellDepends = [ base cairo gtk haskell98 HUnit ]; description = "A GUI testrunner for HUnit"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hunit-parsec" = callPackage @@ -142742,8 +133993,6 @@ self: { testHaskellDepends = [ base hspec HUnit rematch ]; description = "HUnit support for rematch"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hunp" = callPackage @@ -142762,8 +134011,6 @@ self: { ]; description = "Unpacker tool with DWIM"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hunspell-hs" = callPackage @@ -142780,8 +134027,6 @@ self: { benchmarkPkgconfigDepends = [ hunspell ]; description = "Hunspell thread-safe FFI bindings for spell checking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) hunspell;}; "hunt-searchengine" = callPackage @@ -142813,8 +134058,6 @@ self: { ]; description = "A search and indexing engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hunt-server" = callPackage @@ -142838,8 +134081,6 @@ self: { ]; description = "A search and indexing engine server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hunt-server-cli" = callPackage @@ -142893,8 +134134,6 @@ self: { ]; description = "Upload packages or documentation to a hackage server"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hurdle" = callPackage @@ -142910,8 +134149,6 @@ self: { ]; description = "Extract function names from Windows DLLs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hurl" = callPackage @@ -142936,8 +134173,6 @@ self: { executableHaskellDepends = [ base directory network-uri ]; description = "Haskell URL resolver"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hurriyet" = callPackage @@ -142956,8 +134191,6 @@ self: { ]; description = "Haskell bindings for Hurriyet API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "husk-scheme" = callPackage @@ -142982,8 +134215,6 @@ self: { ]; description = "R5RS Scheme interpreter, compiler, and library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "husk-scheme-libs" = callPackage @@ -142999,8 +134230,6 @@ self: { ]; description = "Extra libraries for the husk Scheme platform"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "husky" = callPackage @@ -143018,8 +134247,6 @@ self: { ]; description = "A simple command line calculator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hutton" = callPackage @@ -143040,8 +134267,6 @@ self: { ]; description = "A program for the button on Reddit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "huttons-razor" = callPackage @@ -143055,8 +134280,6 @@ self: { executableHaskellDepends = [ base parsec parsec-numbers ]; description = "Quick implemention of Hutton's Razor"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "huzzy" = callPackage @@ -143068,8 +134291,6 @@ self: { libraryHaskellDepends = [ base easyplot ]; description = "Fuzzy logic library with support for T1, IT2, GT2"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hvect" = callPackage @@ -143158,8 +134379,6 @@ self: { ]; description = "Demo library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-aws-sqs-conduit" = callPackage @@ -143176,8 +134395,6 @@ self: { testHaskellDepends = [ base ]; description = "AWS SQS conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-balancedparens" = callPackage @@ -143262,8 +134479,6 @@ self: { doHaddock = false; description = "CI Assistant for Haskell projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-conduit" = callPackage @@ -143364,8 +134579,6 @@ self: { ]; description = "Unbelievably fast streaming DSV file parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-dump" = callPackage @@ -143641,8 +134854,6 @@ self: { doHaddock = false; description = "Memory efficient JSON parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-json-lens" = callPackage @@ -143672,8 +134883,6 @@ self: { ]; description = "Lens for hw-json"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-json-simd" = callPackage @@ -143700,8 +134909,6 @@ self: { testToolDepends = [ doctest-discover ]; description = "SIMD-based JSON semi-indexer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-json-simple-cursor" = callPackage @@ -143739,8 +134946,6 @@ self: { ]; description = "Memory efficient JSON parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-json-standard-cursor" = callPackage @@ -143780,8 +134985,6 @@ self: { ]; description = "Memory efficient JSON parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-kafka-avro" = callPackage @@ -143808,8 +135011,6 @@ self: { ]; description = "Avro support for Kafka infrastructure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-kafka-client" = callPackage @@ -144002,8 +135203,6 @@ self: { benchmarkHaskellDepends = [ base criterion vector ]; description = "Primitive support for bit manipulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-rankselect" = callPackage @@ -144105,8 +135304,6 @@ self: { ]; description = "SIMD library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-simd-cli" = callPackage @@ -144135,8 +135332,6 @@ self: { testToolDepends = [ doctest-discover ]; description = "SIMD library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-streams" = callPackage @@ -144252,8 +135447,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Supports IO on URIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hw-vector" = callPackage @@ -144329,8 +135522,6 @@ self: { ]; description = "Initial version of firewall Authentication for IITK network"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hweblib" = callPackage @@ -144353,8 +135544,6 @@ self: { ]; description = "Haskell Web Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hwhile" = callPackage @@ -144375,8 +135564,6 @@ self: { testHaskellDepends = [ array base Cabal containers mtl ]; description = "An implementation of Neil D. Jones' While language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hwk" = callPackage @@ -144416,8 +135603,6 @@ self: { ]; description = "A reliable at-least-once job queue built on top of redis"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hworker-ses" = callPackage @@ -144434,8 +135619,6 @@ self: { ]; description = "Library for sending email with Amazon's SES and hworker"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hwormhole" = callPackage @@ -144468,8 +135651,6 @@ self: { ]; description = "magic-wormhole client"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hws" = callPackage @@ -144488,8 +135669,6 @@ self: { ]; description = "Simple Haskell Web Server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hwsl2" = callPackage @@ -144509,8 +135688,6 @@ self: { ]; description = "Hashing with SL2"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hwsl2-bytevector" = callPackage @@ -144522,8 +135699,6 @@ self: { libraryHaskellDepends = [ base bytestring fingertree hwsl2 ]; description = "A hashed byte-vector based on algebraic hashes and finger trees"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hwsl2-reducers" = callPackage @@ -144537,8 +135712,6 @@ self: { ]; description = "Semigroup and Reducer instances for Data.Hash.SL2"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hx" = callPackage @@ -144550,8 +135723,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell extras (missing utility functions)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hxmppc" = callPackage @@ -144570,8 +135741,6 @@ self: { ]; description = "Haskell XMPP (Jabber Client) Command Line Interface (CLI)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hxournal" = callPackage @@ -144598,8 +135767,6 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "A pen notetaking program written in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hxt" = callPackage @@ -144755,8 +135922,6 @@ self: { libraryHaskellDepends = [ base hxt mtl ]; description = "Utility functions for using HXT picklers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hxt-regex-xmlschema" = callPackage @@ -144861,8 +136026,6 @@ self: { libraryHaskellDepends = [ base bytestring encoding hxt mtl ]; description = "Helper functions for HXT"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hxweb" = callPackage @@ -144874,8 +136037,6 @@ self: { libraryHaskellDepends = [ base cgi fastcgi libxml mtl xslt ]; description = "Minimal webframework using fastcgi, libxml2 and libxslt"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyahtzee" = callPackage @@ -144910,8 +136071,6 @@ self: { ]; description = "Literate-style Documentation Generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hybrid" = callPackage @@ -144928,8 +136087,6 @@ self: { ]; description = "A implementation of a type-checker for Lambda-H"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hybrid-vectors" = callPackage @@ -144958,8 +136115,6 @@ self: { testHaskellDepends = [ base ]; description = "Haskell binding to the Sixense SDK for the Razer Hydra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {sixense_x64 = null;}; "hydra-print" = callPackage @@ -144991,8 +136146,6 @@ self: { ]; description = "NCurses interface to view multiple ByteString streams in parallel"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen" = callPackage @@ -145009,8 +136162,6 @@ self: { testHaskellDepends = [ base Cabal containers mtl QuickCheck ]; description = "An alternate Prelude"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-cli" = callPackage @@ -145031,8 +136182,6 @@ self: { ]; description = "Hydrogen Data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-cli-args" = callPackage @@ -145048,8 +136197,6 @@ self: { ]; description = "Hydrogen Command Line Arguments Parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-data" = callPackage @@ -145061,8 +136208,6 @@ self: { libraryHaskellDepends = [ base hydrogen-parsing hydrogen-prelude ]; description = "Hydrogen Data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-multimap" = callPackage @@ -145074,8 +136219,6 @@ self: { libraryHaskellDepends = [ base containers ghc-prim ]; description = "Hydrogen Multimap"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-parsing" = callPackage @@ -145089,8 +136232,6 @@ self: { ]; description = "Hydrogen Parsing Utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-prelude" = callPackage @@ -145110,8 +136251,6 @@ self: { ]; description = "Hydrogen Prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-prelude-parsec" = callPackage @@ -145123,8 +136262,6 @@ self: { libraryHaskellDepends = [ base hydrogen-prelude parsec ]; description = "Hydrogen Prelude /w Parsec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-syntax" = callPackage @@ -145141,8 +136278,6 @@ self: { ]; description = "Hydrogen Syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-util" = callPackage @@ -145157,8 +136292,6 @@ self: { ]; description = "Hydrogen Tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hydrogen-version" = callPackage @@ -145187,8 +136320,6 @@ self: { ]; description = "Simple web application server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hylide" = callPackage @@ -145210,8 +136341,6 @@ self: { ]; description = "WebGL live-coding environment for writing shaders with Hylogen"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hylogen" = callPackage @@ -145238,8 +136367,6 @@ self: { ]; description = "Tools for hybrid logics related programs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hylotab" = callPackage @@ -145254,8 +136381,6 @@ self: { executableHaskellDepends = [ base hylolib mtl ]; description = "Tableau based theorem prover for hybrid logics"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyloutils" = callPackage @@ -145271,8 +136396,6 @@ self: { ]; description = "Very small programs for hybrid logics"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyper" = callPackage @@ -145336,8 +136459,6 @@ self: { ]; description = "a fast, trustworthy HTTP(s) server built"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyperfunctions" = callPackage @@ -145353,8 +136474,6 @@ self: { ]; description = "Hyperfunctions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyperion" = callPackage @@ -145382,8 +136501,6 @@ self: { ]; description = "Reliable performance measurement with robust data export"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyperloglog" = callPackage @@ -145418,8 +136535,6 @@ self: { testHaskellDepends = [ base HUnit semigroups tasty tasty-hunit ]; description = "Approximate cardinality estimation using constant space"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyperpublic" = callPackage @@ -145435,8 +136550,6 @@ self: { ]; description = "A thin wrapper for the Hyperpublic API"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyphenate" = callPackage @@ -145493,8 +136606,6 @@ self: { ]; description = "A Haskell neo4j client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hyraxAbif" = callPackage @@ -145601,8 +136712,6 @@ self: { testSystemDepends = [ zookeeper_mt ]; description = "Haskell client library for Apache Zookeeper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zookeeper_mt;}; "hzulip" = callPackage @@ -145627,8 +136736,6 @@ self: { ]; description = "A haskell wrapper for the Zulip API"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "i18n" = callPackage @@ -145649,8 +136756,6 @@ self: { ]; description = "Internationalization for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "i3blocks-hs-contrib" = callPackage @@ -145687,8 +136792,6 @@ self: { testHaskellDepends = [ aeson base bytestring hspec ]; description = "A type-safe wrapper around i3's IPC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iCalendar" = callPackage @@ -145736,8 +136839,6 @@ self: { ]; description = "A simple wrapper of In-App-Purchase receipt validate APIs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ib-api" = callPackage @@ -145754,8 +136855,6 @@ self: { ]; description = "An API for the Interactive Brokers Trading Workstation written in pure Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iban" = callPackage @@ -145774,8 +136873,6 @@ self: { testHaskellDepends = [ base HUnit tasty tasty-hunit text ]; description = "Validate and generate IBANs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ibus-hs" = callPackage @@ -145808,8 +136905,6 @@ self: { testHaskellDepends = [ base ]; description = "iCalendar format parser and org-mode converter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ice40-prim" = callPackage @@ -145826,8 +136921,6 @@ self: { ]; description = "Lattice iCE40 Primitive IP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "icepeak" = callPackage @@ -145873,8 +136966,6 @@ self: { ]; description = "A fast JSON document store with push notification support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "icfpc2020-galaxy" = callPackage @@ -145924,8 +137015,6 @@ self: { testHaskellDepends = [ base ]; description = "Type safe iconv wrapper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ide-backend" = callPackage @@ -145972,8 +137061,6 @@ self: { ]; description = "An IDE backend library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ide-backend-common" = callPackage @@ -145998,8 +137085,6 @@ self: { ]; description = "Shared library used be ide-backend and ide-backend-server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ide-backend-rts" = callPackage @@ -146034,8 +137119,6 @@ self: { ]; description = "An IDE backend server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ideas" = callPackage @@ -146055,8 +137138,6 @@ self: { ]; description = "Feedback services for intelligent tutoring systems"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ideas-math" = callPackage @@ -146074,8 +137155,6 @@ self: { ]; description = "Interactive domain reasoner for logic and mathematics"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ideas-math-types" = callPackage @@ -146089,8 +137168,6 @@ self: { ]; description = "Common types for mathematical domain reasoners"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ideas-statistics" = callPackage @@ -146106,8 +137183,6 @@ self: { ]; description = "Interactive domain reasoner for statistics"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "idempotent" = callPackage @@ -146120,8 +137195,6 @@ self: { testHaskellDepends = [ base containers hspec QuickCheck ]; description = "Idempotent monoids"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "identicon" = callPackage @@ -146188,8 +137261,6 @@ self: { ]; description = "Numeric identifiers for values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "idiii" = callPackage @@ -146215,8 +137286,6 @@ self: { ]; description = "ID3v2 (tagging standard for MP3 files) library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "idna" = callPackage @@ -146239,8 +137308,6 @@ self: { libraryHaskellDepends = [ base punycode split ]; description = "Converts Unicode hostnames into ASCII"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "idringen" = callPackage @@ -146327,8 +137394,6 @@ self: { libraryHaskellDepends = [ base ]; description = "ieee-utils"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ieee-utils-tempfix" = callPackage @@ -146378,8 +137443,6 @@ self: { testHaskellDepends = [ base bytestring HUnit stocks ]; description = "Library for the IEX Trading API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "if" = callPackage @@ -146405,8 +137468,6 @@ self: { testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; description = "put if statements within type constraints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iff" = callPackage @@ -146455,8 +137516,6 @@ self: { ]; description = "Bindings to Instagram's API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ige" = callPackage @@ -146479,8 +137538,6 @@ self: { ]; description = "An keyboard-driven interactive graph editor"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ige-mac-integration" = callPackage @@ -146499,8 +137556,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Bindings for the Gtk/OS X integration library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {ige-mac-integration = null;}; "ignore" = callPackage @@ -146520,8 +137575,6 @@ self: { testHaskellDepends = [ base HTF text ]; description = "Handle ignore files of different VCSes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "igraph" = callPackage @@ -146539,8 +137592,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to the igraph C library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) igraph;}; "igrf" = callPackage @@ -146775,8 +137826,6 @@ self: { ]; description = "IHaskell display instances for Parsec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ihaskell-plot" = callPackage @@ -146805,8 +137854,6 @@ self: { ]; description = "a rDisp quasiquote to show plots from Rlang-QQ in IHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ihaskell-widgets" = callPackage @@ -146824,8 +137871,6 @@ self: { ]; description = "IPython standard widgets for IHaskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ihs" = callPackage @@ -146857,8 +137902,6 @@ self: { executableHaskellDepends = [ base network ]; description = "Incremental HTTP iteratee"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ilist" = callPackage @@ -146896,8 +137939,6 @@ self: { executableToolDepends = [ alex ]; description = "A fast syntax highlighting library built with alex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "image-type" = callPackage @@ -146966,8 +138007,6 @@ self: { ]; description = "Command-line image paste utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imagesize-conduit" = callPackage @@ -147014,8 +138053,6 @@ self: { ]; description = "An efficient IMAP client library, with SSL and streaming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imapget" = callPackage @@ -147033,8 +138070,6 @@ self: { ]; description = "Downloads email from imap SSL servers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imbib" = callPackage @@ -147056,8 +138091,6 @@ self: { ]; description = "Minimalistic reference manager"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imgur" = callPackage @@ -147073,8 +138106,6 @@ self: { ]; description = "A function to post an image to imgur"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imgurder" = callPackage @@ -147095,8 +138126,6 @@ self: { ]; description = "Uploader for Imgur"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imj-animation" = callPackage @@ -147109,8 +138138,6 @@ self: { testHaskellDepends = [ base ]; description = "Animation Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imj-base" = callPackage @@ -147135,8 +138162,6 @@ self: { ]; description = "Game engine with geometry, easing, animated text, delta rendering"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imj-game-hamazed" = callPackage @@ -147157,8 +138182,6 @@ self: { testHaskellDepends = [ base imj-base mtl text ]; description = "A game with flying numbers and 8-bit color animations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imj-measure-stdout" = callPackage @@ -147174,8 +138197,6 @@ self: { ]; description = "An application to determine the maximum capacity of stdout buffer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imj-prelude" = callPackage @@ -147187,8 +138208,6 @@ self: { libraryHaskellDepends = [ base mtl text ]; description = "Prelude library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imm" = callPackage @@ -147227,8 +138246,6 @@ self: { ]; description = "Execute arbitrary actions for each item from RSS/Atom feeds"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "immortal_0_2_2_1" = callPackage @@ -147290,8 +138307,6 @@ self: { ]; description = "Create worker threads that logs exceptions and restarts"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imparse" = callPackage @@ -147315,8 +138330,6 @@ self: { ]; description = "Multi-platform parser analyzer and generator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imperative-edsl" = callPackage @@ -147342,8 +138355,6 @@ self: { ]; description = "Deep embedding of imperative programs with code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imperative-edsl-vhdl" = callPackage @@ -147360,8 +138371,6 @@ self: { ]; description = "Deep embedding of VHDL programs with code generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "impl" = callPackage @@ -147374,8 +138383,6 @@ self: { doHaddock = false; description = "Framework for defaulting superclasses"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "implicit" = callPackage @@ -147465,8 +138472,6 @@ self: { libraryHaskellDepends = [ base mtl time transformers ]; description = "A logging framework built around implicit parameters"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "implicit-params" = callPackage @@ -147478,8 +138483,6 @@ self: { libraryHaskellDepends = [ base data-default-class ]; description = "Named and unnamed implicit parameters with defaults"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "importify" = callPackage @@ -147512,8 +138515,6 @@ self: { ]; description = "Tool for haskell imports refactoring"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imports" = callPackage @@ -147526,8 +138527,6 @@ self: { testHaskellDepends = [ base directory filepath mtl ]; description = "Generate code for importing directories automatically"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "impossible" = callPackage @@ -147539,8 +138538,6 @@ self: { libraryHaskellDepends = [ base lens ]; description = "Set of data and type definitions of impossible types. Impossible types are useful when declaring type classes / type families instances that should not be expanded by GHC until a specific type is provided in order to keep the types nice and readable."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "imprevu" = callPackage @@ -147598,8 +138595,6 @@ self: { testHaskellDepends = [ base binary constraints hspec ]; description = "Serialization of arbitrary Haskell expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "improve" = callPackage @@ -147611,8 +138606,6 @@ self: { libraryHaskellDepends = [ base mtl yices ]; description = "An imperative, verifiable programming language for high assurance applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "impure-containers" = callPackage @@ -147721,8 +138714,6 @@ self: { ]; description = "A type-checker for Haskell with integer constraints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inchworm" = callPackage @@ -147734,8 +138725,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Simple parser combinators for lexical analysis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "include-file" = callPackage @@ -147790,8 +138779,6 @@ self: { benchmarkHaskellDepends = [ base containers deepseq QuickCheck ]; description = "Incremental computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "incremental-maps" = callPackage @@ -147815,8 +138802,6 @@ self: { ]; description = "Package for doing incremental computations on maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "incremental-parser" = callPackage @@ -147870,8 +138855,6 @@ self: { ]; description = "type classes for incremental updates to data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indent" = callPackage @@ -147902,8 +138885,6 @@ self: { ]; description = "Indentation sensitive parsing combinators for Parsec and Trifecta"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indentation-core" = callPackage @@ -147915,8 +138896,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Indentation sensitive parsing combinators core library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indentation-parsec" = callPackage @@ -147931,8 +138910,6 @@ self: { testHaskellDepends = [ base parsec tasty tasty-hunit ]; description = "Indentation sensitive parsing combinators for Parsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indentation-trifecta" = callPackage @@ -147949,8 +138926,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit trifecta ]; description = "Indentation sensitive parsing combinators for Trifecta"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indentparser" = callPackage @@ -147978,8 +138953,6 @@ self: { testHaskellDepends = [ base mtl parsec tasty tasty-hunit ]; description = "indentation sensitive parser-combinators for parsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "index-core" = callPackage @@ -147991,8 +138964,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Indexed Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indexation" = callPackage @@ -148014,8 +138985,6 @@ self: { ]; description = "Tools for entity indexation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indexed" = callPackage @@ -148148,8 +139117,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A series of type families and constraints for \"indexable\" types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indian-language-font-converter" = callPackage @@ -148176,8 +139143,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Multi-dimensional statically bounded indices"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indieweb-algorithms" = callPackage @@ -148203,8 +139168,6 @@ self: { ]; description = "A collection of implementations of IndieWeb algorithms"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "indigo" = callPackage @@ -148254,8 +139217,6 @@ self: { testHaskellDepends = [ array base deepseq QuickCheck text vector ]; description = "Non-contiguous interval data types with potentially infinite ranges"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "infer-license" = callPackage @@ -148291,8 +139252,6 @@ self: { ]; description = "Find the repository from where a given repo was forked"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "infernal" = callPackage @@ -148313,8 +139272,6 @@ self: { ]; description = "The Infernal Machine - An AWS Lambda Custom Runtime for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "infernu" = callPackage @@ -148335,8 +139292,6 @@ self: { executableHaskellDepends = [ base optparse-applicative parsec ]; description = "Type inference and checker for JavaScript (experimental)"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "infinite-search" = callPackage @@ -148363,8 +139318,6 @@ self: { base binary Cabal filepath ghc irc plugins ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "infix" = callPackage @@ -148376,8 +139329,6 @@ self: { libraryHaskellDepends = [ base containers haskell-src ]; description = "Infix expression re-parsing (for HsParser library)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inflections" = callPackage @@ -148409,8 +139360,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "An infinite list type and operations thereon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "influxdb" = callPackage @@ -148466,8 +139415,6 @@ self: { ]; description = "A yesod subsite serving a wiki"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ini" = callPackage @@ -148498,8 +139445,6 @@ self: { testHaskellDepends = [ base HUnit ini raw-strings-qq text ]; description = "Quasiquoter for INI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inilist" = callPackage @@ -148519,8 +139464,6 @@ self: { ]; description = "Processing for .ini files with duplicate sections and options"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "initialize" = callPackage @@ -148532,8 +139475,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Initialization and Deinitialization of 'Storable' values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inj" = callPackage @@ -148585,8 +139526,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Monadic functions with injected parameters"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inline-asm" = callPackage @@ -148615,8 +139554,6 @@ self: { ]; description = "Inline some Assembly in ur Haskell!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inline-c" = callPackage @@ -148702,8 +139639,6 @@ self: { ]; description = "Java interop via inline Java code in Haskell modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inline-r" = callPackage @@ -148824,8 +139759,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring dlist ]; description = "Stupid simple bytestring templates"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "inspection-proxy" = callPackage @@ -148881,8 +139814,6 @@ self: { testHaskellDepends = [ base ]; description = "Create benchmarks from the HAR files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instana-haskell-trace-sdk" = callPackage @@ -148919,8 +139850,6 @@ self: { ]; description = "SDK for adding custom Instana tracing support to Haskell applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instance-control" = callPackage @@ -148948,8 +139877,6 @@ self: { ]; description = "Template haskell utilities for helping with deserialization etc. of existential types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instant-aeson" = callPackage @@ -148966,8 +139893,6 @@ self: { ]; description = "Generic Aeson instances through instant-generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instant-bytes" = callPackage @@ -148984,8 +139909,6 @@ self: { ]; description = "Generic Serial instances through instant-generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instant-deepseq" = callPackage @@ -148997,8 +139920,6 @@ self: { libraryHaskellDepends = [ base deepseq instant-generics ]; description = "Generic NFData instances through instant-generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instant-generics" = callPackage @@ -149012,8 +139933,6 @@ self: { libraryHaskellDepends = [ base containers syb template-haskell ]; description = "Generic programming library with a sum of products view"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instant-hashable" = callPackage @@ -149025,8 +139944,6 @@ self: { libraryHaskellDepends = [ base hashable instant-generics ]; description = "Generic Hashable instances through instant-generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instant-zipper" = callPackage @@ -149040,8 +139957,6 @@ self: { libraryHaskellDepends = [ base instant-generics mtl ]; description = "Heterogenous Zipper in Instant Generics"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instapaper-sender" = callPackage @@ -149061,8 +139976,6 @@ self: { ]; description = "Basic HTTP gateway to save articles to Instapaper"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instinct" = callPackage @@ -149074,8 +139987,6 @@ self: { libraryHaskellDepends = [ base containers mersenne-random vector ]; description = "Fast artifical neural networks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "instrument" = callPackage @@ -149156,8 +140067,6 @@ self: { ]; description = "A data structure that associates each Int key with a set of values"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "intcode" = callPackage @@ -149172,8 +140081,6 @@ self: { testHaskellDepends = [ base containers doctest primitive ]; description = "Advent of Code 2019 intcode interpreter"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "integer-gmp_1_0_3_0" = callPackage @@ -149214,8 +140121,6 @@ self: { sha256 = "0lrhf6mw90bfph3hbyxv3n7g2n2xnjfq4qnhyhw4ml76k4yybmxa"; description = "A pure-Haskell implementation of arbitrary-precision Integers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "integer-roots" = callPackage @@ -149282,8 +140187,6 @@ self: { ]; description = "Integrate different assays"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "intel-aes" = callPackage @@ -149302,8 +140205,6 @@ self: { librarySystemDepends = [ intel_aes ]; description = "Hardware accelerated AES encryption and Random Number Generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {intel_aes = null;}; "intensional-datatys" = callPackage @@ -149324,8 +140225,6 @@ self: { doHaddock = false; description = "A GHC Core plugin for intensional datatype refinement checking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interact" = callPackage @@ -149438,8 +140337,6 @@ self: { ]; description = "Prelude replacement based on protolude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "intern" = callPackage @@ -149473,8 +140370,6 @@ self: { ]; description = "Shell command for constructing custom stamps for German Post"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "intero" = callPackage @@ -149501,8 +140396,6 @@ self: { ]; description = "Complete interactive development program for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interp" = callPackage @@ -149557,8 +140450,6 @@ self: { ]; description = "GHC preprocessor and library to enable variable interpolation in strings"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interpolate" = callPackage @@ -149608,8 +140499,6 @@ self: { ]; description = "QuasiQuoter for Ruby-style multi-line interpolated strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interpolatedstring-qq-mwotton" = callPackage @@ -149625,8 +140514,6 @@ self: { ]; description = "DO NOT USE THIS. interpolatedstring-qq works now."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interpolatedstring-qq2" = callPackage @@ -149645,8 +140532,6 @@ self: { ]; description = "QuasiQuoter for multi-line interpolated strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interpolation" = callPackage @@ -149716,8 +140601,6 @@ self: { testHaskellDepends = [ base Cabal either transformers ]; description = "Monad transformers that can be run and resumed later, conserving their context"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interspersed" = callPackage @@ -149743,8 +140626,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Intervals with adherences"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "interval-algebra" = callPackage @@ -149819,8 +140700,6 @@ self: { executablePkgconfigDepends = [ ncurses ]; description = "A game of competitive puzzle-design"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses;}; "intrinsic-superclasses" = callPackage @@ -149873,8 +140752,6 @@ self: { doHaddock = false; description = "Intro reexported as Prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "introduction" = callPackage @@ -149895,8 +140772,6 @@ self: { ]; description = "A prelude for safe new projects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "introduction-test" = callPackage @@ -149916,8 +140791,6 @@ self: { ]; description = "A prelude for the tests of safe new projects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "intset" = callPackage @@ -149929,8 +140802,6 @@ self: { libraryHaskellDepends = [ base bits-extras bytestring deepseq ]; description = "Pure, mergeable, succinct Int sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "intset-imperative" = callPackage @@ -150018,8 +140889,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Automatically generate a function's inverse"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "invertible" = callPackage @@ -150070,8 +140939,6 @@ self: { libraryHaskellDepends = [ base HList invertible ]; description = "invertible functions and instances for HList"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "invertible-hxt" = callPackage @@ -150096,8 +140963,6 @@ self: { libraryHaskellDepends = [ base partial-isomorphisms ]; description = "Invertible syntax descriptions for both parsing and pretty printing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "involutive-semigroups" = callPackage @@ -150127,8 +140992,6 @@ self: { ]; description = "Capture IO actions' stdout and stderr"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "io-choice" = callPackage @@ -150148,8 +141011,6 @@ self: { ]; description = "Choice for IO and lifted IO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "io-machine" = callPackage @@ -150201,8 +141062,6 @@ self: { executableHaskellDepends = [ base ]; description = "An API for generating TIMBER style reactive objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "io-region" = callPackage @@ -150331,8 +141190,6 @@ self: { libraryHaskellDepends = [ base network unix ]; description = "Type-safe I/O control package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ion" = callPackage @@ -150353,8 +141210,6 @@ self: { ]; description = "EDSL for concurrent, realtime, embedded programming on top of Ivory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ioref-stable" = callPackage @@ -150377,8 +141232,6 @@ self: { libraryHaskellDepends = [ base bytestring path text ]; description = "A class of strings that can be involved in IO"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iothread" = callPackage @@ -150390,8 +141243,6 @@ self: { libraryHaskellDepends = [ base ]; description = "run IOs in a single thread"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iotransaction" = callPackage @@ -150403,8 +141254,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Supports the automatic undoing of IO operations when an exception is thrown"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ip" = callPackage @@ -150435,8 +141284,6 @@ self: { ]; description = "Library for IP and MAC addresses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ip-quoter" = callPackage @@ -150451,8 +141298,6 @@ self: { testHaskellDepends = [ base cpu network tasty tasty-hunit ]; description = "Quasiquoter for IP addresses"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ip2location" = callPackage @@ -150464,8 +141309,6 @@ self: { libraryHaskellDepends = [ base binary bytestring iproute ]; description = "IP2Location Haskell package for IP geolocation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ip2proxy" = callPackage @@ -150477,8 +141320,6 @@ self: { libraryHaskellDepends = [ base binary bytestring iproute ]; description = "IP2Proxy Haskell package for proxy detection"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ip6addr" = callPackage @@ -150526,8 +141367,6 @@ self: { ]; description = "interactive patch editor"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ipc" = callPackage @@ -150543,8 +141382,6 @@ self: { ]; description = "High level inter-process communication library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ipcvar" = callPackage @@ -150587,8 +141424,6 @@ self: { ]; description = "Access IPFS locally and remotely"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ipfs-api" = callPackage @@ -150604,8 +141439,6 @@ self: { ]; description = "Auto-generated IPFS HTTP API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ipld-cid" = callPackage @@ -150628,7 +141461,6 @@ self: { description = "IPLD Content-IDentifiers "; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ipopt-hs" = callPackage @@ -150650,8 +141482,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "haskell binding to ipopt and nlopt including automatic differentiation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ipopt; inherit (pkgs) nlopt;}; "ipprint" = callPackage @@ -150663,8 +141493,6 @@ self: { libraryHaskellDepends = [ base haskell-src sr-extra ]; description = "Tiny helper for pretty-printing values in ghci console"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iproute" = callPackage @@ -150702,8 +141530,6 @@ self: { executableHaskellDepends = [ base QuickCheck syb ]; description = "iptables rules parser/printer library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iptadmin" = callPackage @@ -150728,8 +141554,6 @@ self: { ]; description = "web-interface for iptables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ipynb" = callPackage @@ -150905,8 +141729,6 @@ self: { ]; description = "A DCC message parsing and helper library for IRC clients"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "irc-fun-bot" = callPackage @@ -150927,8 +141749,6 @@ self: { ]; description = "Library for writing fun IRC bots"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "irc-fun-client" = callPackage @@ -150947,8 +141767,6 @@ self: { ]; description = "Another library for writing IRC clients"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "irc-fun-color" = callPackage @@ -150965,8 +141783,6 @@ self: { testHaskellDepends = [ base text ]; description = "Add color and style decorations to IRC messages"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "irc-fun-messages" = callPackage @@ -150980,8 +141796,6 @@ self: { ]; description = "Types and functions for working with the IRC protocol"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "irc-fun-types" = callPackage @@ -150993,8 +141807,6 @@ self: { libraryHaskellDepends = [ base hashable text ]; description = "Common types for IRC related packages"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ircbot" = callPackage @@ -151063,8 +141875,6 @@ self: { ]; description = "RFC-based resource identifier library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iridium" = callPackage @@ -151092,8 +141902,6 @@ self: { ]; description = "Automated Local Cabal Package Testing and Uploading"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iron-mq" = callPackage @@ -151105,8 +141913,6 @@ self: { libraryHaskellDepends = [ aeson base http-client lens text wreq ]; description = "Iron.IO message queueing client library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ironforge" = callPackage @@ -151129,8 +141935,6 @@ self: { ]; description = "A technical demo for Antisplice"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "irt" = callPackage @@ -151142,8 +141946,6 @@ self: { libraryHaskellDepends = [ ad base data-default-class statistics ]; description = "Item Response Theory functions for use in computerized adaptive testing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "is" = callPackage @@ -151187,8 +141989,6 @@ self: { ]; description = "An executable and library to determine if a file is a DICOM file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "isevaluated" = callPackage @@ -151200,8 +142000,6 @@ self: { libraryHaskellDepends = [ base vacuum ]; description = "Check whether a value has been evaluated"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "isiz" = callPackage @@ -151242,8 +142040,6 @@ self: { ]; description = "Advanced ESMTP library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iso-deriving" = callPackage @@ -151315,8 +142111,6 @@ self: { ]; description = "Types and parser for ISO8601 durations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iso8601-time" = callPackage @@ -151354,8 +142148,6 @@ self: { ]; description = "A parser and generator for the ISO-14496-12/14 base media file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "isobmff-builder" = callPackage @@ -151380,8 +142172,6 @@ self: { ]; description = "A (bytestring-) builder for the ISO-14496-12 base media file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "isohunt" = callPackage @@ -151398,8 +142188,6 @@ self: { ]; description = "Bindings to the isoHunt torrent search API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "isotope" = callPackage @@ -151418,8 +142206,6 @@ self: { ]; description = "Isotopic masses and relative abundances"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ispositive" = callPackage @@ -151444,8 +142230,6 @@ self: { testHaskellDepends = [ base generic-lens QuickCheck ]; description = "Automatically derivable Has instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "itanium-abi" = callPackage @@ -151482,8 +142266,6 @@ self: { ]; description = "Issue Tracker for the CLI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "itemfield" = callPackage @@ -151511,8 +142293,6 @@ self: { ]; description = "A brick Widget for selectable summary of many elements on a terminal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iter-stats" = callPackage @@ -151531,8 +142311,6 @@ self: { ]; description = "iteratees for statistical processing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iterIO" = callPackage @@ -151551,8 +142329,6 @@ self: { librarySystemDepends = [ zlib ]; description = "Iteratee-based IO with pipe operators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zlib;}; "iterable" = callPackage @@ -151596,8 +142372,6 @@ self: { ]; description = "Iteratee-based I/O"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iteratee-compress" = callPackage @@ -151610,8 +142384,6 @@ self: { librarySystemDepends = [ bzip2 zlib ]; description = "Enumeratees for compressing and decompressing streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) bzip2; inherit (pkgs) zlib;}; "iteratee-mtl" = callPackage @@ -151629,8 +142401,6 @@ self: { ]; description = "Iteratee-based I/O"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iteratee-parsec" = callPackage @@ -151646,8 +142416,6 @@ self: { ]; description = "Package allowing parsec parser initeratee"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iteratee-stm" = callPackage @@ -151661,8 +142429,6 @@ self: { ]; description = "Concurrent iteratees using STM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iterio-server" = callPackage @@ -151679,8 +142445,6 @@ self: { ]; description = "Library for building servers with IterIO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iterm-show" = callPackage @@ -151697,8 +142461,6 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Enable graphical display of images inline on some terminals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iterm-show-JuicyPixels" = callPackage @@ -151712,8 +142474,6 @@ self: { libraryHaskellDepends = [ base iterm-show JuicyPixels ]; description = "Orphan Show instances for JuciyPixels image types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iterm-show-diagrams" = callPackage @@ -151731,8 +142491,6 @@ self: { ]; description = "Orphan Show instances for diagrams package that render inline in some terminals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ival" = callPackage @@ -151778,8 +142536,6 @@ self: { ]; description = "Theorem proving library based on dependent type theory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory" = callPackage @@ -151798,8 +142554,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "Safe embedded C programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-artifact" = callPackage @@ -151828,8 +142582,6 @@ self: { ]; description = "Ivory register bindings for the Atmega328p"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-backend-c" = callPackage @@ -151850,8 +142602,6 @@ self: { ]; description = "Ivory C backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-bitdata" = callPackage @@ -151870,8 +142620,6 @@ self: { executableHaskellDepends = [ base ivory ivory-backend-c ]; description = "Ivory bit-data support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-eval" = callPackage @@ -151890,8 +142638,6 @@ self: { ]; description = "Simple concrete evaluator for Ivory programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-examples" = callPackage @@ -151914,8 +142660,6 @@ self: { ]; description = "Ivory examples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-hw" = callPackage @@ -151928,8 +142672,6 @@ self: { libraryHaskellDepends = [ base filepath ivory ivory-artifact ]; description = "Ivory hardware model (STM32F4)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-opts" = callPackage @@ -151946,8 +142688,6 @@ self: { ]; description = "Ivory compiler optimizations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-quickcheck" = callPackage @@ -151969,8 +142709,6 @@ self: { ]; description = "QuickCheck driver for Ivory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-serialize" = callPackage @@ -151987,8 +142725,6 @@ self: { ]; description = "Serialization library for Ivory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivory-stdlib" = callPackage @@ -152001,8 +142737,6 @@ self: { libraryHaskellDepends = [ base filepath ivory ivory-artifact ]; description = "Ivory standard library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ivy-web" = callPackage @@ -152018,8 +142752,6 @@ self: { ]; description = "A lightweight web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iwlib" = callPackage @@ -152078,8 +142810,6 @@ self: { executableHaskellDepends = [ base preprocessor-tools syb ]; description = "A preprocessor for expanding \"ixdo\" notation for indexed monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ixmonad" = callPackage @@ -152093,8 +142823,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Embeds effect systems into Haskell using parameteric effect monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ixset" = callPackage @@ -152186,8 +142914,6 @@ self: { ]; description = "A shallow embedding of the OpenGL Shading Language in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "iyql" = callPackage @@ -152207,8 +142933,6 @@ self: { ]; description = "CLI (command line interface) to YQL"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "j" = callPackage @@ -152223,8 +142947,6 @@ self: { testHaskellDepends = [ base bytestring repa tasty tasty-hunit ]; description = "J in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "j2hs" = callPackage @@ -152245,8 +142967,6 @@ self: { ]; description = "j2hs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ja-base-extra" = callPackage @@ -152291,8 +143011,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "DEPRECATED Bindings to the JACK Audio Connection Kit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libjack2;}; "jackminimix" = callPackage @@ -152304,8 +143022,6 @@ self: { libraryHaskellDepends = [ base hosc ]; description = "control JackMiniMix"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jacobi-roots" = callPackage @@ -152318,8 +143034,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Roots of two shifted Jacobi polynomials (Legendre and Radau) to double precision"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jaeger-flamegraph" = callPackage @@ -152345,8 +143059,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Generate flamegraphs from Jaeger .json dumps."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jail" = callPackage @@ -152362,8 +143074,6 @@ self: { ]; description = "Jailed IO monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jailbreak-cabal" = callPackage @@ -152413,8 +143123,6 @@ self: { ]; description = "Higher level functions for linear algebra. Wraps BLAS and LAPACKE."; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) blas; cblas = null; lapacke = null;}; "jammittools" = callPackage @@ -152480,8 +143188,6 @@ self: { ]; description = "Tool for searching java classes, members and fields in classfiles and JAR archives"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jarify" = callPackage @@ -152503,8 +143209,6 @@ self: { doHaddock = false; description = "Jarification of Haskell sources"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jason" = callPackage @@ -152524,8 +143228,6 @@ self: { testHaskellDepends = [ aeson base bytestring text ]; description = "A fast JASONETTE-iOS JSON combinator library for haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "java-adt" = callPackage @@ -152565,8 +143267,6 @@ self: { ]; description = "Bindings to the JNI and a high level interface generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "java-bridge-extras" = callPackage @@ -152578,8 +143278,6 @@ self: { libraryHaskellDepends = [ base java-bridge transformers ]; description = "Utilities for working with the java-bridge package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "java-character" = callPackage @@ -152591,8 +143289,6 @@ self: { libraryHaskellDepends = [ base diet ]; description = "Functions to simulate Java's Character class"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "java-poker" = callPackage @@ -152618,8 +143314,6 @@ self: { libraryHaskellDepends = [ base containers hx java-bridge ]; description = "Tools for reflecting on Java classes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "javaclass" = callPackage @@ -152662,8 +143356,6 @@ self: { testHaskellDepends = [ aeson base scotty stm text time wai-extra ]; description = "Remote Monad for JavaScript on the browser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "javascript-extras" = callPackage @@ -152704,8 +143396,6 @@ self: { ]; description = "A utility to print the SourceFile attribute of one or more Java class files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "javav" = callPackage @@ -152722,8 +143412,6 @@ self: { ]; description = "A utility to print the target version of Java class files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jbi" = callPackage @@ -152745,8 +143433,6 @@ self: { ]; description = "Just Build It - a \"do what I mean\" abstraction for Haskell build tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jcdecaux-vls" = callPackage @@ -152762,8 +143448,6 @@ self: { ]; description = "JCDecaux self-service bicycles API client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jdi" = callPackage @@ -152782,8 +143466,6 @@ self: { executableHaskellDepends = [ base mtl network ]; description = "Implementation of Java Debug Interface"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jenga" = callPackage @@ -152805,8 +143487,6 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "Generate a cabal freeze file from a stack.yaml"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jenkinsPlugins2nix" = callPackage @@ -152830,8 +143510,6 @@ self: { testHaskellDepends = [ base containers tasty-hspec text ]; description = "Generate nix for Jenkins plugins"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jespresso" = callPackage @@ -152861,8 +143539,6 @@ self: { ]; description = "Extract all JavaScript from an HTML page and consolidate it in one script"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jinquantities" = callPackage @@ -152885,8 +143561,6 @@ self: { ]; description = "Unit conversion and manipulation library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jira-wiki-markup" = callPackage @@ -152928,8 +143602,6 @@ self: { ]; description = "QuasiQuotation library for programmatic generation of Javascript code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jmacro-rpc" = callPackage @@ -152948,8 +143620,6 @@ self: { ]; description = "JSON-RPC clients and servers using JMacro, and evented client-server Reactive Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jmacro-rpc-happstack" = callPackage @@ -152966,8 +143636,6 @@ self: { ]; description = "Happstack backend for jmacro-rpc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jmacro-rpc-snap" = callPackage @@ -152983,8 +143651,6 @@ self: { ]; description = "Snap backend for jmacro-rpc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jml-web-service" = callPackage @@ -153005,8 +143671,6 @@ self: { testHaskellDepends = [ base protolude tasty ]; description = "Common utilities for running a web service"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jmonkey" = callPackage @@ -153019,8 +143683,6 @@ self: { testHaskellDepends = [ base casing free jmacro ]; description = "Jmonkey is very restricted but handy EDSL for JavaScript"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jni" = callPackage @@ -153043,8 +143705,6 @@ self: { testHaskellDepends = [ base hspec singletons ]; description = "Complete JNI raw bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) jdk;}; "jobqueue" = callPackage @@ -153070,8 +143730,6 @@ self: { ]; description = "A job queue library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jobs-ui" = callPackage @@ -153092,8 +143750,6 @@ self: { ]; description = "A library for creating a jobs management website running custom jobs"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "join" = callPackage @@ -153106,8 +143762,6 @@ self: { libraryHaskellDepends = [ base haskell98 multisetrewrite stm ]; description = "Parallel Join Patterns with Guards and Propagation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "join-api" = callPackage @@ -153121,8 +143775,6 @@ self: { ]; description = "Bindings for Join push notifications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "joinlist" = callPackage @@ -153134,8 +143786,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Join list - symmetric list type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "joint" = callPackage @@ -153166,8 +143816,6 @@ self: { ]; description = "An implementation of the Jonathan's Card API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jord" = callPackage @@ -153272,8 +143920,6 @@ self: { ]; description = "Tiny markdown notebook"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jpeg" = callPackage @@ -153285,8 +143931,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A library for decoding JPEG files written in pure Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jps" = callPackage @@ -153348,8 +143992,6 @@ self: { libraryHaskellDepends = [ base wl-pprint ]; description = "Javascript: The Good Parts -- AST & Pretty Printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "js-jquery" = callPackage @@ -153429,8 +144071,6 @@ self: { executableHaskellDepends = [ base jsaddle lens text ]; description = "JSaddle Hello World, an example package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsaddle-warp" = callPackage @@ -153512,8 +144152,6 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsc" = callPackage @@ -153542,8 +144180,6 @@ self: { libraryHaskellDepends = [ base DOM mtl WebBits ]; description = "Javascript Monadic Writer base package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json" = callPackage @@ -153572,8 +144208,6 @@ self: { libraryHaskellDepends = [ aeson base ]; description = "Union 'alternative' or Either that has untagged JSON encoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-api" = callPackage @@ -153634,8 +144268,6 @@ self: { ]; description = "Test that your (Aeson) JSON encoding matches your expectations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-ast" = callPackage @@ -153668,8 +144300,6 @@ self: { ]; description = "Encoders of JSON AST"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-ast-quickcheck" = callPackage @@ -153684,8 +144314,6 @@ self: { ]; description = "Compatibility layer for \"json-ast\" and \"QuickCheck\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-autotype" = callPackage @@ -153720,8 +144348,6 @@ self: { ]; description = "Automatic type declaration for JSON input data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-b" = callPackage @@ -153744,8 +144370,6 @@ self: { ]; description = "JSON parser that uses byte strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-builder" = callPackage @@ -153764,8 +144388,6 @@ self: { ]; description = "Data structure agnostic JSON serialization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-bytes-builder" = callPackage @@ -153820,8 +144442,6 @@ self: { ]; description = "A direct-to-bytes single-pass JSON encoder with a declarative DSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-enumerator" = callPackage @@ -153839,8 +144459,6 @@ self: { ]; description = "Pure-Haskell utilities for dealing with JSON with the enumerator package. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-extra" = callPackage @@ -153857,8 +144475,6 @@ self: { ]; description = "Utility functions to extend Aeson"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-feed" = callPackage @@ -153896,8 +144512,6 @@ self: { ]; description = "Generic JSON serialization / deserialization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-incremental-decoder" = callPackage @@ -153922,8 +144536,6 @@ self: { ]; description = "Incremental JSON parser with early termination and a declarative DSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-litobj" = callPackage @@ -153936,8 +144548,6 @@ self: { testHaskellDepends = [ base hspec json QuickCheck ]; description = "Extends Text.JSON to handle literal JS objects."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-pointer" = callPackage @@ -153982,8 +144592,6 @@ self: { ]; description = "JSON Pointer extensions for Hasql"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-pointy" = callPackage @@ -154008,8 +144616,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "JSON Pointer (RFC 6901) parsing, access, and modification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-python" = callPackage @@ -154026,8 +144632,6 @@ self: { libraryPkgconfigDepends = [ python ]; description = "Call python inline from haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {python = null;}; "json-qq" = callPackage @@ -154067,8 +144671,6 @@ self: { ]; description = "Kitchen sink for querying JSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-rpc" = callPackage @@ -154127,8 +144729,6 @@ self: { ]; description = "JSON-RPC 2.0 on the client side."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-rpc-generic" = callPackage @@ -154198,8 +144798,6 @@ self: { ]; description = "Types and type classes for defining JSON schemas"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-sop" = callPackage @@ -154216,8 +144814,6 @@ self: { ]; description = "Generics JSON (de)serialization using generics-sop"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-state" = callPackage @@ -154281,8 +144877,6 @@ self: { ]; description = "High-performance JSON parser and encoder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-to-haskell" = callPackage @@ -154314,8 +144908,6 @@ self: { recursion-schemes text unordered-containers vector ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-togo" = callPackage @@ -154333,8 +144925,6 @@ self: { ]; description = "Effectful parsing of JSON documents"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-tokens" = callPackage @@ -154362,8 +144952,6 @@ self: { ]; description = "Tokenize JSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-tools" = callPackage @@ -154383,8 +144971,6 @@ self: { ]; description = "A collection of JSON tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-tracer" = callPackage @@ -154408,8 +144994,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A polymorphic, type-safe, json-structured tracing library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json-types" = callPackage @@ -154437,8 +145021,6 @@ self: { ]; description = "Library provides support for JSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json2-hdbc" = callPackage @@ -154454,8 +145036,6 @@ self: { ]; description = "Support JSON for SQL Database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "json2-types" = callPackage @@ -154515,8 +145095,6 @@ self: { ]; description = "Filter select values in JSON objects to unix programs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsonifier" = callPackage @@ -154537,8 +145115,6 @@ self: { ]; description = "Fast and simple JSON encoding toolkit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsonnet" = callPackage @@ -154572,8 +145148,6 @@ self: { ]; description = "Jsonnet implementaton in pure Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsonpath" = callPackage @@ -154610,8 +145184,6 @@ self: { ]; description = "Parser and datatypes for the JSON Resume format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsonrpc-conduit" = callPackage @@ -154633,8 +145205,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "JSON-RPC 2.0 server over a Conduit."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsons-to-schema" = callPackage @@ -154666,8 +145236,6 @@ self: { ]; description = "JSON to JSON Schema"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsonschema-gen" = callPackage @@ -154689,8 +145257,6 @@ self: { ]; description = "JSON Schema generator from Algebraic data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsonsql" = callPackage @@ -154711,8 +145277,6 @@ self: { ]; description = "Interpolate JSON object values into SQL strings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsontsv" = callPackage @@ -154733,8 +145297,6 @@ self: { ]; description = "JSON to TSV transformer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsonxlsx" = callPackage @@ -154755,8 +145317,6 @@ self: { ]; description = "json to xlsx converter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jsop" = callPackage @@ -154796,8 +145356,6 @@ self: { ]; description = "Extract substructures from JSON by following a path"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "juandelacosa" = callPackage @@ -154821,8 +145379,6 @@ self: { ]; description = "Manage users in MariaDB >= 10.1.1"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "judge" = callPackage @@ -154849,8 +145405,6 @@ self: { ]; description = "Tableau-based theorem prover for justification logic"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "judy" = callPackage @@ -154866,8 +145420,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Fast, scalable, mutable dynamic arrays, maps and hashes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {Judy = null;}; "juicy-draw" = callPackage @@ -154989,8 +145541,6 @@ self: { ]; description = "A library for creating and using Jupyter kernels"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "justified-containers" = callPackage @@ -155032,8 +145582,6 @@ self: { ]; description = "Call JVM methods from Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jvm-batching" = callPackage @@ -155060,8 +145608,6 @@ self: { ]; description = "Provides batched marshalling of values between Java and Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jvm-binary" = callPackage @@ -155094,8 +145640,6 @@ self: { ]; description = "A library for reading Java class-files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jvm-parser" = callPackage @@ -155112,8 +145656,6 @@ self: { ]; description = "A parser for JVM bytecode files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jvm-streaming" = callPackage @@ -155140,8 +145682,6 @@ self: { ]; description = "Expose Java iterators as streams from the streaming package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "jwt" = callPackage @@ -155191,8 +145731,6 @@ self: { ]; description = "An implementation of the Kademlia DHT Protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka" = callPackage @@ -155223,8 +145761,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Low-level Haskell client library for Apache Kafka 0.7."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka-client-sync" = callPackage @@ -155239,8 +145775,6 @@ self: { testHaskellDepends = [ base hw-kafka-client monad-parallel text ]; description = "Synchronous Kafka Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka-device" = callPackage @@ -155261,8 +145795,6 @@ self: { ]; description = "UI device events via a Kafka message broker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka-device-glut" = callPackage @@ -155277,8 +145809,6 @@ self: { executableHaskellDepends = [ base GLUT kafka-device OpenGL ]; description = "GLUT events via a Kafka message broker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka-device-joystick" = callPackage @@ -155299,8 +145829,6 @@ self: { ]; description = "Linux joystick events via a Kafka message broker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka-device-leap" = callPackage @@ -155319,8 +145847,6 @@ self: { ]; description = "Leap Motion events via a Kafka message broker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka-device-spacenav" = callPackage @@ -155341,8 +145867,6 @@ self: { ]; description = "Linux SpaceNavigator events via a Kafka message broker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kafka-device-vrpn" = callPackage @@ -155357,8 +145881,6 @@ self: { executableHaskellDepends = [ base kafka-device vrpn ]; description = "VRPN events via a Kafka message broker"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kaleidoscope" = callPackage @@ -155381,8 +145903,6 @@ self: { doHaddock = false; description = "Haskell Kaleidoscope tutorial"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kalman" = callPackage @@ -155402,8 +145922,6 @@ self: { ]; description = "Kalman and particle filters and smoothers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kan-extensions" = callPackage @@ -155433,8 +145951,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Binary parsing with random access"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kanji" = callPackage @@ -155502,8 +146018,6 @@ self: { ]; description = "Kansas Lava is a hardware simulator and VHDL generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kansas-lava-cores" = callPackage @@ -155523,8 +146037,6 @@ self: { ]; description = "FPGA Cores Written in Kansas Lava"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kansas-lava-papilio" = callPackage @@ -155543,8 +146055,6 @@ self: { ]; description = "Kansas Lava support files for the Papilio FPGA board"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kansas-lava-shake" = callPackage @@ -155561,8 +146071,6 @@ self: { ]; description = "Shake rules for building Kansas Lava projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "karakuri" = callPackage @@ -155578,8 +146086,6 @@ self: { ]; description = "Good stateful automata"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "karps" = callPackage @@ -155607,8 +146113,6 @@ self: { ]; description = "Haskell bindings for Spark Dataframes and Datasets"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "karver" = callPackage @@ -155715,8 +146219,6 @@ self: { ]; description = "ElasticSearch scribe for the Katip logging framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "katip-kafka" = callPackage @@ -155730,8 +146232,6 @@ self: { ]; description = "Katip scribe to send logs to Kafka"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "katip-logstash" = callPackage @@ -155790,8 +146290,6 @@ self: { ]; description = "Katip scribe for raven (https://sentry.io)"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "katip-rollbar" = callPackage @@ -155808,8 +146306,6 @@ self: { ]; description = "Katip scribe that logs to Rollbar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "katip-scalyr-scribe" = callPackage @@ -155828,8 +146324,6 @@ self: { ]; description = "A katip scribe for logging to json"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "katip-syslog" = callPackage @@ -155846,8 +146340,6 @@ self: { testHaskellDepends = [ base ]; description = "Syslog Katip Scribe"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "katt" = callPackage @@ -155869,8 +146361,6 @@ self: { testHaskellDepends = [ base bytestring directory mtl ]; description = "Client for the Kattis judge system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "katydid" = callPackage @@ -155904,8 +146394,6 @@ self: { ]; description = "A haskell implementation of Katydid"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kawa" = callPackage @@ -155952,8 +146440,6 @@ self: { ]; description = "Utilities for serving static sites and blogs with Wai/Warp"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kawhi" = callPackage @@ -155976,8 +146462,6 @@ self: { ]; description = "stats.NBA.com library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kazura-queue" = callPackage @@ -156047,8 +146531,6 @@ self: { ]; description = "A simple k-d tree implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kdesrc-build-extra" = callPackage @@ -156067,8 +146549,6 @@ self: { ]; description = "Build profiles for kdesrc-build"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kdesrc-build-profiles" = callPackage @@ -156131,8 +146611,6 @@ self: { ]; description = "cryptographic functions based on the sponge construction"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keenser" = callPackage @@ -156199,8 +146677,6 @@ self: { ]; description = "Rapid Gtk Application Development - I18N"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-mvc-controller" = callPackage @@ -156228,8 +146704,6 @@ self: { ]; description = "Haskell on Gtk rails - Gtk-based global environment for MVC applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-mvc-model-lightmodel" = callPackage @@ -156246,8 +146720,6 @@ self: { ]; description = "Rapid Gtk Application Development - Reactive Protected Light Models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-mvc-model-protectedmodel" = callPackage @@ -156264,8 +146736,6 @@ self: { ]; description = "Rapid Gtk Application Development - Protected Reactive Models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-mvc-solutions-config" = callPackage @@ -156298,8 +146768,6 @@ self: { ]; description = "Haskell on Gtk rails - Common solutions to recurrent problems in Gtk applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-mvc-view" = callPackage @@ -156342,8 +146810,6 @@ self: { ]; description = "Reactive Haskell on Rails - CBMVars as reactive values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactive-fs" = callPackage @@ -156359,8 +146825,6 @@ self: { ]; description = "Haskell on Rails - Files as Reactive Values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactive-gtk" = callPackage @@ -156377,8 +146841,6 @@ self: { ]; description = "Haskell on Gtk rails - Reactive Fields for Gtk widgets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactive-htmldom" = callPackage @@ -156396,8 +146858,6 @@ self: { ]; description = "Keera Hails Reactive bindings for HTML DOM via GHCJS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactive-network" = callPackage @@ -156413,8 +146873,6 @@ self: { ]; description = "Haskell on Rails - Sockets as Reactive Values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactive-polling" = callPackage @@ -156429,8 +146887,6 @@ self: { ]; description = "Haskell on Rails - Polling based Readable RVs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactive-wx" = callPackage @@ -156444,8 +146900,6 @@ self: { ]; description = "Haskell on Rails - Reactive Fields for WX widgets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactive-yampa" = callPackage @@ -156461,8 +146915,6 @@ self: { ]; description = "Haskell on Rails - FRP Yampa Signal Functions as RVs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactivelenses" = callPackage @@ -156474,8 +146926,6 @@ self: { libraryHaskellDepends = [ base keera-hails-reactivevalues lens ]; description = "Reactive Haskell on Rails - Lenses applied to Reactive Values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-hails-reactivevalues" = callPackage @@ -156495,8 +146945,6 @@ self: { testToolDepends = [ cabal-install ]; description = "Haskell on Rails - Reactive Values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keera-posture" = callPackage @@ -156588,8 +147036,6 @@ self: { doHaddock = false; description = "Kempe compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kerry" = callPackage @@ -156612,8 +147058,6 @@ self: { ]; description = "Manage and abstract your packer configurations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kesha" = callPackage @@ -156668,8 +147112,6 @@ self: { ]; description = "Web application deployment manager, focusing on Haskell web frameworks"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kevin" = callPackage @@ -156690,8 +147132,6 @@ self: { ]; description = "a dAmn ↔ IRC proxy"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "key" = callPackage @@ -156778,8 +147218,6 @@ self: { libraryHaskellDepends = [ base containers vector ]; description = "Generic indexing for many data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keylayouts" = callPackage @@ -156804,8 +147242,6 @@ self: { libraryHaskellDepends = [ base udbus ]; description = "Keyring access"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keys" = callPackage @@ -156853,8 +147289,6 @@ self: { ]; description = "back up a secret key securely to the cloud"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keystore" = callPackage @@ -156886,8 +147320,6 @@ self: { ]; description = "Managing stores of secret things"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keyvaluehash" = callPackage @@ -156904,8 +147336,6 @@ self: { ]; description = "Pure Haskell key/value store implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "keyword-args" = callPackage @@ -156927,8 +147357,6 @@ self: { ]; description = "Extract data from a keyword-args config file format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "khph" = callPackage @@ -156948,8 +147376,6 @@ self: { ]; description = "Command-line file tagging and organization tool"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ki" = callPackage @@ -156994,8 +147420,6 @@ self: { ]; description = "Parser and writer for KiCad files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kickass-torrents-dump-parser" = callPackage @@ -157013,8 +147437,6 @@ self: { ]; description = "Parses kat.ph torrent dumps"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kickchan" = callPackage @@ -157033,8 +147455,6 @@ self: { ]; description = "Kick Channels: bounded channels with non-blocking writes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kif-parser" = callPackage @@ -157053,8 +147473,6 @@ self: { ]; description = "Process KIF iOS test logs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kind-apply" = callPackage @@ -157124,8 +147542,6 @@ self: { ]; description = "A dependency manager for Xcode (Objective-C) projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kleene" = callPackage @@ -157147,8 +147563,6 @@ self: { ]; description = "Kleene algebra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kleene-list" = callPackage @@ -157198,8 +147612,6 @@ self: { ]; description = "Sequential and parallel implementations of Lloyd's algorithm"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kmeans-vector" = callPackage @@ -157216,8 +147628,6 @@ self: { benchmarkHaskellDepends = [ base criterion QuickCheck vector ]; description = "An implementation of the kmeans clustering algorithm based on the vector package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kmonad" = callPackage @@ -157237,8 +147647,6 @@ self: { executableHaskellDepends = [ base ]; description = "Advanced keyboard remapping utility"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kmp-dfa" = callPackage @@ -157251,8 +147659,6 @@ self: { testHaskellDepends = [ array base QuickCheck ]; description = "KMP algorithm implementation, based on Deterministic Finite State Automata"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "knead" = callPackage @@ -157274,8 +147680,6 @@ self: { ]; description = "Repa-like array processing using LLVM JIT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "knead-arithmetic" = callPackage @@ -157289,8 +147693,6 @@ self: { ]; description = "Linear algebra and interpolation using LLVM JIT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "knit" = callPackage @@ -157342,8 +147744,6 @@ self: { ]; description = "a minimal Rmarkdown sort-of-thing for haskell, by way of Pandoc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "knob" = callPackage @@ -157373,8 +147773,6 @@ self: { executableHaskellDepends = [ base containers parallel ]; description = "Khovanov homology computations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "koellner-phonetic" = callPackage @@ -157388,8 +147786,6 @@ self: { doHaddock = false; description = "\"map German words to code representing pronunciation\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "koji" = callPackage @@ -157429,8 +147825,6 @@ self: { ]; description = "JSON config file parsing based on unjson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kontrakcja-templates" = callPackage @@ -157500,8 +147894,6 @@ self: { ]; description = "The Korfu ORF Utility"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kparams" = callPackage @@ -157518,8 +147910,6 @@ self: { doHaddock = false; description = "Extracts values from /proc/cmdline"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kqueue" = callPackage @@ -157533,8 +147923,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "A binding to the kqueue event library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kraken" = callPackage @@ -157552,8 +147940,6 @@ self: { ]; description = "Kraken.io API client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "krank" = callPackage @@ -157609,8 +147995,6 @@ self: { ]; description = "Haskell bindings for Spark Dataframes and Datasets"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "krpc" = callPackage @@ -157636,8 +148020,6 @@ self: { ]; description = "KRPC protocol implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ks-test" = callPackage @@ -157649,8 +148031,6 @@ self: { libraryHaskellDepends = [ base gamma random-fu roots vector ]; description = "Kolmogorov distribution and Kolmogorov-Smirnov test"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ksystools" = callPackage @@ -157674,8 +148054,6 @@ self: { libraryPkgconfigDepends = [ egl glew ]; description = "A binding for libktx from Khronos"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {egl = null; inherit (pkgs) glew;}; "ktx-codec" = callPackage @@ -157695,8 +148073,6 @@ self: { ]; description = "Khronos texture format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kubernetes-client" = callPackage @@ -157732,8 +148108,6 @@ self: { ]; description = "Client library for Kubernetes"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kubernetes-client-core" = callPackage @@ -157761,8 +148135,6 @@ self: { ]; description = "Auto-generated kubernetes-client-core API Client"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kubernetes-webhook-haskell" = callPackage @@ -157790,8 +148162,6 @@ self: { libraryHaskellDepends = [ base boxes containers lens ]; description = "A Quantitative Information Flow aware programming language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kure" = callPackage @@ -157803,8 +148173,6 @@ self: { libraryHaskellDepends = [ base dlist transformers ]; description = "Combinators for Strategic Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kure-your-boilerplate" = callPackage @@ -157816,8 +148184,6 @@ self: { libraryHaskellDepends = [ base kure template-haskell ]; description = "Generator for Boilerplate KURE Combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kurita" = callPackage @@ -157850,8 +148216,6 @@ self: { testHaskellDepends = [ base ]; description = "Find the alpha emoji"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "kvitable" = callPackage @@ -157896,8 +148260,6 @@ self: { librarySystemDepends = [ lbfgsb ]; description = "Bindings to L-BFGS-B, Fortran code for limited-memory quasi-Newton bound-constrained optimization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {lbfgsb = null;}; "l10n" = callPackage @@ -157920,8 +148282,6 @@ self: { libraryHaskellDepends = [ base labeled-tree ]; description = "Labeled graph structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "labeled-tree" = callPackage @@ -157967,8 +148327,6 @@ self: { ]; description = "an experiment management framework"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "labsat" = callPackage @@ -157992,8 +148350,6 @@ self: { ]; description = "LabSat TCP Interface Wrapper"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "labyrinth" = callPackage @@ -158015,8 +148371,6 @@ self: { ]; description = "A complicated turn-based game"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "labyrinth-server" = callPackage @@ -158050,8 +148404,6 @@ self: { ]; description = "A complicated turn-based game - Web server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lackey" = callPackage @@ -158064,8 +148416,6 @@ self: { testHaskellDepends = [ base hspec servant servant-foreign text ]; description = "Generate Ruby clients from Servant APIs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lacroix" = callPackage @@ -158097,8 +148447,6 @@ self: { ]; description = "Solve Lagrange multiplier problems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "laika" = callPackage @@ -158118,8 +148466,6 @@ self: { ]; description = "Minimalistic type-checked compile-time template engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambda-ast" = callPackage @@ -158145,8 +148491,6 @@ self: { executableHaskellDepends = [ base ]; description = "A bridge from Haskell (on a CPU) to VHDL on a FPGA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambda-calculator" = callPackage @@ -158166,8 +148510,6 @@ self: { testHaskellDepends = [ base containers hlint hspec HUnit ]; description = "A lambda calculus interpreter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambda-calculus-interpreter" = callPackage @@ -158194,8 +148536,6 @@ self: { libraryHaskellDepends = [ base GLUT mtl OpenGL time ]; description = "Educational drawing canvas for FP explorers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambda-devs" = callPackage @@ -158222,8 +148562,6 @@ self: { ]; description = "a Paralell-DEVS implementaion based on distributed-process"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambda-options" = callPackage @@ -158238,8 +148576,6 @@ self: { ]; description = "Declarative command-line parser with type-driven pattern matching"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambda-placeholders" = callPackage @@ -158280,8 +148616,6 @@ self: { executableHaskellDepends = [ base ]; description = "An application to work with the lambda calculus (for learning)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambda2js" = callPackage @@ -158295,8 +148629,6 @@ self: { executableHaskellDepends = [ base parsec ]; description = "Untyped Lambda calculus to JavaScript compiler"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdaBase" = callPackage @@ -158308,8 +148640,6 @@ self: { libraryHaskellDepends = [ base parsec ]; testHaskellDepends = [ base parsec ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdaFeed" = callPackage @@ -158323,8 +148653,6 @@ self: { executableHaskellDepends = [ base haskell98 html ]; description = "RSS 2.0 feed generator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdaLit" = callPackage @@ -158342,8 +148670,6 @@ self: { ]; description = "..."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdabot" = callPackage @@ -158534,8 +148860,6 @@ self: { ]; description = "Utility libraries for the advanced IRC bot, Lambdabot"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdabot-xmpp" = callPackage @@ -158582,8 +148906,6 @@ self: { testHaskellDepends = [ base hspec HUnit text ]; description = "Lambdabot for Zulip Chat"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacat" = callPackage @@ -158627,8 +148949,6 @@ self: { ]; description = "LambdaCms 'core' subsite for Yesod apps"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacms-media" = callPackage @@ -158645,8 +148965,6 @@ self: { ]; description = "LambdaCms \"media\" extension"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube" = callPackage @@ -158660,8 +148978,6 @@ self: { executableHaskellDepends = [ base editline mtl pretty ]; description = "A simple lambda cube type checker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-bullet" = callPackage @@ -158675,8 +148991,6 @@ self: { ]; description = "Example for combining LambdaCube and Bullet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-compiler" = callPackage @@ -158701,8 +149015,6 @@ self: { ]; description = "LambdaCube 3D is a DSL to program GPUs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-core" = callPackage @@ -158718,8 +149030,6 @@ self: { ]; description = "LambdaCube 3D IR"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-edsl" = callPackage @@ -158736,8 +149046,6 @@ self: { ]; description = "LambdaCube 3D EDSL definition"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-engine" = callPackage @@ -158757,8 +149065,6 @@ self: { ]; description = "3D rendering engine written entirely in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-examples" = callPackage @@ -158775,8 +149081,6 @@ self: { ]; description = "Examples for LambdaCube"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-gl" = callPackage @@ -158795,8 +149099,6 @@ self: { ]; description = "OpenGL 3.3 Core Profile backend for LambdaCube 3D"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-ir" = callPackage @@ -158808,8 +149110,6 @@ self: { libraryHaskellDepends = [ aeson base containers mtl text vector ]; description = "LambdaCube 3D intermediate representation of 3D graphics pipelines"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdacube-samples" = callPackage @@ -158831,8 +149131,6 @@ self: { ]; description = "Samples for LambdaCube 3D"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdatex" = callPackage @@ -158853,8 +149151,6 @@ self: { ]; description = "Type-Safe LaTeX EDSL"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdatwit" = callPackage @@ -158880,8 +149176,6 @@ self: { ]; description = "Lambdabot running as a twitter bot. Similar to the @fsibot f# bot."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdaya-bus" = callPackage @@ -158895,8 +149189,6 @@ self: { ]; description = "Fpga bus core and serialization for RedPitaya"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lambdiff" = callPackage @@ -158914,8 +149206,6 @@ self: { ]; description = "Diff Viewer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lame" = callPackage @@ -158941,8 +149231,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Fairly complete high-level binding to LAME encoder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {mp3lame = null;}; "lame-tester" = callPackage @@ -158959,8 +149247,6 @@ self: { testHaskellDepends = [ bizzlelude containers tasty tasty-hunit ]; description = "A strange and unnecessary selective test-running library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lang" = callPackage @@ -158972,8 +149258,6 @@ self: { libraryHaskellDepends = [ base bytestring http-streams Mapping ]; description = "A Lisp"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-Modula2" = callPackage @@ -159006,8 +149290,6 @@ self: { ]; description = "Parser, pretty-printer, and more for the Modula-2 programming language"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-asn" = callPackage @@ -159026,8 +149308,6 @@ self: { ]; description = "ASN.1 encoding and decoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-asn1" = callPackage @@ -159129,8 +149409,6 @@ self: { ]; description = "Interpreter and language infrastructure for Boogie"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-c" = callPackage @@ -159181,8 +149459,6 @@ self: { libraryToolDepends = [ alex ]; description = "Extracting comments from C code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-c-inline" = callPackage @@ -159199,8 +149475,6 @@ self: { ]; description = "Inline C & Objective-C code in Haskell for language interoperability"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-c-quote" = callPackage @@ -159294,8 +149568,6 @@ self: { ]; description = "Conf parsers and pretty-printers for the Haskell programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-csharp" = callPackage @@ -159310,8 +149582,6 @@ self: { libraryToolDepends = [ alex ]; description = "C# source code manipulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-css" = callPackage @@ -159335,8 +149605,6 @@ self: { testHaskellDepends = [ base hspec raw-strings-qq ]; description = "Manipulating Dart source: abstract syntax and pretty-printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-dickinson" = callPackage @@ -159376,8 +149644,6 @@ self: { doHaddock = false; description = "A language for generative literature"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-docker" = callPackage @@ -159427,8 +149693,6 @@ self: { ]; description = "Dockerfile linter, parser, pretty-printer and embedded DSL"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-dot" = callPackage @@ -159502,8 +149766,6 @@ self: { libraryToolDepends = [ alex ]; description = "Parser and pretty printer for the Eiffel language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-elm" = callPackage @@ -159521,8 +149783,6 @@ self: { testToolDepends = [ doctest ]; description = "Generate elm code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-fortran" = callPackage @@ -159536,8 +149796,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "Fortran lexer and parser, language support, and extensions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-gcl" = callPackage @@ -159549,8 +149807,6 @@ self: { libraryHaskellDepends = [ base bifunctors parsers ]; description = "Something similar to Dijkstra's guarded command language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-gemini" = callPackage @@ -159596,8 +149852,6 @@ self: { libraryHaskellDepends = [ array base parsec utf8-string ]; description = "A library for analysis and synthesis of Go code"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-guess" = callPackage @@ -159610,8 +149864,6 @@ self: { libraryHaskellDepends = [ base bytestring cereal containers ]; description = "Guess at which language a text is written in using trigrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-haskell-extract" = callPackage @@ -159649,8 +149901,6 @@ self: { ]; description = "HCL parsers and pretty-printers for the Haskell programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-java" = callPackage @@ -159687,8 +149937,6 @@ self: { ]; description = "Parser for Java .class files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-javascript" = callPackage @@ -159745,8 +149993,6 @@ self: { ]; description = "Parser and serializer for the Kort information language"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-lua" = callPackage @@ -159787,8 +150033,6 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-lua2" = callPackage @@ -159814,8 +150058,6 @@ self: { ]; description = "Lua parser and pretty printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-mixal" = callPackage @@ -159830,8 +150072,6 @@ self: { executableHaskellDepends = [ base pretty ]; description = "Parser, pretty-printer, and AST types for the MIXAL assembly language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-ninja" = callPackage @@ -159870,8 +150110,6 @@ self: { ]; description = "A library for dealing with the Ninja build language"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-nix" = callPackage @@ -159919,8 +150157,6 @@ self: { ]; description = "Parser, pretty-printer, and more for the Oberon programming language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-objc" = callPackage @@ -159938,8 +150174,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "Analysis and generation of Objective C code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-ocaml" = callPackage @@ -159965,8 +150199,6 @@ self: { ]; description = "Language tools for manipulating OCaml programs in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zlib;}; "language-openscad" = callPackage @@ -159983,8 +150215,6 @@ self: { executableHaskellDepends = [ attoparsec base bytestring ]; description = "A simple parser for OpenSCAD"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-pig" = callPackage @@ -160005,8 +150235,6 @@ self: { ]; description = "Pig parser in haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-protobuf" = callPackage @@ -160060,8 +150288,6 @@ self: { ]; description = "Tools to parse and evaluate the Puppet DSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-python" = callPackage @@ -160093,8 +150319,6 @@ self: { ]; description = "Generate coloured XHTML for Python code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-python-test" = callPackage @@ -160124,8 +150348,6 @@ self: { ]; description = "Utilities for working with the Qux language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-rust" = callPackage @@ -160155,8 +150377,6 @@ self: { ]; description = "Parsing and pretty printing of Rust code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-sally" = callPackage @@ -160185,8 +150405,6 @@ self: { ]; description = "A package for parsing shell scripts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-slice" = callPackage @@ -160225,8 +150443,6 @@ self: { ]; description = "Various tools to detect/correct mistakes in words"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-sqlite" = callPackage @@ -160242,8 +150458,6 @@ self: { ]; description = "Full parser and generator for SQL as implemented by SQLite3"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-sygus" = callPackage @@ -160258,8 +150472,6 @@ self: { testHaskellDepends = [ base deepseq tasty tasty-hunit text ]; description = "A parser and printer for the SyGuS 2.0 language."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-thrift" = callPackage @@ -160282,8 +150494,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Parser and pretty printer for the Thrift IDL format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-tl" = callPackage @@ -160306,8 +150516,6 @@ self: { ]; description = "A Parser for the Type Language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-typescript" = callPackage @@ -160319,8 +150527,6 @@ self: { libraryHaskellDepends = [ base containers parsec pretty ]; description = "A library for working with TypeScript Definition files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-vhdl" = callPackage @@ -160332,8 +150538,6 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "VHDL AST and pretty printer in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "language-webidl" = callPackage @@ -160346,8 +150550,6 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Parser and Pretty Printer for WebIDL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "laop" = callPackage @@ -160392,8 +150594,6 @@ self: { ]; description = "Numerical Linear Algebra using LAPACK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lapack-carray" = callPackage @@ -160410,8 +150610,6 @@ self: { ]; description = "Auto-generated interface to Fortran LAPACK via CArrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lapack-comfort-array" = callPackage @@ -160428,8 +150626,6 @@ self: { ]; description = "Auto-generated interface to Fortran LAPACK via comfort-array"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lapack-ffi" = callPackage @@ -160442,8 +150638,6 @@ self: { libraryPkgconfigDepends = [ liblapack ]; description = "Auto-generated interface to Fortran LAPACK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {liblapack = null;}; "lapack-ffi-tools" = callPackage @@ -160496,8 +150690,6 @@ self: { ]; description = "Efficiently hash (large) Haskell values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "largeword" = callPackage @@ -160534,8 +150726,6 @@ self: { ]; description = "Tool to track security alerts on LWN"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "latest-npm-version" = callPackage @@ -160566,8 +150756,6 @@ self: { ]; description = "Find the latest version of a package on npm"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "latex" = callPackage @@ -160597,8 +150785,6 @@ self: { ]; description = "Use actual LaTeX to render formulae inside Hakyll pages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "latex-formulae-image" = callPackage @@ -160617,8 +150803,6 @@ self: { ]; description = "A library for rendering LaTeX formulae as images using an actual LaTeX installation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "latex-formulae-pandoc" = callPackage @@ -160640,8 +150824,6 @@ self: { ]; description = "Render LaTeX formulae in pandoc documents to images with an actual LaTeX installation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "latex-function-tables" = callPackage @@ -160694,8 +150876,6 @@ self: { ]; description = "Use actual LaTeX to render formulae inside Hakyll pages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "latex-svg-image" = callPackage @@ -160713,8 +150893,6 @@ self: { ]; description = "A library for rendering LaTeX formulae as SVG using an actual LaTeX"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "latex-svg-pandoc" = callPackage @@ -160734,8 +150912,6 @@ self: { executableHaskellDepends = [ base latex-svg-image pandoc-types ]; description = "Render LaTeX formulae in pandoc documents to images with an actual LaTeX"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lattices" = callPackage @@ -160794,8 +150970,6 @@ self: { ]; description = "Server-side SDK for integrating with LaunchDarkly"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "launchpad-control" = callPackage @@ -160813,8 +150987,6 @@ self: { executableHaskellDepends = [ base ]; description = "High and low-level interface to the Novation Launchpad midi controller"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lawful" = callPackage @@ -160847,8 +151019,6 @@ self: { benchmarkHaskellDepends = [ base machines time ]; description = "Concurrent networked stream transducers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lawz" = callPackage @@ -160893,8 +151063,6 @@ self: { ]; description = "Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "layers" = callPackage @@ -160906,8 +151074,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Modular type class machinery for monad transformer stacks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "layers-game" = callPackage @@ -160927,8 +151093,6 @@ self: { ]; description = "A prototypical 2d platform game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "layout" = callPackage @@ -160940,8 +151104,6 @@ self: { libraryHaskellDepends = [ base convertible hinduce-missingh ]; description = "Turn values into pretty text or markup"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "layout-bootstrap" = callPackage @@ -160953,8 +151115,6 @@ self: { libraryHaskellDepends = [ base blaze-html containers text ]; description = "Template and widgets for Bootstrap2 to use with Text.Blaze.Html5"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "layout-rules" = callPackage @@ -160966,8 +151126,6 @@ self: { libraryHaskellDepends = [ alex-tools base text ]; description = "A collection of different layout implementations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "layouting" = callPackage @@ -160983,8 +151141,6 @@ self: { ]; description = "General layouting library. Currently supports layouting 2D areas and can be used as a backend for text pretty printing or automatic windows layouting managers."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazy" = callPackage @@ -161028,8 +151184,6 @@ self: { ]; description = "Identifiers for not-yet-computed values"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazy-hash-cache" = callPackage @@ -161050,8 +151204,6 @@ self: { ]; description = "Storing computed values for re-use when the same program runs again"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazy-io" = callPackage @@ -161076,8 +151228,6 @@ self: { libraryHaskellDepends = [ base bytestring io-streams ]; description = "Get lazy with your io-streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazy-priority-queue" = callPackage @@ -161094,8 +151244,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Lazy-Spined Monadic Priority Queues"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazy-search" = callPackage @@ -161107,8 +151255,6 @@ self: { libraryHaskellDepends = [ base size-based ]; description = "Finds values satisfying a lazy predicate"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazyarray" = callPackage @@ -161120,8 +151266,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Efficient implementation of lazy monolithic arrays (lazy in indexes)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazyboy" = callPackage @@ -161141,8 +151285,6 @@ self: { ]; description = "An EDSL for programming the Game Boy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazyio" = callPackage @@ -161173,8 +151315,6 @@ self: { ]; description = "Set and Map from lazy/infinite lists"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lazysmallcheck" = callPackage @@ -161243,8 +151383,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Data structures for representing arbitrary intervals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lda" = callPackage @@ -161260,8 +151398,6 @@ self: { ]; description = "Online Latent Dirichlet Allocation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ldap-client" = callPackage @@ -161298,8 +151434,6 @@ self: { ]; description = "LDIF idempotent apply tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ldif" = callPackage @@ -161322,8 +151456,6 @@ self: { testHaskellDepends = [ base HUnit ]; description = "The LDAP Data Interchange Format (LDIF) tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "leaf" = callPackage @@ -161342,8 +151474,6 @@ self: { ]; description = "A simple portfolio generator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "leaky" = callPackage @@ -161362,8 +151492,6 @@ self: { ]; description = "Robust space leak, and its strictification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lean" = callPackage @@ -161379,8 +151507,6 @@ self: { ]; description = "Bonds to Lean theorem prover"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lean-peano" = callPackage @@ -161483,8 +151609,6 @@ self: { ]; description = "Use the Leanpub API via Wreq"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "leapseconds" = callPackage @@ -161498,8 +151622,6 @@ self: { libraryHaskellDepends = [ base time ]; testHaskellDepends = [ base tasty tasty-hunit time ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "leapseconds-announced" = callPackage @@ -161523,8 +151645,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Learning Algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "learn-physics" = callPackage @@ -161562,8 +151682,6 @@ self: { ]; description = "examples for learn-physics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "learning-hmm" = callPackage @@ -161598,8 +151716,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion deepseq ]; description = "LEB128 encoding logic for and in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "leb128-cereal" = callPackage @@ -161630,8 +151746,6 @@ self: { executableHaskellDepends = [ base containers ]; description = "Leetify text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "left4deadrl" = callPackage @@ -161666,8 +151780,6 @@ self: { ]; description = "Distributed, stateful, homogeneous microservice framework"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "legion-discovery" = callPackage @@ -161693,8 +151805,6 @@ self: { testHaskellDepends = [ base ]; description = "A discovery service based on Legion"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "legion-discovery-client" = callPackage @@ -161714,8 +151824,6 @@ self: { testHaskellDepends = [ base ]; description = "Client library for communicating with legion-discovery"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "legion-extra" = callPackage @@ -161737,8 +151845,6 @@ self: { testHaskellDepends = [ base ]; description = "Extra non-essential utilities for building legion applications"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "leksah" = callPackage @@ -161814,8 +151920,6 @@ self: { ]; description = "Metadata collection for leksah"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lendingclub" = callPackage @@ -161832,8 +151936,6 @@ self: { ]; description = "Bindings for the LendingClub marketplace API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens" = callPackage @@ -162090,8 +152192,6 @@ self: { ]; description = "Lens interface for your filesystem; still a bit experimental"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-labels" = callPackage @@ -162103,8 +152203,6 @@ self: { libraryHaskellDepends = [ base ghc-prim profunctors tagged ]; description = "Integration of lenses with OverloadedLabels"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-misc" = callPackage @@ -162144,8 +152242,6 @@ self: { ]; description = "Alternate prelude that exports lens combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-process" = callPackage @@ -162163,8 +152259,6 @@ self: { ]; description = "Optics for system processes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-properties" = callPackage @@ -162237,8 +152331,6 @@ self: { ]; description = "simplified import of elementary lens-family combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-sop" = callPackage @@ -162263,8 +152355,6 @@ self: { libraryHaskellDepends = [ base bytestring lens text ]; description = "Isomorphisms and prisms for text <=> bytestring conversions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-th-rewrite" = callPackage @@ -162279,8 +152369,6 @@ self: { executableHaskellDepends = [ base ghc ghc-exactprint lens ]; description = "Rewrites Template Haskell splices using the API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-time" = callPackage @@ -162292,8 +152380,6 @@ self: { libraryHaskellDepends = [ base lens time ]; description = "lens for Data.Time"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-toml-parser" = callPackage @@ -162310,8 +152396,6 @@ self: { ]; description = "Lenses for toml-parser"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-tutorial" = callPackage @@ -162324,8 +152408,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Tutorial for the lens library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-typelevel" = callPackage @@ -162337,8 +152419,6 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Type-level lenses using singletons"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-utils" = callPackage @@ -162355,8 +152435,6 @@ self: { ]; description = "Collection of missing lens utilities"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lens-xml" = callPackage @@ -162394,8 +152472,6 @@ self: { testHaskellDepends = [ base ]; description = "References which can be joined and on which lenses can be applied"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lentil" = callPackage @@ -162422,8 +152498,6 @@ self: { ]; description = "frugal issue tracker"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lenz" = callPackage @@ -162516,8 +152590,6 @@ self: { libraryHaskellDepends = [ base fmlist ]; description = "Non-Determinism Monad for Level-Wise Search"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "leveldb-haskell" = callPackage @@ -162576,8 +152648,6 @@ self: { libraryHaskellDepends = [ base bindings-levmar hmatrix vector ]; description = "An implementation of the Levenberg-Marquardt algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "levmar-chart" = callPackage @@ -162591,8 +152661,6 @@ self: { libraryHaskellDepends = [ base Chart colour data-accessor levmar ]; description = "Plots the results of the Levenberg-Marquardt algorithm in a chart"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lex-applicative" = callPackage @@ -162612,8 +152680,6 @@ self: { benchmarkHaskellDepends = [ base gauge util ]; description = "See README for more info"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lexer-applicative" = callPackage @@ -162642,8 +152708,6 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "L-Fuzzy Set Theory implementation in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lgtk" = callPackage @@ -162671,8 +152735,6 @@ self: { ]; description = "Lens GUI Toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lha" = callPackage @@ -162684,8 +152746,6 @@ self: { libraryHaskellDepends = [ haskell2010 ]; description = "Data structures for the Les Houches Accord"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lhae" = callPackage @@ -162705,8 +152765,6 @@ self: { ]; description = "Simple spreadsheet program"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lhc" = callPackage @@ -162720,8 +152778,6 @@ self: { enableSeparateDataOutput = true; description = "LHC Haskell Compiler"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lhe" = callPackage @@ -162733,8 +152789,6 @@ self: { libraryHaskellDepends = [ bytestring haskell2010 HaXml lha ]; description = "Parser and writer for Les-Houches event files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lhs2TeX-hl" = callPackage @@ -162753,8 +152807,6 @@ self: { ]; description = "Literate highlighter preprocessor for lhs2tex"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lhs2html" = callPackage @@ -162804,8 +152856,6 @@ self: { ]; description = "Tool for using pdflatex with .lhs files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libBF" = callPackage @@ -162837,8 +152887,6 @@ self: { ]; description = "A natural language generator (specifically, an FB-LTAG surface realiser)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libarchive" = callPackage @@ -162869,8 +152917,6 @@ self: { ]; description = "Haskell interface to libarchive"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libarchive;}; "libarchive-conduit" = callPackage @@ -162907,8 +152953,6 @@ self: { testHaskellDepends = [ base doctest doctest-prop lens ]; description = "Haskell bindings to libconfig"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libconfig;}; "libcspm" = callPackage @@ -162929,8 +152973,6 @@ self: { ]; description = "A library providing a parser, type checker and evaluator for CSPM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libexpect" = callPackage @@ -162943,8 +152985,6 @@ self: { librarySystemDepends = [ expect tcl ]; description = "Library for interacting with console applications via pseudoterminals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) expect; inherit (pkgs) tcl;}; "libffi" = callPackage @@ -162994,8 +153034,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion unix ]; description = "A Haskell binding for libfuse-3.x"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fuse3;}; "libgit" = callPackage @@ -163047,8 +153085,6 @@ self: { ]; description = "Backend for text editors to provide better Haskell editing support"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libinfluxdb" = callPackage @@ -163067,8 +153103,6 @@ self: { ]; description = "libinfluxdb"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libiserv_9_0_1" = callPackage @@ -163113,8 +153147,6 @@ self: { ]; description = "Jenkins API interface"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libjwt-typed" = callPackage @@ -163145,8 +153177,6 @@ self: { ]; description = "A Haskell implementation of JSON Web Token (JWT)"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liblastfm" = callPackage @@ -163173,8 +153203,6 @@ self: { ]; description = "Lastfm API interface"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liblawless" = callPackage @@ -163210,8 +153238,6 @@ self: { ]; description = "Prelude based on protolude for GHC 8 and beyond"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liblinear-enumerator" = callPackage @@ -163225,8 +153251,6 @@ self: { ]; description = "liblinear iteratee"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libltdl" = callPackage @@ -163240,8 +153264,6 @@ self: { libraryHaskellDepends = [ base ]; description = "FFI interface to libltdl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libmodbus" = callPackage @@ -163289,8 +153311,6 @@ self: { ]; description = "Prelude based on protolude for GHC 8 and beyond"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libmpd" = callPackage @@ -163332,8 +153352,6 @@ self: { ]; description = "Bindings to the nix package manager"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libnotify" = callPackage @@ -163386,8 +153404,6 @@ self: { testHaskellDepends = [ base ]; description = "Bindings to liboath"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {liboath = null; oath = null;}; "liboleg" = callPackage @@ -163403,8 +153419,6 @@ self: { ]; description = "An evolving collection of Oleg Kiselyov's Haskell modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libpafe" = callPackage @@ -163418,8 +153432,6 @@ self: { testHaskellDepends = [ base bytestring iconv transformers ]; description = "Wrapper for libpafe"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {pafe = null;}; "libpq" = callPackage @@ -163432,8 +153444,6 @@ self: { librarySystemDepends = [ postgresql ]; description = "libpq binding for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) postgresql;}; "libraft" = callPackage @@ -163485,8 +153495,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Raft consensus algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "librandomorg" = callPackage @@ -163498,8 +153506,6 @@ self: { libraryHaskellDepends = [ base bytestring curl ]; description = "Wrapper to Random.org API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "librato" = callPackage @@ -163520,8 +153526,6 @@ self: { ]; description = "Bindings to the Librato API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libravatar" = callPackage @@ -163618,8 +153622,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "FFI bindings to libssh2 SSH2 client library (http://libssh2.org/)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libssh2;}; "libssh2-conduit" = callPackage @@ -163637,8 +153639,6 @@ self: { ]; description = "Conduit wrappers for libssh2 FFI bindings (see libssh2 package)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libstackexchange" = callPackage @@ -163676,8 +153676,6 @@ self: { ]; description = "Haskell bindings for libsystemd-daemon"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {libsystemd-daemon = null; systemd-daemon = null;}; "libsystemd-journal" = callPackage @@ -163714,8 +153712,6 @@ self: { libraryPkgconfigDepends = [ taglib ]; description = "Binding to TagLib C library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) taglib;}; "libtelnet" = callPackage @@ -163782,8 +153778,6 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "Bindings to libxls"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libxml" = callPackage @@ -163814,8 +153808,6 @@ self: { ]; description = "Enumerator-based API for libXML's SAX interface"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "libxml-sax" = callPackage @@ -163841,8 +153833,6 @@ self: { librarySystemDepends = [ xslt ]; description = "Binding to libxslt"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {xslt = null;}; "libyaml" = callPackage @@ -163905,8 +153895,6 @@ self: { executableHaskellDepends = [ base ]; description = "Lie Algebras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "life" = callPackage @@ -163947,8 +153935,6 @@ self: { ]; description = "Synchronize personal configs across multiple machines"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lifetimes" = callPackage @@ -163968,8 +153954,6 @@ self: { ]; description = "Flexible manual resource management"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lift-generics" = callPackage @@ -164080,8 +154064,6 @@ self: { ]; description = "lifted IO operations from the base library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lifted-protolude" = callPackage @@ -164099,8 +154081,6 @@ self: { ]; description = "A sensible set of defaults for writing lifted custom Preludes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lifted-stm" = callPackage @@ -164150,8 +154130,6 @@ self: { ]; description = "A boulderdash-like game and solution validator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ligature" = callPackage @@ -164163,8 +154141,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "Expand ligatures in unicode text"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ligd" = callPackage @@ -164211,8 +154187,6 @@ self: { ]; description = "Haskell client for lightning-viz REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lightstep-haskell" = callPackage @@ -164244,8 +154218,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "LightStep OpenTracing client library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lighttpd-conf" = callPackage @@ -164262,8 +154234,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "Lighttpd configuration file tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lighttpd-conf-qq" = callPackage @@ -164280,8 +154250,6 @@ self: { ]; description = "A QuasiQuoter for lighttpd configuration files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lilypond" = callPackage @@ -164298,8 +154266,6 @@ self: { ]; description = "Bindings to Lilypond"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "limp" = callPackage @@ -164333,8 +154299,6 @@ self: { ]; description = "bindings for integer linear programming solver Coin/CBC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lin-alg" = callPackage @@ -164357,8 +154321,6 @@ self: { libraryHaskellDepends = [ base hmatrix HUnit ]; description = "LINear Discriminant Analysis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linden" = callPackage @@ -164388,8 +154350,6 @@ self: { ]; description = "Zen gardening, based on l-systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lindenmayer" = callPackage @@ -164458,8 +154418,6 @@ self: { ]; description = "Haskell SDK for LINE Messaging API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "line-break" = callPackage @@ -164485,8 +154443,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "raster line drawing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "line-size" = callPackage @@ -164578,8 +154534,6 @@ self: { ]; description = "A linear algebra library with bindings to BLAS and LAPACK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linear-base" = callPackage @@ -164606,8 +154560,6 @@ self: { ]; description = "Standard library for linear types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linear-circuit" = callPackage @@ -164629,8 +154581,6 @@ self: { ]; description = "Compute resistance of linear electrical circuits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linear-code" = callPackage @@ -164656,8 +154606,6 @@ self: { ]; description = "A simple library for linear codes (coding theory, error correction)"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linear-grammar" = callPackage @@ -164684,8 +154632,6 @@ self: { libraryHaskellDepends = [ base containers HUnit ]; description = "Finite maps for linear use"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linear-opengl" = callPackage @@ -164701,8 +154647,6 @@ self: { ]; description = "Isomorphisms between linear and OpenGL types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linear-socket" = callPackage @@ -164741,8 +154685,6 @@ self: { libraryHaskellDepends = [ base random ]; description = "A low-dimensional linear algebra library, operating on the Num typeclass"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linearEqSolver" = callPackage @@ -164776,8 +154718,6 @@ self: { ]; description = "Native, complete, matrix-free linear algebra"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linearscan" = callPackage @@ -164791,8 +154731,6 @@ self: { ]; description = "Linear scan register allocator, formally verified in Coq"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linearscan-hoopl" = callPackage @@ -164813,8 +154751,6 @@ self: { ]; description = "Makes it easy to use the linearscan register allocator with Hoopl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linebreak" = callPackage @@ -164857,8 +154793,6 @@ self: { libraryHaskellDepends = [ base containers mtl safe ]; description = "Lines of Action, 2-player strategy board game"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lingo" = callPackage @@ -164924,8 +154858,6 @@ self: { ]; description = "linkchk is a network interface link ping monitor"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linkcore" = callPackage @@ -164942,8 +154874,6 @@ self: { ]; description = "Combines multiple GHC Core modules into a single module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linked-list-with-iterator" = callPackage @@ -164956,8 +154886,6 @@ self: { testHaskellDepends = [ base ]; description = "A pure linked list which is mutable through iterators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linkedhashmap" = callPackage @@ -164980,8 +154908,6 @@ self: { ]; description = "Persistent LinkedHashMap data structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linklater" = callPackage @@ -165004,8 +154930,6 @@ self: { ]; description = "A Haskell library for the Slack API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linnet" = callPackage @@ -165032,8 +154956,6 @@ self: { ]; description = "Lightweight library for building HTTP API"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linnet-aeson" = callPackage @@ -165051,8 +154973,6 @@ self: { ]; description = "Aeson JSON support for Linnet"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linnet-conduit" = callPackage @@ -165073,8 +154993,6 @@ self: { ]; description = "Conduit-backed support for streaming in Linnet"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linode" = callPackage @@ -165096,8 +155014,6 @@ self: { ]; description = "Bindings to the Linode API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linode-v4" = callPackage @@ -165114,8 +155030,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Haskell wrapper for the Linode v4 API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linux-blkid" = callPackage @@ -165132,8 +155046,6 @@ self: { libraryPkgconfigDepends = [ blkid ]; description = "Linux libblkid"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {blkid = null;}; "linux-capabilities" = callPackage @@ -165156,8 +155068,6 @@ self: { libraryHaskellDepends = [ base filepath ]; description = "Very basic interface to the Linux CGroup Virtual Filesystem"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linux-evdev" = callPackage @@ -165219,8 +155129,6 @@ self: { libraryPkgconfigDepends = [ libkmod ]; description = "Linux kernel modules support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {libkmod = null;}; "linux-mount" = callPackage @@ -165265,8 +155173,6 @@ self: { ]; description = "Read files generated by perf on Linux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linux-ptrace" = callPackage @@ -165284,8 +155190,6 @@ self: { ]; description = "Wrapping of Linux' ptrace(2)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "linux-xattr" = callPackage @@ -165317,8 +155221,6 @@ self: { ]; description = "Implementation of the Enea LINX gateway protocol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lio" = callPackage @@ -165346,8 +155248,6 @@ self: { ]; description = "Labeled IO library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lio-fs" = callPackage @@ -165390,8 +155290,6 @@ self: { ]; description = "LIO support for the Simple web framework"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lion" = callPackage @@ -165409,8 +155307,6 @@ self: { ]; description = "RISC-V Core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lipsum-gen" = callPackage @@ -165422,8 +155318,6 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Generators for random sequences of English-like nonsense text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid" = callPackage @@ -165448,8 +155342,6 @@ self: { benchmarkHaskellDepends = [ aeson attoparsec base criterion text ]; description = "Liquid template language library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-base" = callPackage @@ -165463,8 +155355,6 @@ self: { libraryHaskellDepends = [ base liquid-ghc-prim liquidhaskell ]; description = "Drop-in base replacement for LiquidHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-bytestring" = callPackage @@ -165480,8 +155370,6 @@ self: { libraryHaskellDepends = [ bytestring liquid-base liquidhaskell ]; description = "LiquidHaskell specs for the bytestring package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-containers" = callPackage @@ -165497,8 +155385,6 @@ self: { libraryHaskellDepends = [ containers liquid-base liquidhaskell ]; description = "LiquidHaskell specs for the containers package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-fixpoint" = callPackage @@ -165546,8 +155432,6 @@ self: { libraryHaskellDepends = [ ghc-prim liquidhaskell ]; description = "Drop-in ghc-prim replacement for LiquidHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-parallel" = callPackage @@ -165562,8 +155446,6 @@ self: { libraryHaskellDepends = [ liquid-base liquidhaskell parallel ]; description = "LiquidHaskell specs for the parallel package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-platform" = callPackage @@ -165583,8 +155465,6 @@ self: { ]; description = "A battery-included platform for LiquidHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-prelude" = callPackage @@ -165601,8 +155481,6 @@ self: { ]; description = "General utility modules for LiquidHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquid-vector" = callPackage @@ -165616,8 +155494,6 @@ self: { libraryHaskellDepends = [ liquid-base liquidhaskell vector ]; description = "LiquidHaskell specs for the vector package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquidhaskell" = callPackage @@ -165658,8 +155534,6 @@ self: { testSystemDepends = [ z3 ]; description = "Liquid Types for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) z3;}; "liquidhaskell-cabal" = callPackage @@ -165673,8 +155547,6 @@ self: { libraryHaskellDepends = [ base Cabal directory filepath ]; description = "Liquid Haskell integration for Cabal and Stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liquidhaskell-cabal-demo" = callPackage @@ -165749,8 +155621,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "testing list fusion for success"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-grouping" = callPackage @@ -165773,8 +155643,6 @@ self: { libraryHaskellDepends = [ base ]; description = "List Multiplexing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-predicate" = callPackage @@ -165807,8 +155675,6 @@ self: { ]; description = "A simple list prompt UI for the terminal"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-remote-forwards" = callPackage @@ -165835,8 +155701,6 @@ self: { ]; description = "List all remote forwards for mail accounts stored in a SQL database"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-singleton" = callPackage @@ -165882,8 +155746,6 @@ self: { ]; description = "An \"attoparsec\" adapter for \"list-t\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-t-html-parser" = callPackage @@ -165907,8 +155769,6 @@ self: { ]; description = "Streaming HTML parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-t-http-client" = callPackage @@ -165924,8 +155784,6 @@ self: { ]; description = "A streaming HTTP client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-t-libcurl" = callPackage @@ -165961,8 +155819,6 @@ self: { ]; description = "A streaming text codec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-transformer" = callPackage @@ -166030,8 +155886,6 @@ self: { ]; description = "Witnesses for working with type-level lists"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-zip-def" = callPackage @@ -166043,8 +155897,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Provides zips with default values"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "list-zipper" = callPackage @@ -166067,8 +155919,6 @@ self: { ]; description = "A list zipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "listenbrainz-client" = callPackage @@ -166086,8 +155936,6 @@ self: { ]; description = "A client library to the ListenBrainz project"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "listlike-instances" = callPackage @@ -166099,8 +155947,6 @@ self: { libraryHaskellDepends = [ base bytestring ListLike text vector ]; description = "Extra instances of the ListLike class"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lists" = callPackage @@ -166169,8 +156015,6 @@ self: { ]; description = "Append only key-list database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lit" = callPackage @@ -166190,8 +156034,6 @@ self: { ]; description = "A simple tool for literate programming"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "literals" = callPackage @@ -166203,8 +156045,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Non-overloaded functions for concrete literals"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "little-logger" = callPackage @@ -166224,8 +156064,6 @@ self: { ]; description = "Basic logging based on co-log"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "little-rio" = callPackage @@ -166269,8 +156107,6 @@ self: { ]; description = "Live coding of MIDI music"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "liveplot" = callPackage @@ -166306,8 +156142,6 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ picosat ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) picosat;}; "llrbtree" = callPackage @@ -166339,8 +156173,6 @@ self: { ]; description = "An implementation of the LLSD data system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm" = callPackage @@ -166357,8 +156189,6 @@ self: { ]; description = "Bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-analysis" = callPackage @@ -166386,8 +156216,6 @@ self: { ]; description = "A Haskell library for analyzing LLVM bitcode"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-base" = callPackage @@ -166399,8 +156227,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "FFI bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-base-types" = callPackage @@ -166421,8 +156247,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "The base types for a mostly pure Haskell LLVM analysis library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-base-util" = callPackage @@ -166434,8 +156258,6 @@ self: { libraryHaskellDepends = [ base llvm-base ]; description = "Utilities for bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-data-interop" = callPackage @@ -166456,8 +156278,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "A low-level data interoperability binding for LLVM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-dsl" = callPackage @@ -166475,8 +156295,6 @@ self: { ]; description = "Support for writing an EDSL with LLVM-JIT as target"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-extension" = callPackage @@ -166495,8 +156313,6 @@ self: { ]; description = "Processor specific intrinsics for the llvm interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-extra" = callPackage @@ -166522,8 +156338,6 @@ self: { doHaddock = false; description = "Utility functions for the llvm interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-ffi" = callPackage @@ -166538,8 +156352,6 @@ self: { librarySystemDepends = [ LLVM ]; description = "FFI bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {LLVM = null;}; "llvm-ffi-tools" = callPackage @@ -166557,8 +156369,6 @@ self: { ]; description = "Tools for maintaining the llvm-ffi package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-general" = callPackage @@ -166585,8 +156395,6 @@ self: { ]; description = "General purpose LLVM bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {llvm-config = null;}; "llvm-general-pure" = callPackage @@ -166607,8 +156415,6 @@ self: { ]; description = "Pure Haskell LLVM functionality (no FFI)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-general-quote" = callPackage @@ -166632,8 +156438,6 @@ self: { ]; description = "QuasiQuoting llvm code for llvm-general"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-hs" = callPackage @@ -166715,8 +156519,6 @@ self: { ]; description = "Bindings to the LLVM compiler toolkit with some custom extensions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-pkg-config" = callPackage @@ -166735,8 +156537,6 @@ self: { ]; description = "Generate Pkg-Config configuration file for LLVM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-pretty" = callPackage @@ -166753,8 +156553,6 @@ self: { ]; description = "A pretty printing library inspired by the llvm binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-pretty-bc-parser" = callPackage @@ -166781,8 +156579,6 @@ self: { ]; description = "LLVM bitcode parsing library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-tf" = callPackage @@ -166804,8 +156600,6 @@ self: { doHaddock = false; description = "Bindings to the LLVM compiler toolkit using type families"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "llvm-tools" = callPackage @@ -166833,8 +156627,6 @@ self: { ]; description = "Useful tools built on llvm-analysis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lmdb" = callPackage @@ -166904,8 +156696,6 @@ self: { ]; description = "LMonad is an Information Flow Control (IFC) framework for Haskell applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lmonad-yesod" = callPackage @@ -166926,8 +156716,6 @@ self: { ]; description = "LMonad for Yesod integrates LMonad's IFC with Yesod web applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "load-balancing" = callPackage @@ -166939,8 +156727,6 @@ self: { libraryHaskellDepends = [ base containers hslogger PSQueue stm ]; description = "Client-side load balancing utilities"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "load-env" = callPackage @@ -166973,8 +156759,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "A cross platform library for loading bundled fonts into your application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loadavg" = callPackage @@ -167020,8 +156804,6 @@ self: { libraryHaskellDepends = [ base network ]; description = "Functions to get local interface address"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "local-search" = callPackage @@ -167038,8 +156820,6 @@ self: { ]; description = "Generalised local search within Haskell, for applications in combinatorial optimisation"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "localization" = callPackage @@ -167069,8 +156849,6 @@ self: { ]; description = "GNU Gettext-based messages localization library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "located" = callPackage @@ -167082,8 +156860,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "Source location helpers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "located-base" = callPackage @@ -167108,8 +156884,6 @@ self: { libraryHaskellDepends = [ base monad-logger text ]; description = "Location-aware logging without Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "locators" = callPackage @@ -167142,8 +156916,6 @@ self: { executableHaskellDepends = [ base ]; description = "Support for precise error locations in source files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loch-th" = callPackage @@ -167196,8 +156968,6 @@ self: { ]; description = "Very simple poll lock"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lockfree-queue" = callPackage @@ -167255,8 +157025,6 @@ self: { ]; description = "Structured logging solution with multiple backends"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "log-base" = callPackage @@ -167371,8 +157139,6 @@ self: { ]; description = "Structured logging solution (PostgreSQL back end)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "log-utils" = callPackage @@ -167395,8 +157161,6 @@ self: { ]; description = "Utils for working with logs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "log-warper" = callPackage @@ -167432,8 +157196,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Flexible, configurable, monadic and pretty logging"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "log2json" = callPackage @@ -167447,8 +157209,6 @@ self: { executableHaskellDepends = [ base containers json parsec ]; description = "Turn log file records into JSON"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "log4hs" = callPackage @@ -167479,8 +157239,6 @@ self: { ]; description = "A python logging style log library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logentries" = callPackage @@ -167500,8 +157258,6 @@ self: { ]; description = "Request logger middleware for Logentries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logfloat" = callPackage @@ -167530,8 +157286,6 @@ self: { ]; description = "Fast & extensible logging framework"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logger-thread" = callPackage @@ -167610,8 +157364,6 @@ self: { executableHaskellDepends = [ base ]; description = "Supplemental packages for `logging-effect`"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logging-effect-extra-file" = callPackage @@ -167630,8 +157382,6 @@ self: { executableHaskellDepends = [ base logging-effect prettyprinter ]; description = "TH splices to augment log messages with file info"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logging-effect-extra-handler" = callPackage @@ -167650,8 +157400,6 @@ self: { executableHaskellDepends = [ base logging-effect prettyprinter ]; description = "Handy logging handler combinators"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logging-facade" = callPackage @@ -167745,8 +157493,6 @@ self: { ]; description = "Framework for propositional and first order logic, theorem proving"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logicst" = callPackage @@ -167758,8 +157504,6 @@ self: { libraryHaskellDepends = [ base logict transformers ]; description = "Backtracking mutable references in the ST and IO monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logict" = callPackage @@ -167785,8 +157529,6 @@ self: { libraryHaskellDepends = [ base logict mtl transformers ]; description = "Library for logic programming based on haskell package logict"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loglevel" = callPackage @@ -167811,8 +157553,6 @@ self: { testHaskellDepends = [ base hspec time ]; description = "Parse Heroku application/logplex documents"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "logsink" = callPackage @@ -167865,8 +157605,6 @@ self: { executableHaskellDepends = [ haskell98 ]; description = "Useful utilities for the Lojban language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lojbanParser" = callPackage @@ -167881,8 +157619,6 @@ self: { executableHaskellDepends = [ base ]; description = "lojban parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lojbanXiragan" = callPackage @@ -167897,8 +157633,6 @@ self: { executableHaskellDepends = [ base ]; description = "lojban to xiragan"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lojysamban" = callPackage @@ -167912,8 +157646,6 @@ self: { executableHaskellDepends = [ base lojbanParser yjtools ]; description = "Prolog with lojban"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol" = callPackage @@ -167942,8 +157674,6 @@ self: { testHaskellDepends = [ base test-framework ]; description = "A library for lattice cryptography"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol-apps" = callPackage @@ -167964,8 +157694,6 @@ self: { ]; description = "Lattice-based cryptographic applications using ."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol-benches" = callPackage @@ -167982,8 +157710,6 @@ self: { ]; description = "A library for benchmarking ."; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol-calculus" = callPackage @@ -168005,8 +157731,6 @@ self: { ]; description = "Calculus for LOL (λω language)"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol-cpp" = callPackage @@ -168026,8 +157750,6 @@ self: { benchmarkHaskellDepends = [ base DRBG lol lol-apps MonadRandom ]; description = "A fast C++ backend for ."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol-repa" = callPackage @@ -168047,8 +157769,6 @@ self: { benchmarkHaskellDepends = [ base DRBG lol lol-benches ]; description = "A repa backend for ."; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol-tests" = callPackage @@ -168068,8 +157788,6 @@ self: { testHaskellDepends = [ base lol test-framework ]; description = "A library for testing ."; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lol-typing" = callPackage @@ -168094,8 +157812,6 @@ self: { ]; description = "Type inferencer for LOL (λω language)"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loli" = callPackage @@ -168113,8 +157829,6 @@ self: { ]; description = "A minimum web dev DSL in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "long-double" = callPackage @@ -168137,8 +157851,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Dependently-typed linked list implementation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "longshot" = callPackage @@ -168170,8 +157882,6 @@ self: { ]; description = "Fast Brute-force search using parallelism"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lookup-tables" = callPackage @@ -168186,8 +157896,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Statically generate lookup tables using Template Haskell"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loop" = callPackage @@ -168215,8 +157923,6 @@ self: { libraryHaskellDepends = [ base effin ]; description = "control-monad-loop port for effin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loop-while" = callPackage @@ -168228,8 +157934,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformer supporting various styles of while loop"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loopbreaker" = callPackage @@ -168247,8 +157951,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "inline self-recursive definitions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "looper" = callPackage @@ -168266,8 +157968,6 @@ self: { aeson base hspec optparse-applicative text time unliftio ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loops" = callPackage @@ -168285,8 +157985,6 @@ self: { benchmarkHaskellDepends = [ base criterion transformers vector ]; description = "Fast imperative-style loops"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loopy" = callPackage @@ -168305,8 +158003,6 @@ self: { ]; description = "Find all biological feedback loops within an ecosystem graph"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lord" = callPackage @@ -168347,8 +158043,6 @@ self: { ]; description = "A command line interface to online radios"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lorem" = callPackage @@ -168363,8 +158057,6 @@ self: { executableHaskellDepends = [ base ]; description = "Library for generating filler text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lorentz" = callPackage @@ -168387,8 +158079,6 @@ self: { ]; description = "EDSL for the Michelson Language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "loris" = callPackage @@ -168402,8 +158092,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "interface to Loris API"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {loris = null;}; "loshadka" = callPackage @@ -168422,8 +158110,6 @@ self: { ]; description = "Minecraft 1.7 server proxy that answers to queries when the server is offline"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lostcities" = callPackage @@ -168441,8 +158127,6 @@ self: { ]; description = "An implementation of an adictive two-player card game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "louis" = callPackage @@ -168476,8 +158160,6 @@ self: { executableHaskellDepends = [ base optparse-generic shakers ]; description = "Amazon Simple Workflow Service Wrapper for Work Pools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lowgl" = callPackage @@ -168489,8 +158171,6 @@ self: { libraryHaskellDepends = [ base gl linear vector ]; description = "Basic gl wrapper and reference"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lowlin" = callPackage @@ -168540,8 +158220,6 @@ self: { ]; description = "SVG Backend for lp-diagrams"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lrucache" = callPackage @@ -168602,8 +158280,6 @@ self: { ]; description = "List USB devices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lscabal" = callPackage @@ -168621,8 +158297,6 @@ self: { ]; description = "List exported modules from a set of .cabal files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lsfrom" = callPackage @@ -168641,8 +158315,6 @@ self: { testHaskellDepends = [ base directory filepath simple-cmd ]; description = "List dir files starting from a specific name"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lsp" = callPackage @@ -168786,8 +158458,6 @@ self: { ]; description = "Paint an L-System Grammar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ltext" = callPackage @@ -168839,8 +158509,6 @@ self: { ]; description = "Core functionality for LTI 1.3."; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ltiv1p1" = callPackage @@ -168880,8 +158548,6 @@ self: { libraryPkgconfigDepends = [ gtk3 ]; description = "Leksah tool kit"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk3;}; "ltl" = callPackage @@ -168923,8 +158589,6 @@ self: { ]; description = "Lua bytecode parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lua-bytecode" = callPackage @@ -168957,8 +158621,6 @@ self: { ]; description = "Library functions for reading and writing Lua chunks"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "luautils" = callPackage @@ -168980,8 +158642,6 @@ self: { ]; description = "Helpers for Haskell integration with Lua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lub" = callPackage @@ -169038,8 +158698,6 @@ self: { libraryHaskellDepends = [ base colonnade lucid text ]; description = "Helper functions for using lucid with colonnade"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lucid-extras" = callPackage @@ -169106,8 +158764,6 @@ self: { ]; description = "Server side feed aggregator/reader"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "luhn" = callPackage @@ -169119,8 +158775,6 @@ self: { libraryHaskellDepends = [ base digits QuickCheck ]; description = "An implementation of Luhn's check digit algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lui" = callPackage @@ -169136,8 +158790,6 @@ self: { ]; description = "Purely FunctionaL User Interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "luis-client" = callPackage @@ -169152,8 +158804,6 @@ self: { ]; description = "An unofficial client for the LUIS NLP service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "luka" = callPackage @@ -169167,8 +158817,6 @@ self: { librarySystemDepends = [ objc ]; description = "Simple ObjectiveC runtime binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {objc = null;}; "lukko" = callPackage @@ -169225,8 +158873,6 @@ self: { ]; description = "Type-safe, type-level and stateless graphics framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "luminance-samples" = callPackage @@ -169245,8 +158891,6 @@ self: { ]; description = "Luminance samples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lushtags" = callPackage @@ -169260,8 +158904,6 @@ self: { executableHaskellDepends = [ base haskell-src-exts text vector ]; description = "Create ctags compatible tags files for Haskell programs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "luthor" = callPackage @@ -169274,8 +158916,6 @@ self: { testHaskellDepends = [ base mtl parsec ]; description = "Tools for lexing and utilizing lexemes that integrate with Parsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lvar" = callPackage @@ -169314,8 +158954,6 @@ self: { ]; description = "Parallel scheduler, LVar data structures, and infrastructure to build more"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lvmlib" = callPackage @@ -169338,8 +158976,6 @@ self: { ]; description = "The Lazy Virtual Machine (LVM)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lvmrun" = callPackage @@ -169363,8 +158999,6 @@ self: { libraryHaskellDepends = [ base bindings-lxc mtl transformers ]; description = "High level Haskell bindings to LXC (Linux containers)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lxd-client" = callPackage @@ -169394,8 +159028,6 @@ self: { ]; description = "LXD client written in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lxd-client-config" = callPackage @@ -169433,8 +159065,6 @@ self: { ]; description = "A Lilypond-compiling music box"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lz4" = callPackage @@ -169468,8 +159098,6 @@ self: { ]; description = "Bindings to LZ4"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lz4-conduit" = callPackage @@ -169493,8 +159121,6 @@ self: { ]; description = "LZ4 compression for conduits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lz4-frame-conduit" = callPackage @@ -169523,8 +159149,6 @@ self: { ]; description = "Conduit implementing the official LZ4 frame streaming format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lz4-hs" = callPackage @@ -169554,8 +159178,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Lzip compression / Lzlib bindings"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lzlib" = callPackage @@ -169648,8 +159270,6 @@ self: { ]; description = "Enumerator interface for lzma/xz compression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) xz;}; "lzma-static" = callPackage @@ -169686,8 +159306,6 @@ self: { ]; description = "IO-Streams interface for lzma/xz compression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "lzo" = callPackage @@ -169703,8 +159321,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "minilzo bundled for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mDNSResponder-client" = callPackage @@ -169721,8 +159337,6 @@ self: { testHaskellDepends = [ base bytestring Cabal ]; description = "Library for talking to the mDNSResponder daemon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maam" = callPackage @@ -169739,8 +159353,6 @@ self: { ]; description = "Monadic Abstracting Abstract Machines (MAAM) built on Galois Transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mac" = callPackage @@ -169752,8 +159364,6 @@ self: { libraryHaskellDepends = [ base network transformers ]; description = "Static Mandatory Access Control in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "macaroon-shop" = callPackage @@ -169774,8 +159384,6 @@ self: { ]; description = "A toolkit for working with macaroons"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "macbeth-lib" = callPackage @@ -169801,8 +159409,6 @@ self: { testHaskellDepends = [ attoparsec base bytestring hspec ]; description = "Macbeth - A beautiful and minimalistic FICS client"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maccatcher" = callPackage @@ -169846,8 +159452,6 @@ self: { ]; description = "Arrow based stream transducers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines" = callPackage @@ -169891,8 +159495,6 @@ self: { ]; description = "Machine transducers for Amazonka calls"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-attoparsec" = callPackage @@ -169913,8 +159515,6 @@ self: { ]; description = "Parse machines streams with attoparsec parsers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-binary" = callPackage @@ -169926,8 +159526,6 @@ self: { libraryHaskellDepends = [ base binary bytestring machines ]; description = "Binary utilities for the machines library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-bytestring" = callPackage @@ -169939,8 +159537,6 @@ self: { libraryHaskellDepends = [ base bytestring machines ]; description = "ByteString support for machines"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-directory" = callPackage @@ -169956,8 +159552,6 @@ self: { ]; description = "Directory (system) utilities for the machines library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-encoding" = callPackage @@ -169969,8 +159563,6 @@ self: { libraryHaskellDepends = [ base bytestring machines text ]; description = "Transcode encodings with machines"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-io" = callPackage @@ -169986,8 +159578,6 @@ self: { ]; description = "IO utilities for the machines library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-process" = callPackage @@ -170002,8 +159592,6 @@ self: { ]; description = "Process (system) utilities for the machines library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "machines-zlib" = callPackage @@ -170018,8 +159606,6 @@ self: { ]; description = "Decompression support for machines"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "macho" = callPackage @@ -170032,8 +159618,6 @@ self: { libraryHaskellDepends = [ base binary bytestring ]; description = "Parser for Mach-O object format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mackerel-client" = callPackage @@ -170081,8 +159665,6 @@ self: { ]; description = "Control screen and keyboard backlights on MACs under Linux"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "macos-corelibs" = callPackage @@ -170098,8 +159680,6 @@ self: { ]; description = "Haskell bindings to C-based Mac OS SDK frameworks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "macosx-make-standalone" = callPackage @@ -170119,8 +159699,6 @@ self: { ]; description = "Make a macosx app standalone deployable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "macrm" = callPackage @@ -170145,8 +159723,6 @@ self: { ]; description = "Alternative rm command for macOS that remove files/dirs to the system trash"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mad-props" = callPackage @@ -170199,8 +159775,6 @@ self: { benchmarkHaskellDepends = [ base criterion megaparsec text ]; description = "Randomized templating language DSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mage" = callPackage @@ -170216,8 +159790,6 @@ self: { executableSystemDepends = [ ncurses ]; description = "Rogue-like"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses;}; "magic" = callPackage @@ -170241,8 +159813,6 @@ self: { libraryHaskellDepends = [ base ghc ghc-tcplugins-extra syb ]; description = "Write plugins for magic type families with ease"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "magic-wormhole" = callPackage @@ -170273,8 +159843,6 @@ self: { ]; description = "Interact with Magic Wormhole"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "magicbane" = callPackage @@ -170305,8 +159873,6 @@ self: { ]; description = "A web framework that integrates Servant, RIO, EKG, fast-logger, wai-cli…"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "magico" = callPackage @@ -170324,8 +159890,6 @@ self: { ]; description = "Compute solutions for Magico puzzle"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "magma" = callPackage @@ -170339,8 +159903,6 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "magma is an algebraic structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "magmas" = callPackage @@ -170372,8 +159934,6 @@ self: { ]; description = "ImageBoards to XMPP gate"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maid" = callPackage @@ -170395,8 +159955,6 @@ self: { ]; description = "A simple static web server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mail-pool" = callPackage @@ -170419,8 +159977,6 @@ self: { ]; description = "Preconfigured email connection pool on top of smtp"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mail-reports" = callPackage @@ -170436,8 +159992,6 @@ self: { ]; description = "A parser library for DMARC and SMTP TLS reports"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mailbox-count" = callPackage @@ -170480,8 +160034,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Bindings for the MailChimp API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mailchimp-subscribe" = callPackage @@ -170500,8 +160052,6 @@ self: { ]; description = "MailChimp subscription request handler"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mailgun" = callPackage @@ -170521,8 +160071,6 @@ self: { ]; description = "API binding for Mailgun"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "main-tester" = callPackage @@ -170572,8 +160120,6 @@ self: { ]; description = "Majordomo protocol for ZeroMQ"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "majority" = callPackage @@ -170585,8 +160131,6 @@ self: { libraryHaskellDepends = [ haskell2010 ]; description = "Boyer-Moore Majority Vote Algorithm"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "make-hard-links" = callPackage @@ -170604,8 +160148,6 @@ self: { ]; description = "Change duplicated files into hard-links"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "make-monofoldable-foldable" = callPackage @@ -170617,8 +160159,6 @@ self: { libraryHaskellDepends = [ base mono-traversable ]; description = "Make a MonoFoldable type into an ordinary Foldable type"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "make-package" = callPackage @@ -170639,8 +160179,6 @@ self: { ]; description = "Make a cabalized package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "makedo" = callPackage @@ -170652,8 +160190,6 @@ self: { libraryHaskellDepends = [ base directory filepath HSH process ]; description = "Helper for writing redo scripts in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "makefile" = callPackage @@ -170671,8 +160207,6 @@ self: { ]; description = "Simple Makefile parser and generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mallard" = callPackage @@ -170700,8 +160234,6 @@ self: { ]; description = "Database migration and testing as a library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mameya" = callPackage @@ -170748,8 +160280,6 @@ self: { ]; description = "The Haskell/Gtk+ Integrated Live Environment"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-all" = callPackage @@ -170796,8 +160326,6 @@ self: { ]; description = "Multithread interactive input/search framework for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-browser" = callPackage @@ -170841,8 +160369,6 @@ self: { ]; description = "The core of Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-curl" = callPackage @@ -170865,8 +160391,6 @@ self: { ]; description = "Download Manager extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-editor" = callPackage @@ -170887,8 +160411,6 @@ self: { ]; description = "Editor extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-filemanager" = callPackage @@ -170909,8 +160431,6 @@ self: { ]; description = "File manager extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-imageviewer" = callPackage @@ -170931,8 +160451,6 @@ self: { ]; description = "Image viewer extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-ircclient" = callPackage @@ -170957,8 +160475,6 @@ self: { ]; description = "IRC client extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-mplayer" = callPackage @@ -170980,8 +160496,6 @@ self: { ]; description = "Mplayer client extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-pdfviewer" = callPackage @@ -171002,8 +160516,6 @@ self: { ]; description = "PDF viewer extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-processmanager" = callPackage @@ -171023,8 +160535,6 @@ self: { ]; description = "Process manager extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-reader" = callPackage @@ -171065,8 +160575,6 @@ self: { ]; description = "Template code to create Manatee application"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-terminal" = callPackage @@ -171086,8 +160594,6 @@ self: { ]; description = "Terminal Emulator extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manatee-welcome" = callPackage @@ -171107,8 +160613,6 @@ self: { ]; description = "Welcome module to help user play Manatee quickly"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mancala" = callPackage @@ -171146,8 +160650,6 @@ self: { ]; description = "Library for interfacing with the Mandrill JSON API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mandulia" = callPackage @@ -171166,8 +160668,6 @@ self: { ]; description = "A zooming visualisation of the Mandelbrot Set as many Julia Sets"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mangopay" = callPackage @@ -171206,8 +160706,6 @@ self: { ]; description = "Bindings to the MangoPay API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mangrove" = callPackage @@ -171245,8 +160743,6 @@ self: { ]; description = "Sampling random points on general manifolds"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manifolds" = callPackage @@ -171276,8 +160772,6 @@ self: { ]; description = "Coordinate-free hypersurfaces"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "manifolds-core" = callPackage @@ -171319,8 +160813,6 @@ self: { executableHaskellDepends = [ base bytestring cassava containers ]; description = "Extensions to Data.Map"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "map-reduce-folds" = callPackage @@ -171386,8 +160878,6 @@ self: { ]; description = "Efficient, polymorphic Map Algebra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mappy" = callPackage @@ -171410,8 +160900,6 @@ self: { testHaskellDepends = [ base containers hspec parsec QuickCheck ]; description = "A functional programming language focused around maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mapquest-api" = callPackage @@ -171471,8 +160959,6 @@ self: { ]; description = "A study of marionetta movements"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "markdown" = callPackage @@ -171518,8 +161004,6 @@ self: { ]; description = "Convert Markdown to HTML, with XSS protection"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "markdown-pap" = callPackage @@ -171531,8 +161015,6 @@ self: { libraryHaskellDepends = [ base monads-tf papillon ]; description = "markdown parser with papillon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "markdown-unlit" = callPackage @@ -171572,8 +161054,6 @@ self: { ]; description = "markdown to svg converter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "marked-pretty" = callPackage @@ -171586,8 +161066,6 @@ self: { testHaskellDepends = [ base ]; description = "Pretty-printing library, with scoping, based on pretty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "markov" = callPackage @@ -171643,8 +161121,6 @@ self: { testHaskellDepends = [ assertions base bifunctors memoize random ]; description = "Hidden Markov processes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "markov-realization" = callPackage @@ -171657,8 +161133,6 @@ self: { testHaskellDepends = [ base HTF MonadRandom ]; description = "Realizations of Markov chains"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "markup" = callPackage @@ -171677,8 +161151,6 @@ self: { ]; description = "Abstraction for HTML-embedded content"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "markup-preview" = callPackage @@ -171727,8 +161199,6 @@ self: { ]; description = "Upload packages to Marmalade"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "marquise" = callPackage @@ -171763,8 +161233,6 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Client library for Vaultaire"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mars" = callPackage @@ -171780,8 +161248,6 @@ self: { ]; description = "Generates mountainous terrain using a random walk algorithm"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "marshal-contt" = callPackage @@ -171831,8 +161297,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A framework for modular, portable chat bots"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "marvin-interpolate" = callPackage @@ -171849,8 +161313,6 @@ self: { testHaskellDepends = [ base hspec text ]; description = "Compile time string interpolation a la Scala and CoffeeScript"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "marxup" = callPackage @@ -171896,8 +161358,6 @@ self: { ]; description = "@minamiyama1994_bot on haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mason" = callPackage @@ -171976,8 +161436,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Compatibility of 'massiv' with 'persist'"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "massiv-scheduler" = callPackage @@ -172015,8 +161473,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Compatibility of 'massiv' with 'serialise'"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "massiv-test" = callPackage @@ -172063,8 +161519,6 @@ self: { ]; description = "The project management tool for hackers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mastermind" = callPackage @@ -172139,8 +161593,6 @@ self: { librarySystemDepends = [ pcre ]; description = "Text matchers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) pcre;}; "math-extras" = callPackage @@ -172193,8 +161645,6 @@ self: { testHaskellDepends = [ array base containers hspec random ]; description = "Library containing graph data structures and graph algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "math-interpolate" = callPackage @@ -172206,8 +161656,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Class for interpolation of values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "math-metric" = callPackage @@ -172219,8 +161667,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Typeclass for metric spaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "math-programming" = callPackage @@ -172239,8 +161685,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A library for formulating and solving math programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "math-programming-glpk" = callPackage @@ -172263,8 +161707,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A GLPK backend to the math-programming library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) glpk;}; "math-programming-tests" = callPackage @@ -172280,8 +161722,6 @@ self: { ]; description = "Utility functions for testing implementations of the math-programming library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mathblog" = callPackage @@ -172308,8 +161748,6 @@ self: { ]; description = "A program for creating and managing a static weblog with LaTeX math and diagrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mathexpr" = callPackage @@ -172340,8 +161778,6 @@ self: { ]; description = "Dependently typed tensorflow modeler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mathgenealogy" = callPackage @@ -172400,8 +161836,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Write Mathematica packages in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "matlab" = callPackage @@ -172500,8 +161934,6 @@ self: { ]; description = "Read and Display Jones-Faithful notation for spacegroup and planegroup"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "matrix-lens" = callPackage @@ -172531,8 +161963,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Read and write NIST Matrix Market files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "matrix-market-attoparsec" = callPackage @@ -172584,8 +162014,6 @@ self: { ]; description = "Haskell matrix library with interface to C++ linear algebra libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "matrix-static" = callPackage @@ -172636,8 +162064,6 @@ self: { ]; description = "ncurses XMPP client"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "matterhorn" = callPackage @@ -172739,8 +162165,6 @@ self: { ]; description = "An interface to the Maude rewriting system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maxent" = callPackage @@ -172762,8 +162186,6 @@ self: { ]; description = "Compute Maximum Entropy Distributions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maxent-learner-hw" = callPackage @@ -172787,8 +162209,6 @@ self: { ]; description = "Hayes and Wilson's maxent learning algorithm for phonotactic grammars"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maxent-learner-hw-gui" = callPackage @@ -172810,8 +162230,6 @@ self: { ]; description = "GUI for maxent-learner-hw"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maximal-cliques" = callPackage @@ -172844,8 +162262,6 @@ self: { ]; description = "Maximal sharing of terms in the lambda calculus with letrec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "maybe-justify" = callPackage @@ -172876,8 +162292,6 @@ self: { ]; description = "Automated benchmarking tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mbox" = callPackage @@ -172909,8 +162323,6 @@ self: { ]; description = "A collection of tools to process mbox files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mbox-utility" = callPackage @@ -172972,8 +162384,6 @@ self: { ]; description = "download bugs mailboxes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mcaeson" = callPackage @@ -173015,8 +162425,6 @@ self: { ]; description = "Bindings to mcl, a generic and fast pairing-based cryptography library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gmpxx; mcl = null; inherit (pkgs) openssl;}; "mcm" = callPackage @@ -173036,8 +162444,6 @@ self: { ]; description = "Machine Configuration Manager"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mcmaster-gloss-examples" = callPackage @@ -173050,8 +162456,6 @@ self: { isExecutable = true; executableHaskellDepends = [ base gloss ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mcmc" = callPackage @@ -173079,8 +162483,6 @@ self: { ]; description = "Sample from a posterior using Markov chain Monte Carlo"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mcmc-samplers" = callPackage @@ -173096,8 +162498,6 @@ self: { ]; description = "Combinators for MCMC sampling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mcmc-synthesis" = callPackage @@ -173109,8 +162509,6 @@ self: { libraryHaskellDepends = [ base MonadRandom ]; description = "MCMC applied to probabilistic program synthesis"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mcmc-types" = callPackage @@ -173138,8 +162536,6 @@ self: { executableHaskellDepends = [ base transformers ]; description = "Connect to MineCraft running on a Raspberry PI"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mdapi" = callPackage @@ -173158,8 +162554,6 @@ self: { ]; description = "Haskell interface to Fedora's mdapi"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mdcat" = callPackage @@ -173179,8 +162573,6 @@ self: { ]; description = "Markdown viewer in your terminal"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mdo" = callPackage @@ -173210,8 +162602,6 @@ self: { testHaskellDepends = [ base HTF HUnit QuickCheck vector ]; description = "Tools for solving Markov Decision Processes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mealstrom" = callPackage @@ -173234,8 +162624,6 @@ self: { ]; description = "Manipulate FSMs and store them in PostgreSQL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mealy" = callPackage @@ -173256,8 +162644,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "means" = callPackage @@ -173281,8 +162667,6 @@ self: { librarySystemDepends = [ mecab ]; description = "A Haskell binding to MeCab"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) mecab;}; "mech" = callPackage @@ -173294,8 +162678,6 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mecha" = callPackage @@ -173320,8 +162702,6 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "med-module" = callPackage @@ -173396,8 +162776,6 @@ self: { ]; description = "Multimedia streaming on top of Conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mediabus-fdk-aac" = callPackage @@ -173425,8 +162803,6 @@ self: { ]; description = "Mediabus plugin for the Frauenhofer ISO-14496-3 AAC FDK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {fdk-aac = null;}; "mediabus-rtp" = callPackage @@ -173464,8 +162840,6 @@ self: { ]; description = "Receive and Send RTP Packets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "median-stream" = callPackage @@ -173496,8 +162870,6 @@ self: { ]; description = "Interfacing with the MediaWiki API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mediawiki2latex" = callPackage @@ -173541,8 +162913,6 @@ self: { ]; description = "Haskell SDK for communicating with the Medium API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "meep" = callPackage @@ -173581,8 +162951,6 @@ self: { ]; description = "Handles uploading to Hackage from mega repos"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "megalisp" = callPackage @@ -173594,8 +162962,6 @@ self: { libraryHaskellDepends = [ base megaparsec mtl text ]; description = "lisp parser using mega-parsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "megaparsec" = callPackage @@ -173677,8 +163043,6 @@ self: { ]; description = "Control physical access devices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mellon-gpio" = callPackage @@ -173690,8 +163054,6 @@ self: { libraryHaskellDepends = [ base hpio mellon-core protolude ]; description = "GPIO support for mellon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mellon-web" = callPackage @@ -173733,8 +163095,6 @@ self: { ]; description = "A REST web service for Mellon controllers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "melody" = callPackage @@ -173756,8 +163116,6 @@ self: { ]; description = "A functional scripting language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "membership" = callPackage @@ -173811,8 +163169,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "A memcached client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memcache-conduit" = callPackage @@ -173832,8 +163188,6 @@ self: { ]; description = "Conduit library for memcache procotol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memcache-haskell" = callPackage @@ -173856,8 +163210,6 @@ self: { ]; description = "Memcache procotol library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memcached" = callPackage @@ -173892,8 +163244,6 @@ self: { ]; description = "memcached client using binary protocol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memdb" = callPackage @@ -173959,8 +163309,6 @@ self: { ]; description = "Memis Efficient Manual Image Sorting"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memo-ptr" = callPackage @@ -173972,8 +163320,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Pointer equality memoization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memo-sqlite" = callPackage @@ -174001,8 +163347,6 @@ self: { testHaskellDepends = [ base hspec time time-units ]; description = "Utilities for memoizing functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memoize" = callPackage @@ -174076,8 +163420,6 @@ self: { ]; description = "basic memory pool outside of haskell heap/GC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "memscript" = callPackage @@ -174119,8 +163461,6 @@ self: { ]; description = "Haskell binding for Menoh DNN inference library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {menoh = null;}; "menshen" = callPackage @@ -174139,8 +163479,6 @@ self: { ]; description = "Data Validation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mercury-api" = callPackage @@ -174225,8 +163563,6 @@ self: { ]; description = "Support for using mergeful from persistent-based databases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mergeless" = callPackage @@ -174265,8 +163601,6 @@ self: { ]; description = "Support for using mergeless from persistent-based databases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "merkle-log" = callPackage @@ -174318,8 +163652,6 @@ self: { ]; description = "A modified Merkle Patricia DB"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "merkle-tree" = callPackage @@ -174339,8 +163671,6 @@ self: { ]; description = "An implementation of a Merkle tree and merkle tree proofs of inclusion"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mersenne-random" = callPackage @@ -174404,8 +163734,6 @@ self: { ]; description = "Message Pack RPC over TCP"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "messente" = callPackage @@ -174419,8 +163747,6 @@ self: { ]; description = "Messente SMS Gateway"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "meta-misc" = callPackage @@ -174432,8 +163758,6 @@ self: { libraryHaskellDepends = [ base loch-th template-haskell ]; description = "Utility library providing miscellaneous meta-programming utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "meta-par" = callPackage @@ -174450,8 +163774,6 @@ self: { ]; description = "Provides the monad-par interface, but based on modular scheduler \"mix-ins\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "meta-par-accelerate" = callPackage @@ -174469,8 +163791,6 @@ self: { ]; description = "Support for integrated Accelerate computations within Meta-par"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "metadata" = callPackage @@ -174482,8 +163802,6 @@ self: { libraryHaskellDepends = [ base text time ]; description = "metadata library for semantic web"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "metaheuristics" = callPackage @@ -174495,8 +163813,6 @@ self: { libraryHaskellDepends = [ arrows base random Stream ]; description = "Generalised local search within Haskell, for applications in combinatorial optimisation"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "metamorphic" = callPackage @@ -174520,8 +163836,6 @@ self: { libraryHaskellDepends = [ base Cabal filepath ghc haskell98 ]; description = "a tiny ghc api wrapper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "metar" = callPackage @@ -174547,8 +163861,6 @@ self: { ]; description = "Australian METAR"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "metar-http" = callPackage @@ -174573,8 +163885,6 @@ self: { ]; description = "HTTP for METAR"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "method" = callPackage @@ -174613,8 +163923,6 @@ self: { ]; description = "Metric spaces"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "metrics" = callPackage @@ -174648,8 +163956,6 @@ self: { libraryHaskellDepends = [ base network ]; description = "Client for the metrics aggregator Metricsd"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "metro" = callPackage @@ -174751,8 +164057,6 @@ self: { ]; description = "Time Synchronized execution"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mezzo" = callPackage @@ -174773,8 +164077,6 @@ self: { ]; description = "Typesafe music composition"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mezzolens" = callPackage @@ -174786,8 +164088,6 @@ self: { libraryHaskellDepends = [ base containers mtl transformers ]; description = "Pure Profunctor Functional Lenses"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mfsolve" = callPackage @@ -174817,8 +164117,6 @@ self: { ]; description = "Generics with multiple parameters"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mi" = callPackage @@ -174834,8 +164132,6 @@ self: { ]; description = "Multiple Instance for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miconix-test" = callPackage @@ -174851,8 +164147,6 @@ self: { executableHaskellDepends = [ base ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "micro-gateway" = callPackage @@ -174881,8 +164175,6 @@ self: { ]; description = "A Micro service gateway"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "micro-recursion-schemes" = callPackage @@ -174900,8 +164192,6 @@ self: { testHaskellDepends = [ base HUnit template-haskell ]; description = "Simple recursion schemes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microaeson" = callPackage @@ -174937,8 +164227,6 @@ self: { doHaddock = false; description = "A minimal base to work around GHC bugs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microbench" = callPackage @@ -175001,8 +164289,6 @@ self: { ]; description = "A Microformats 2 parser"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microformats2-types" = callPackage @@ -175018,8 +164304,6 @@ self: { ]; description = "Microformats 2 types (with Aeson instances)"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microgroove" = callPackage @@ -175031,8 +164315,6 @@ self: { libraryHaskellDepends = [ base primitive vector ]; description = "Array-backed extensible records"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microlens" = callPackage @@ -175087,8 +164369,6 @@ self: { libraryHaskellDepends = [ base microlens ]; description = "'each' for microlens"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microlens-ghc" = callPackage @@ -175186,8 +164466,6 @@ self: { testHaskellDepends = [ aeson base hspec text ]; description = "A super simple logging module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microsoft-translator" = callPackage @@ -175205,8 +164483,6 @@ self: { ]; description = "Bindings to the Microsoft Translator API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "microspec" = callPackage @@ -175282,8 +164558,6 @@ self: { ]; description = "Language for algorithmic generation of MIDI files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "midair" = callPackage @@ -175352,8 +164626,6 @@ self: { ]; description = "Convert MIDI file to music box punch tape"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "midi-simple" = callPackage @@ -175405,8 +164677,6 @@ self: { ]; description = "Utilities for working with MIDI data"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "midimory" = callPackage @@ -175426,8 +164696,6 @@ self: { ]; description = "A Memory-like (Concentration, Pairs, ...) game for tones"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "midisurface" = callPackage @@ -175445,8 +164713,6 @@ self: { ]; description = "A control midi surface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mighttpd" = callPackage @@ -175467,8 +164733,6 @@ self: { ]; description = "Simple Web Server in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mighttpd2" = callPackage @@ -175537,8 +164801,6 @@ self: { ]; description = "Semi-automatic database schema migrations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "migrant-hdbc" = callPackage @@ -175557,8 +164819,6 @@ self: { ]; description = "Semi-automatic database schema migrations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "migrant-postgresql-simple" = callPackage @@ -175579,8 +164839,6 @@ self: { ]; description = "Semi-automatic database schema migrations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "migrant-sqlite-simple" = callPackage @@ -175598,8 +164856,6 @@ self: { ]; description = "Semi-automatic database schema migrations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mikmod" = callPackage @@ -175613,8 +164869,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "MikMod bindings"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mikrokosmos" = callPackage @@ -175640,8 +164894,6 @@ self: { ]; description = "Lambda calculus interpreter"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miku" = callPackage @@ -175658,8 +164910,6 @@ self: { ]; description = "A minimum web dev DSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "milena" = callPackage @@ -175683,8 +164933,6 @@ self: { ]; description = "A Kafka client for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mime" = callPackage @@ -175713,8 +164961,6 @@ self: { ]; description = "A library for parsing/printing the text/directory mime type"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mime-mail" = callPackage @@ -175835,8 +165081,6 @@ self: { ]; description = "a DSL for generating minecraft commands and levels"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mines" = callPackage @@ -175871,8 +165115,6 @@ self: { ]; description = "Minesweeper game which is always solvable without guessing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mini-egison" = callPackage @@ -175894,8 +165136,6 @@ self: { testHaskellDepends = [ base hspec primes ]; description = "Template Haskell Implementation of Egison Pattern Matching"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miniball" = callPackage @@ -175928,8 +165168,6 @@ self: { ]; description = "Miniature FORTH-like interpreter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minilens" = callPackage @@ -175945,8 +165183,6 @@ self: { ]; description = "A minimalistic lens library, providing only the simplest, most basic lens functionality"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minilight" = callPackage @@ -175978,8 +165214,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A SDL2-based graphics library, batteries-included"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minilight-lua" = callPackage @@ -176000,8 +165234,6 @@ self: { executableHaskellDepends = [ base lens minilight mtl ]; description = "A binding library of minilight for Lua langauge"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minimal-configuration" = callPackage @@ -176043,8 +165275,6 @@ self: { executableHaskellDepends = [ base GLUT haskell98 unix ]; description = "Shows how to run grabber on Mac OS X"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minio-hs" = callPackage @@ -176097,8 +165327,6 @@ self: { ]; description = "A fast parallel ssh tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minioperational" = callPackage @@ -176115,8 +165343,6 @@ self: { ]; description = "fast and simple operational monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miniplex" = callPackage @@ -176133,8 +165359,6 @@ self: { ]; description = "simple 1-to-N interprocess communication"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minirotate" = callPackage @@ -176154,8 +165378,6 @@ self: { ]; description = "Minimalistic file rotation utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minisat" = callPackage @@ -176197,8 +165419,6 @@ self: { ]; description = "an interpreter for an operational semantics for the STG machine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minitypeset-opengl" = callPackage @@ -176250,8 +165470,6 @@ self: { ]; description = "A set of helpers to call minizinc models"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "minlen" = callPackage @@ -176279,8 +165497,6 @@ self: { testHaskellDepends = [ base binary directory hspec vector ]; description = "Read and write IDX data that is used in e.g. the MINST database."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mintty" = callPackage @@ -176315,8 +165531,6 @@ self: { ]; description = "A Minisat-based CDCL SAT solver in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mirror-tweet" = callPackage @@ -176335,8 +165549,6 @@ self: { ]; description = "Tweet mirror"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "misfortune" = callPackage @@ -176482,8 +165694,6 @@ self: { ]; description = "A tasty Haskell front-end framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miso-action-logger" = callPackage @@ -176495,8 +165705,6 @@ self: { libraryHaskellDepends = [ aeson base ghcjs-base miso ]; description = "Miso state transition logger"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miso-examples" = callPackage @@ -176509,8 +165717,6 @@ self: { isExecutable = true; description = "A tasty Haskell front-end framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miso-from-html" = callPackage @@ -176558,8 +165764,6 @@ self: { ]; description = "A Haskell git implimentation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miss-porcelain" = callPackage @@ -176578,8 +165782,6 @@ self: { ]; description = "Useability extras built on top of miss"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "missing-foreign" = callPackage @@ -176605,8 +165807,6 @@ self: { ]; description = "Haskell interface to Python"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mit-3qvpPyAi6mH" = callPackage @@ -176634,8 +165834,6 @@ self: { ]; description = "A git wrapper with a streamlined UX"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "miv" = callPackage @@ -176673,8 +165871,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Mixing effects of one arrow into another one"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mixed-strategies" = callPackage @@ -176691,8 +165887,6 @@ self: { ]; description = "Find optimal mixed strategies for two-player games"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mixed-types-num" = callPackage @@ -176753,8 +165947,6 @@ self: { testToolDepends = [ hspec-discover markdown-unlit ]; description = "Mixpanel client"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mkbndl" = callPackage @@ -176769,8 +165961,6 @@ self: { executableHaskellDepends = [ base directory filepath haskell98 ]; description = "Makes an OS X .app bundle from a binary."; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mkcabal" = callPackage @@ -176789,8 +165979,6 @@ self: { ]; description = "Generate cabal files for a Haskell project"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ml-w" = callPackage @@ -176805,8 +165993,6 @@ self: { executableHaskellDepends = [ base mtl parsec pretty ]; description = "Minimal ML language to to demonstrate the W type infererence algorithm"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mlist" = callPackage @@ -176818,8 +166004,6 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "Monadic List alternative to lazy I/O"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mltool" = callPackage @@ -176854,8 +166038,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "The library that can be used for optimization of multiple (Ord a) => a -> b transformations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmap" = callPackage @@ -176898,8 +166080,6 @@ self: { benchmarkHaskellDepends = [ base criterion text weigh ]; description = "Strict markdown processor for writers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmark_0_0_7_3" = callPackage @@ -176930,7 +166110,6 @@ self: { description = "Strict markdown processor for writers"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmark-cli" = callPackage @@ -176954,8 +166133,6 @@ self: { ]; description = "Command line interface to the MMark markdown processor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmark-ext" = callPackage @@ -176976,8 +166153,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Commonly useful extensions for the MMark markdown processor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmorph_1_1_3" = callPackage @@ -177133,8 +166308,6 @@ self: { ]; description = "Produces a sound recording specified by the Ukrainian text"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmsyn7l" = callPackage @@ -177221,8 +166394,6 @@ self: { ]; description = "Macromolecular Transmission Format implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmtl" = callPackage @@ -177234,8 +166405,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Modular Monad transformer library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mmtl-base" = callPackage @@ -177249,8 +166418,6 @@ self: { libraryHaskellDepends = [ base mmtl ]; description = "MonadBase type-class for mmtl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mnist-idx" = callPackage @@ -177280,8 +166447,6 @@ self: { ]; description = "Language-agnostic analyzer for positional morphosyntactic tags"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mock-httpd" = callPackage @@ -177429,8 +166594,6 @@ self: { ]; description = "A parser for the modelica language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "modern-uri" = callPackage @@ -177480,8 +166643,6 @@ self: { ]; description = "Modify fasta (and CLIP) files in several optional ways"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "modsplit" = callPackage @@ -177502,8 +166663,6 @@ self: { ]; description = "Haskell source splitter driven by special comments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "modular" = callPackage @@ -177544,8 +166703,6 @@ self: { ]; description = "A new Prelude featuring first class modules"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "modular-prelude-classy" = callPackage @@ -177557,8 +166714,6 @@ self: { libraryHaskellDepends = [ base classy-prelude modular-prelude ]; description = "Reifying ClassyPrelude a la ModularPrelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "modularity" = callPackage @@ -177574,8 +166729,6 @@ self: { ]; description = "Find the modularity of a network"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "module-management" = callPackage @@ -177606,8 +166759,6 @@ self: { ]; description = "Clean up module imports, split and merge modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "modulespection" = callPackage @@ -177624,8 +166775,6 @@ self: { ]; description = "Template Haskell for introspecting a module's declarations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "modulo" = callPackage @@ -177645,8 +166794,6 @@ self: { ]; description = "Modular C code generator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "moe" = callPackage @@ -177662,8 +166809,6 @@ self: { ]; description = "html with style"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "moesocks" = callPackage @@ -177686,8 +166831,6 @@ self: { ]; description = "A functional firewall killer"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mohws" = callPackage @@ -177711,8 +166854,6 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Modular Haskell Web Server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mole" = callPackage @@ -177743,8 +166884,6 @@ self: { ]; description = "A glorified string replacement tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mollie-api-haskell" = callPackage @@ -177770,8 +166909,6 @@ self: { ]; description = "Mollie API client for Haskell http://www.mollie.com"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-abort-fd" = callPackage @@ -177799,8 +166936,6 @@ self: { libraryHaskellDepends = [ base containers ghc-prim mtl ]; description = "Monadically convert object to unique integers and back"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-atom-simple" = callPackage @@ -177812,8 +166947,6 @@ self: { libraryHaskellDepends = [ base containers ghc-prim mtl ]; description = "Monadically map objects to unique ints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-batcher" = callPackage @@ -177857,8 +166990,6 @@ self: { ]; description = "A library for probabilistic programming"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-bool" = callPackage @@ -177882,8 +167013,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Monadic abstraction for computations that can be branched and run independently"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-choice" = callPackage @@ -178076,8 +167205,6 @@ self: { ]; description = "Exstensible monadic exceptions"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-extras" = callPackage @@ -178120,8 +167247,6 @@ self: { libraryHaskellDepends = [ base monad-control ]; description = "Type class for monads which support a fork operation"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-gen" = callPackage @@ -178170,8 +167295,6 @@ self: { ]; description = "A class of monads which can do http requests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-interleave" = callPackage @@ -178183,8 +167306,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Monads with an unsaveInterleaveIO-like operation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-introspect" = callPackage @@ -178246,8 +167367,6 @@ self: { ]; description = "Specific levels of monad transformers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-lgbt" = callPackage @@ -178266,8 +167385,6 @@ self: { ]; description = "Monad transformers for combining local and global state"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-log" = callPackage @@ -178287,8 +167404,6 @@ self: { ]; description = "A simple and fast logging monad"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-logger" = callPackage @@ -178435,8 +167550,6 @@ self: { ]; description = "a monad to calculate linear recursive sequence"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-markov" = callPackage @@ -178488,8 +167601,6 @@ self: { libraryHaskellDepends = [ base mersenne-random-pure64 ]; description = "An efficient random generator monad, based on the Mersenne Twister"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-metrics" = callPackage @@ -178527,8 +167638,6 @@ self: { ]; description = "An extensible and type-safe wrapper around EKG metrics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-mock" = callPackage @@ -178547,8 +167656,6 @@ self: { testHaskellDepends = [ base hspec mtl ]; description = "A monad transformer for mocking mtl-style typeclasses"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-open" = callPackage @@ -178560,8 +167667,6 @@ self: { libraryHaskellDepends = [ base exceptions mtl transformers ]; description = "Open recursion for when you need it"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-ox" = callPackage @@ -178643,8 +167748,6 @@ self: { ]; description = "Parallel execution of monadic computations with a progress bar"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-param" = callPackage @@ -178656,8 +167759,6 @@ self: { libraryHaskellDepends = [ base mtl stm ]; description = "Parameterized monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-peel" = callPackage @@ -178698,8 +167799,6 @@ self: { ]; description = "An mtl-style typeclass and transformer for persistent"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-primitive" = callPackage @@ -178733,8 +167832,6 @@ self: { libraryHaskellDepends = [ base ghc-prim mtl ]; description = "Fast monads and monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-recorder" = callPackage @@ -178751,8 +167848,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Record and replay the results of monadic actions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-resumption" = callPackage @@ -178801,8 +167896,6 @@ self: { ]; description = "Utility library for monads, particularly those involving state"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-statevar" = callPackage @@ -178815,8 +167908,6 @@ self: { testHaskellDepends = [ base stm ]; description = "Concise, overloaded accessors for IORef, STRef, TVar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-ste" = callPackage @@ -178833,8 +167924,6 @@ self: { testHaskellDepends = [ base hspec HUnit ]; description = "ST monad with efficient explicit errors"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-stlike-io" = callPackage @@ -178849,8 +167938,6 @@ self: { ]; description = "ST-like monad capturing variables to regions and supporting IO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-stlike-stm" = callPackage @@ -178862,8 +167949,6 @@ self: { libraryHaskellDepends = [ base monad-stlike-io stm ]; description = "ST-like monad capturing variables to regions and supporting STM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-stm" = callPackage @@ -178898,8 +167983,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "A monad transformer that turns event processing into co-routine programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-time" = callPackage @@ -178929,8 +168012,6 @@ self: { testHaskellDepends = [ base containers hlint hspec transformers ]; description = "Monad transformer for recording timing events"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-tx" = callPackage @@ -178942,8 +168023,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A transactional state monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-unify" = callPackage @@ -178957,8 +168036,6 @@ self: { libraryHaskellDepends = [ base mtl unordered-containers ]; description = "Generic first-order unification"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-unlift" = callPackage @@ -179022,8 +168099,6 @@ self: { libraryHaskellDepends = [ base base-compat stm ]; description = "Generic operations over variables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monad-wrap" = callPackage @@ -179035,8 +168110,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Wrap functions such as catch around different monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monadIO" = callPackage @@ -179072,8 +168145,6 @@ self: { libraryHaskellDepends = [ base monadLib ]; description = "Arrow-like monad composition for monadLib"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monadacme" = callPackage @@ -179085,8 +168156,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "The Acme and AcmeT monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monadbi" = callPackage @@ -179156,8 +168225,6 @@ self: { testHaskellDepends = [ base ]; description = "Recursion Schemes for Monadic version"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monadiccp" = callPackage @@ -179175,8 +168242,6 @@ self: { testHaskellDepends = [ base ]; description = "Constraint Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monadiccp-gecode" = callPackage @@ -179195,8 +168260,6 @@ self: { testHaskellDepends = [ base ]; description = "Constraint Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gecodeint = null; gecodekernel = null; gecodesearch = null; gecodeset = null; gecodesupport = null;}; @@ -179248,8 +168311,6 @@ self: { ]; description = "A preprocessor for generating monadic call traces"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monadlog" = callPackage @@ -179269,8 +168330,6 @@ self: { ]; description = "A simple and fast logging monad"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monadoid" = callPackage @@ -179297,8 +168356,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell98 partial maps and filters over MonadPlus"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monads-fd" = callPackage @@ -179310,8 +168367,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Monad classes, using functional dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monads-tf" = callPackage @@ -179352,8 +168407,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Monadic interface for TokyoTyrant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mondo" = callPackage @@ -179377,8 +168430,6 @@ self: { ]; description = "Haskell bindings for the Mondo API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monetdb-mapi" = callPackage @@ -179390,8 +168441,6 @@ self: { libraryHaskellDepends = [ base bindings-monetdb-mapi ]; description = "Mid-level bindings for the MonetDB API (mapi)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "money" = callPackage @@ -179404,8 +168453,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Money"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mongoDB" = callPackage @@ -179438,8 +168485,6 @@ self: { ]; description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mongodb-queue" = callPackage @@ -179460,8 +168505,6 @@ self: { ]; description = "message queue using MongoDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mongrel2-handler" = callPackage @@ -179479,8 +168522,6 @@ self: { ]; description = "Mongrel2 Handler Library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monitor" = callPackage @@ -179494,8 +168535,6 @@ self: { executableHaskellDepends = [ base filepath hinotify process ]; description = "Do things when files change"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monky" = callPackage @@ -179520,8 +168559,6 @@ self: { ]; description = "A system state collecting library and application"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mono-foldable" = callPackage @@ -179533,8 +168570,6 @@ self: { libraryHaskellDepends = [ base bytestring text vector ]; description = "Folds for monomorphic containers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mono-traversable" = callPackage @@ -179615,8 +168650,6 @@ self: { libraryHaskellDepends = [ base containers lens mtl ]; description = "Monoid type classes, designed in modular way, distinguish Monoid from Mempty and Semigroup. This design allows mempty operation don't bring Semigroups related constraints until (<>) is used."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monoid-absorbing" = callPackage @@ -179628,8 +168661,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A library for (left, right) zero monoids and backtracking with cut"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monoid-extras" = callPackage @@ -179657,8 +168688,6 @@ self: { libraryHaskellDepends = [ base bytestring containers ]; description = "a practical monoid implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monoid-record" = callPackage @@ -179771,8 +168800,6 @@ self: { ]; description = "Extra classes/functions about monoids"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monoids" = callPackage @@ -179788,8 +168815,6 @@ self: { ]; description = "Deprecated: Use 'reducers'"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monomorphic" = callPackage @@ -179817,8 +168842,6 @@ self: { ]; description = "Well-typed paths"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "montage" = callPackage @@ -179884,8 +168907,6 @@ self: { ]; description = "A monad and transformer for Monte Carlo calculations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "months" = callPackage @@ -179904,8 +168925,6 @@ self: { ]; description = "MonthName"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monus" = callPackage @@ -179922,8 +168941,6 @@ self: { ]; description = "a 'Monus' is a commutative monoid that allows a notion of substraction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "monzo" = callPackage @@ -179947,8 +168964,6 @@ self: { ]; description = "Haskell bindings for the Monzo API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "moo" = callPackage @@ -179970,8 +168985,6 @@ self: { ]; description = "Genetic algorithm library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "moonshine" = callPackage @@ -180031,8 +169044,6 @@ self: { ]; description = "A tool for supervised learning of morphology"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morfeusz" = callPackage @@ -180050,8 +169061,6 @@ self: { librarySystemDepends = [ morfeusz ]; description = "Bindings to the morphological analyser Morfeusz"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {morfeusz = null;}; "morley" = callPackage @@ -180096,8 +169105,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Developer tools for the Michelson Language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morley-prelude" = callPackage @@ -180180,8 +169187,6 @@ self: { ]; description = "A multi-lingual, typed, workflow language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morph" = callPackage @@ -180228,8 +169233,6 @@ self: { ]; description = "Morpheus GraphQL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morpheus-graphql-app" = callPackage @@ -180256,8 +169259,6 @@ self: { ]; description = "Morpheus GraphQL Core"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morpheus-graphql-cli" = callPackage @@ -180278,8 +169279,6 @@ self: { ]; description = "Morpheus GraphQL CLI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morpheus-graphql-client" = callPackage @@ -180352,8 +169351,6 @@ self: { ]; description = "Morpheus GraphQL Subscriptions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morphisms" = callPackage @@ -180375,8 +169372,6 @@ self: { libraryHaskellDepends = [ morphisms ]; description = "Functors, theirs compositions and transformations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morphisms-functors-inventory" = callPackage @@ -180388,8 +169383,6 @@ self: { libraryHaskellDepends = [ morphisms morphisms-functors ]; description = "Inventory is state and store"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morphisms-objects" = callPackage @@ -180401,8 +169394,6 @@ self: { libraryHaskellDepends = [ morphisms ]; description = "Algebraic structures"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "morte" = callPackage @@ -180436,8 +169427,6 @@ self: { benchmarkHaskellDepends = [ base criterion system-filepath text ]; description = "A bare-bones calculus of constructions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mosaico-lib" = callPackage @@ -180456,8 +169445,6 @@ self: { ]; description = "Generación interactiva de mosaicos"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mosquitto-hs" = callPackage @@ -180526,8 +169513,6 @@ self: { ]; description = "PostgreSQL-based migrations registry for moto"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "motor" = callPackage @@ -180568,8 +169553,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Generate state diagrams from Motor FSM typeclasses"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "motor-reflection" = callPackage @@ -180587,8 +169570,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Reflect on Motor FSM typeclasses to obtain runtime representations"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mount" = callPackage @@ -180600,8 +169581,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Mounts and umounts filesystems"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mountpoints" = callPackage @@ -180636,8 +169615,6 @@ self: { ]; description = "Plays videos using GStreamer and GTK+"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "moving-averages" = callPackage @@ -180674,8 +169651,6 @@ self: { ]; description = "Music player for linux"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mp3decoder" = callPackage @@ -180707,8 +169682,6 @@ self: { ]; description = "MPD/PowerMate executable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mpg123-bindings" = callPackage @@ -180831,8 +169804,6 @@ self: { ]; description = "Multi-dimensional parametric pretty-printer with color"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mprelude" = callPackage @@ -180851,8 +169822,6 @@ self: { ]; description = "A minimalish prelude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mpretty" = callPackage @@ -180869,8 +169838,6 @@ self: { ]; description = "a monadic, extensible pretty printing library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mpris" = callPackage @@ -180882,8 +169849,6 @@ self: { libraryHaskellDepends = [ base containers dbus mtl ]; description = "Interface for MPRIS"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mprover" = callPackage @@ -180901,8 +169866,6 @@ self: { ]; description = "Simple equational reasoning for a Haskell-ish language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mps" = callPackage @@ -180922,8 +169885,6 @@ self: { ]; description = "simply oo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mptcp-pm" = callPackage @@ -180948,8 +169909,6 @@ self: { executableToolDepends = [ c2hs ]; description = "A work in progress Multipath TCP path manager"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mpvguihs" = callPackage @@ -180968,8 +169927,6 @@ self: { ]; description = "A minimalist mpv GUI written in I/O heavy Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mqtt" = callPackage @@ -180998,8 +169955,6 @@ self: { ]; description = "An MQTT protocol implementation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mqtt-hs" = callPackage @@ -181016,8 +169971,6 @@ self: { ]; description = "A MQTT client library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mr-env" = callPackage @@ -181043,8 +169996,6 @@ self: { executableHaskellDepends = [ array base containers mtl ]; description = "Decompiles Glulx files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mrm" = callPackage @@ -181056,8 +170007,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Modular Refiable Matching, first-class matches"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ms" = callPackage @@ -181078,8 +170027,6 @@ self: { ]; description = "metric spaces"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ms-tds" = callPackage @@ -181125,8 +170072,6 @@ self: { ]; description = "A Haskell implementation of MessagePack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "msgpack-aeson" = callPackage @@ -181145,8 +170090,6 @@ self: { testHaskellDepends = [ aeson base msgpack tasty tasty-hunit ]; description = "Aeson adapter for MessagePack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "msgpack-binary" = callPackage @@ -181173,8 +170116,6 @@ self: { ]; description = "A Haskell implementation of MessagePack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "msgpack-idl" = callPackage @@ -181196,8 +170137,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "An IDL Compiler for MessagePack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "msgpack-rpc" = callPackage @@ -181218,8 +170157,6 @@ self: { testHaskellDepends = [ async base mtl network tasty tasty-hunit ]; description = "A MessagePack-RPC Implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "msgpack-rpc-conduit" = callPackage @@ -181241,8 +170178,6 @@ self: { testHaskellDepends = [ async base bytestring hspec mtl network ]; description = "A MessagePack-RPC Implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "msgpack-types" = callPackage @@ -181280,8 +170215,6 @@ self: { ]; description = "Object-Oriented Programming in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "msi-kb-backlit" = callPackage @@ -181295,8 +170228,6 @@ self: { executableHaskellDepends = [ base bytestring hid split ]; description = "A command line tool to change backlit colors of your MSI keyboards"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mssql-simple" = callPackage @@ -181371,8 +170302,6 @@ self: { ]; description = "Library to communicate with Mt.Gox"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mtl_2_2_2" = callPackage @@ -181396,8 +170325,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Very strict CPS'd transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mtl-compat" = callPackage @@ -181425,8 +170352,6 @@ self: { ]; description = "Instances for the mtl classes for all monad transformers"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mtl-extras" = callPackage @@ -181438,8 +170363,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Higher order versions of MTL classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mtl-prelude" = callPackage @@ -181462,8 +170385,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Monad Transformer Library with Type Families"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mtl-unleashed" = callPackage @@ -181517,8 +170438,6 @@ self: { libraryHaskellDepends = [ base mtl QuickCheck ]; description = "Monad transformer library with type indexes, providing 'free' copies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mtp" = callPackage @@ -181531,8 +170450,6 @@ self: { librarySystemDepends = [ mtp ]; description = "Bindings to libmtp"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {mtp = null;}; "mtree" = callPackage @@ -181580,8 +170497,6 @@ self: { ]; description = "Avro serialization support for Mu microservices"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-graphql" = callPackage @@ -181611,8 +170526,6 @@ self: { ]; description = "GraphQL support for Mu"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-grpc-client" = callPackage @@ -181636,8 +170549,6 @@ self: { ]; description = "gRPC clients from Mu definitions"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-grpc-common" = callPackage @@ -181657,8 +170568,6 @@ self: { ]; description = "gRPC for Mu, common modules for client and server"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-grpc-server" = callPackage @@ -181685,8 +170594,6 @@ self: { ]; description = "gRPC servers for Mu definitions"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-kafka" = callPackage @@ -181703,8 +170610,6 @@ self: { ]; description = "Utilities for interoperation between Mu and Kafka"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-lens" = callPackage @@ -181720,8 +170625,6 @@ self: { ]; description = "Lenses for @mu-schema@ terms"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-optics" = callPackage @@ -181736,8 +170639,6 @@ self: { ]; description = "Optics for @mu-schema@ terms"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-persistent" = callPackage @@ -181754,8 +170655,6 @@ self: { ]; description = "Utilities for interoperation between Mu and Persistent"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-prometheus" = callPackage @@ -181772,8 +170671,6 @@ self: { ]; description = "Metrics support for Mu using Prometheus"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-protobuf" = callPackage @@ -181801,8 +170698,6 @@ self: { ]; description = "Protocol Buffers serialization and gRPC schema import for Mu microservices"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-rpc" = callPackage @@ -181819,8 +170714,6 @@ self: { ]; description = "Protocol-independent declaration of services and servers"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-schema" = callPackage @@ -181839,8 +170732,6 @@ self: { ]; description = "Format-independent schemas for serialization"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-servant-server" = callPackage @@ -181864,8 +170755,6 @@ self: { ]; description = "Servant servers for Mu definitions"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mu-tracing" = callPackage @@ -181879,8 +170768,6 @@ self: { ]; description = "Tracing support for Mu"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mucipher" = callPackage @@ -181916,8 +170803,6 @@ self: { ]; description = "Multi-version deployer for web applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mudbath" = callPackage @@ -181955,8 +170840,6 @@ self: { ]; description = "A simple document-oriented database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mueval" = callPackage @@ -182010,8 +170893,6 @@ self: { testToolDepends = [ alex happy ]; description = "An intermediate language designed to perform advanced code analysis"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multext-east-msd" = callPackage @@ -182023,8 +170904,6 @@ self: { libraryHaskellDepends = [ base ]; description = "MULTEXT-East morphosyntactic descriptors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multi-cabal" = callPackage @@ -182046,8 +170925,6 @@ self: { ]; description = "A tool supporting multi cabal project builds"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multi-containers" = callPackage @@ -182073,8 +170950,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Typeclasses augmented with a phantom type parameter"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multi-trie" = callPackage @@ -182087,8 +170962,6 @@ self: { testHaskellDepends = [ base containers HTF ]; description = "Trie of sets, as a model for compound names having multiple values"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multiaddr" = callPackage @@ -182109,8 +170982,6 @@ self: { ]; description = "A network address format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multiarg" = callPackage @@ -182129,8 +171000,6 @@ self: { ]; description = "Command lines for options that take multiple arguments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multibase" = callPackage @@ -182154,7 +171023,6 @@ self: { description = "Self-identifying base encodings, implementation of "; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multifile" = callPackage @@ -182198,8 +171066,6 @@ self: { ]; description = "Bidirectional Two-level Transformation of XML Schemas"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multihash" = callPackage @@ -182223,8 +171089,6 @@ self: { ]; description = "Multihash library and CLI executable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multihash-cryptonite" = callPackage @@ -182262,7 +171126,6 @@ self: { description = "CBOR encoding of multihashes"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multihashmap" = callPackage @@ -182295,8 +171158,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq weigh ]; description = "Comprehensive and efficient (multi)linear algebra implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multilinear-io" = callPackage @@ -182320,8 +171181,6 @@ self: { ]; description = "Conduit-based input/output capability for multilinear package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multimap" = callPackage @@ -182376,8 +171235,6 @@ self: { ]; description = "Folding data with multiple named passes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multipath" = callPackage @@ -182389,8 +171246,6 @@ self: { libraryHaskellDepends = [ base parsec utf8-string ]; description = "Parser and builder for unix-path-like objects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multiplate" = callPackage @@ -182417,8 +171272,6 @@ self: { libraryHaskellDepends = [ base multiplate transformers ]; description = "Shorter, more generic functions for Multiplate"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multiplicity" = callPackage @@ -182435,8 +171288,6 @@ self: { ]; description = "Wrapper program for duplicity, adding config files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multipool" = callPackage @@ -182501,8 +171352,6 @@ self: { ]; description = "Read and write appropriately from both master and replicated postgresql instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multipool-postgresql-simple" = callPackage @@ -182546,8 +171395,6 @@ self: { testHaskellDepends = [ base ]; description = "Generic programming for families of recursive datatypes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multirec-alt-deriver" = callPackage @@ -182563,8 +171410,6 @@ self: { ]; description = "Alternative multirec instances deriver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multirec-binary" = callPackage @@ -182576,8 +171421,6 @@ self: { libraryHaskellDepends = [ base binary multirec ]; description = "Generic Data.Binary instances using MultiRec."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multiset" = callPackage @@ -182619,8 +171462,6 @@ self: { libraryHaskellDepends = [ base haskell98 stm ]; description = "Multi-set rewrite rules with guards and a parallel execution scheme"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multistate" = callPackage @@ -182669,8 +171510,6 @@ self: { ]; description = "Multivariant assignments generation language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "multivector" = callPackage @@ -182711,8 +171550,6 @@ self: { ]; description = "Static blog generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "murder" = callPackage @@ -182729,8 +171566,6 @@ self: { ]; description = "MUtually Recursive Definitions Explicitly Represented"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "murmur" = callPackage @@ -182756,8 +171591,6 @@ self: { testHaskellDepends = [ base ]; description = "Simple CUI Twitter Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "murmur-hash" = callPackage @@ -182789,8 +171622,6 @@ self: { ]; description = "Pure Haskell implementation of the MurmurHash3 x86_32 algorithm"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "murmurhash3" = callPackage @@ -182802,8 +171633,6 @@ self: { libraryHaskellDepends = [ haskell2010 ]; description = "32-bit non-cryptographic hashing"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mushu" = callPackage @@ -182830,8 +171659,6 @@ self: { testHaskellDepends = [ base classy-prelude ]; description = "Minimalist MPD client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-articulation" = callPackage @@ -182896,8 +171723,6 @@ self: { ]; description = "Diagrams-based visualization of musical data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-parts" = callPackage @@ -182920,8 +171745,6 @@ self: { ]; description = "Musical instruments, parts and playing techniques"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-pitch" = callPackage @@ -182939,8 +171762,6 @@ self: { ]; description = "Musical pitch representation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-pitch-literal" = callPackage @@ -182981,8 +171802,6 @@ self: { testHaskellDepends = [ base process tasty tasty-golden ]; description = "Some useful preludes for the Music Suite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-score" = callPackage @@ -183006,8 +171825,6 @@ self: { ]; description = "Musical score and part representation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-sibelius" = callPackage @@ -183027,8 +171844,6 @@ self: { ]; description = "Interaction with Sibelius"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-suite" = callPackage @@ -183048,8 +171863,6 @@ self: { doHaddock = false; description = "A set of libraries for composition, analysis and manipulation of music"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "music-util" = callPackage @@ -183067,8 +171880,6 @@ self: { ]; description = "Utility for developing the Music Suite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "musicScroll" = callPackage @@ -183093,8 +171904,6 @@ self: { executablePkgconfigDepends = [ gtk3 ]; description = "Supply your tunes info without leaving your music player"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gtk3;}; "musicbrainz-email" = callPackage @@ -183128,8 +171937,6 @@ self: { ]; description = "Send an email to all MusicBrainz editors"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "musicw" = callPackage @@ -183165,8 +171972,6 @@ self: { ]; description = "MusicXML format encoded as Haskell type and functions of reading and writting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "musicxml2" = callPackage @@ -183184,8 +171989,6 @@ self: { ]; description = "A representation of the MusicXML format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mustache" = callPackage @@ -183239,8 +172042,6 @@ self: { ]; description = "Straight implementation of mustache templates"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mustache2hs" = callPackage @@ -183315,8 +172116,6 @@ self: { ]; description = "iteratees based upon mutable buffers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mutable-lens" = callPackage @@ -183353,8 +172152,6 @@ self: { ]; description = "Watches your screensaver and (un)mutes music when you (un)lock the screen"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mvar-lock" = callPackage @@ -183366,8 +172163,6 @@ self: { libraryHaskellDepends = [ base safe-exceptions ]; description = "A trivial lock based on MVar"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mvc" = callPackage @@ -183384,8 +172179,6 @@ self: { ]; description = "Model-view-controller"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mvc-updates" = callPackage @@ -183397,8 +172190,6 @@ self: { libraryHaskellDepends = [ async base foldl mvc ]; description = "Concurrent and combinable updates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mvclient" = callPackage @@ -183417,8 +172208,6 @@ self: { ]; description = "Client library for metaverse systems like Second Life"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mwc-probability" = callPackage @@ -183552,8 +172341,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit vector ]; description = "MXNet interface in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) mxnet;}; "mxnet-dataiter" = callPackage @@ -183571,8 +172358,6 @@ self: { testHaskellDepends = [ base hspec mxnet streaming ]; description = "mxnet dataiters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mxnet-examples" = callPackage @@ -183586,8 +172371,6 @@ self: { executableHaskellDepends = [ base mxnet ]; description = "Examples for MXNet in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mxnet-nn" = callPackage @@ -183613,8 +172396,6 @@ self: { ]; description = "Train a neural network with MXNet in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mxnet-nnvm" = callPackage @@ -183628,8 +172409,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "NNVM interface in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) mxnet;}; "my-package-testing" = callPackage @@ -183654,8 +172433,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "my-test-docs" = callPackage @@ -183680,8 +172457,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "myTestlll" = callPackage @@ -183706,8 +172481,6 @@ self: { ]; description = "None"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "myanimelist-export" = callPackage @@ -183731,8 +172504,6 @@ self: { ]; description = "Export from MyAnimeList"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mybitcoin-sci" = callPackage @@ -183769,8 +172540,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Haskell binding to the Myo armband"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mysnapsession" = callPackage @@ -183787,8 +172556,6 @@ self: { ]; description = "Sessions and continuations for Snap web apps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mysnapsession-example" = callPackage @@ -183808,8 +172575,6 @@ self: { ]; description = "Example projects using mysnapsession"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mysql" = callPackage @@ -183842,8 +172607,6 @@ self: { ]; description = "An extensible mysql effect using extensible-effects and mysql-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mysql-haskell" = callPackage @@ -183898,8 +172661,6 @@ self: { ]; description = "TLS support for mysql-haskell package using openssl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mysql-simple" = callPackage @@ -183933,8 +172694,6 @@ self: { ]; description = "Quasi-quoter for use with mysql-simple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mysql-simple-typed" = callPackage @@ -183950,8 +172709,6 @@ self: { ]; description = "Typed extension to mysql simple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mystem" = callPackage @@ -183970,8 +172727,6 @@ self: { executableHaskellDepends = [ base text ]; description = "Bindings for Mystem morphological analyzer executabe"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mywatch" = callPackage @@ -183996,8 +172751,6 @@ self: { ]; description = "Web application to view and kill MySQL queries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "myxine-client" = callPackage @@ -184020,8 +172773,6 @@ self: { testHaskellDepends = [ bytestring text ]; description = "A Haskell client for the Myxine GUI server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "mzv" = callPackage @@ -184033,8 +172784,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Implementation of the \"Monads, Zippers and Views\" (Schrijvers and Oliveira, ICFP'11)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "n-ary-functor" = callPackage @@ -184078,8 +172827,6 @@ self: { libraryHaskellDepends = [ base singletons vector ]; description = "Homogeneous tuples of arbitrary length"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "n2o" = callPackage @@ -184124,8 +172871,6 @@ self: { ]; description = "N2O Protocols Starter Pack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "n2o-web" = callPackage @@ -184144,8 +172889,6 @@ self: { ]; description = "N2O adapter for WebSockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nagios-check" = callPackage @@ -184215,8 +172958,6 @@ self: { ]; description = "Monitor ekg metrics via Nagios"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nakadi-client" = callPackage @@ -184255,8 +172996,6 @@ self: { ]; description = "Client library for the Nakadi Event Broker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "namecoin-update" = callPackage @@ -184311,8 +173050,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A named lock that is created on demand"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "named-records" = callPackage @@ -184335,8 +173072,6 @@ self: { libraryHaskellDepends = [ base named servant ]; description = "support records and named (from the named package) parameters in servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "named-servant-client" = callPackage @@ -184352,8 +173087,6 @@ self: { ]; description = "client support for named-servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "named-servant-server" = callPackage @@ -184369,8 +173102,6 @@ self: { ]; description = "server support for named-servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "named-sop" = callPackage @@ -184383,8 +173114,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Dependently-typed sums and products, tagged by field name"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "namelist" = callPackage @@ -184403,8 +173132,6 @@ self: { ]; description = "fortran90 namelist parser/pretty printer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "names" = callPackage @@ -184439,8 +173166,6 @@ self: { testHaskellDepends = [ base ]; description = "A Generic Haskell library for managing namespaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nano-cryptr" = callPackage @@ -184481,8 +173206,6 @@ self: { librarySystemDepends = [ openssl ]; description = "Bindings to OpenSSL HMAC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "nano-md5" = callPackage @@ -184497,8 +173220,6 @@ self: { librarySystemDepends = [ openssl ]; description = "Efficient, ByteString bindings to OpenSSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "nanoAgda" = callPackage @@ -184529,8 +173250,6 @@ self: { librarySystemDepends = [ ncurses ]; description = "Simple Curses binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses;}; "nanomsg" = callPackage @@ -184543,8 +173262,6 @@ self: { librarySystemDepends = [ nanomsg ]; description = "nanomsg - scalability protocols library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) nanomsg;}; "nanomsg-haskell" = callPackage @@ -184569,8 +173286,6 @@ self: { ]; description = "Bindings to the nanomsg library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) nanomsg;}; "nanoparsec" = callPackage @@ -184582,8 +173297,6 @@ self: { libraryHaskellDepends = [ base bytestring ListLike ]; description = "An implementation of attoparsec-like parser around list-like"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nanospec" = callPackage @@ -184617,8 +173330,6 @@ self: { testHaskellDepends = [ base containers hspec inline-c QuickCheck ]; description = "Haskell bindings for nanovg"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {GLEW = null; inherit (pkgs) glew; inherit (pkgs) libGL; inherit (pkgs) libGLU;}; @@ -184637,8 +173348,6 @@ self: { ]; description = "Simple interface to rendering with NanoVG"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nanq" = callPackage @@ -184658,8 +173367,6 @@ self: { ]; description = "Performs 漢字検定 (Japan Kanji Aptitude Test) level analysis on given Kanji"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "naperian" = callPackage @@ -184677,8 +173384,6 @@ self: { ]; description = "Efficient representable functors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "naqsha" = callPackage @@ -184697,8 +173402,6 @@ self: { doHaddock = false; description = "A library for working with anything map related"; license = "(Apache-2.0 OR BSD-3-Clause)"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "narc" = callPackage @@ -184710,8 +173413,6 @@ self: { libraryHaskellDepends = [ base HDBC HUnit mtl QuickCheck random ]; description = "Query SQL databases using Nested Relational Calculus embedded in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nat" = callPackage @@ -184735,8 +173436,6 @@ self: { testHaskellDepends = [ base doctest hedgehog QuickCheck ]; description = "Variable-sized numbers from type-level nats"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nationstates" = callPackage @@ -184753,8 +173452,6 @@ self: { ]; description = "NationStates API client"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "native" = callPackage @@ -184814,8 +173511,6 @@ self: { benchmarkHaskellDepends = [ base criterion time ]; description = "Another Haskell client for NATS (https://nats.io)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nats-queue" = callPackage @@ -184836,8 +173531,6 @@ self: { ]; description = "Haskell API for NATS messaging system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "natural" = callPackage @@ -184856,8 +173549,6 @@ self: { ]; description = "Natural number"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "natural-arithmetic" = callPackage @@ -184898,8 +173589,6 @@ self: { ]; description = "Natural numbers tagged with a type-level representation of the number"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "natural-numbers" = callPackage @@ -184977,8 +173666,6 @@ self: { ]; description = "Interface to Naver Translate"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nbt" = callPackage @@ -184998,8 +173685,6 @@ self: { ]; description = "A parser/serializer for Minecraft's Named Binary Tag (NBT) data format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nc-indicators" = callPackage @@ -185062,8 +173747,6 @@ self: { executableHaskellDepends = [ base filepath parsec ]; description = "A Fast Retargetable Template Engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neat-interpolation" = callPackage @@ -185098,8 +173781,6 @@ self: { ]; description = "ASCII-fied arrow notation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neet" = callPackage @@ -185116,8 +173797,6 @@ self: { ]; description = "A NEAT library for Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nehe-tuts" = callPackage @@ -185137,8 +173816,6 @@ self: { ]; description = "Port of the NeHe OpenGL tutorials to Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neil" = callPackage @@ -185168,8 +173845,6 @@ self: { libraryHaskellDepends = [ base failure transformers ]; description = "Provide versions of Either with good monad and applicative instances. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neko-lib" = callPackage @@ -185190,8 +173865,6 @@ self: { ]; description = "Neko VM code generation and disassembly library"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neko-obfs" = callPackage @@ -185245,8 +173918,6 @@ self: { ]; description = "A collection of Nemesis tasks to bootstrap a Haskell project with a focus on continuous integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neptune-backend" = callPackage @@ -185280,8 +173951,6 @@ self: { ]; description = "Neptune Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nerf" = callPackage @@ -185308,8 +173977,6 @@ self: { ]; description = "Nerf, a named entity recognition tool based on linear-chain CRFs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nero" = callPackage @@ -185328,8 +173995,6 @@ self: { ]; description = "Lens-based HTTP toolkit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nero-wai" = callPackage @@ -185345,8 +174010,6 @@ self: { ]; description = "WAI adapter for Nero server applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nero-warp" = callPackage @@ -185358,8 +174021,6 @@ self: { libraryHaskellDepends = [ base nero nero-wai warp ]; description = "Run Nero server applications with Warp"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nest" = callPackage @@ -185375,8 +174036,6 @@ self: { ]; testHaskellDepends = [ base bytestring containers hedgehog text ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nested-routes" = callPackage @@ -185406,8 +174065,6 @@ self: { ]; description = "Declarative, compositional Wai responses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nested-sequence" = callPackage @@ -185424,8 +174081,6 @@ self: { ]; description = "List-like data structures with O(log(n)) random access"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nested-sets" = callPackage @@ -185454,8 +174109,6 @@ self: { ]; description = "A library for nested maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "net-concurrent" = callPackage @@ -185567,8 +174220,6 @@ self: { ]; description = "A graph database middleware to maintain a time-varying graph"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "net-spider-cli" = callPackage @@ -185589,8 +174240,6 @@ self: { ]; description = "CLI option parsers for NetSpider objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "net-spider-pangraph" = callPackage @@ -185609,8 +174258,6 @@ self: { ]; description = "Conversion between net-spider and pangraph"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "net-spider-rpl" = callPackage @@ -185632,8 +174279,6 @@ self: { ]; description = "NetSpider data model and utility for RPL networks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "net-spider-rpl-cli" = callPackage @@ -185660,8 +174305,6 @@ self: { ]; description = "CLI executable of NetSpider.RPL."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netclock" = callPackage @@ -185675,8 +174318,6 @@ self: { libraryHaskellDepends = [ base bytestring hosc network ]; description = "Netclock protocol"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netcode-io" = callPackage @@ -185722,8 +174363,6 @@ self: { ]; description = "The NetCore compiler and runtime system for OpenFlow networks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netease-fm" = callPackage @@ -185752,8 +174391,6 @@ self: { ]; description = "NetEase Cloud Music FM client in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netlib-carray" = callPackage @@ -185813,8 +174450,6 @@ self: { executableHaskellDepends = [ base HTF random ]; description = "Enumerator tools for text-based network protocols"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netlink" = callPackage @@ -185911,8 +174546,6 @@ self: { ]; description = "Contract normaliser and simulator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netspec" = callPackage @@ -185929,8 +174562,6 @@ self: { ]; description = "Simplify static Networking tasks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netstring-enumerator" = callPackage @@ -185944,8 +174575,6 @@ self: { ]; description = "Enumerator-based netstring parsing"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nettle" = callPackage @@ -185987,8 +174616,6 @@ self: { ]; description = "FRP for controlling networks of OpenFlow switches"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nettle-netkit" = callPackage @@ -186004,8 +174631,6 @@ self: { ]; description = "DSL for describing OpenFlow networks, and a compiler generating NetKit labs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nettle-openflow" = callPackage @@ -186022,8 +174647,6 @@ self: { ]; description = "OpenFlow protocol messages, binary formats, and servers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netwire" = callPackage @@ -186083,8 +174706,6 @@ self: { ]; description = "JavaScript instance of netwire-input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "netwire-vinylglfw-examples" = callPackage @@ -186107,8 +174728,6 @@ self: { ]; description = "Netwire/GLFW/VinylGL input handling demo"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network_2_6_3_1" = callPackage @@ -186179,8 +174798,6 @@ self: { ]; description = "IP data structures and textual representation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-anonymous-i2p" = callPackage @@ -186203,8 +174820,6 @@ self: { ]; description = "Haskell API for I2P anonymous networking"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-anonymous-tor" = callPackage @@ -186234,8 +174849,6 @@ self: { ]; description = "Haskell API for Tor anonymous networking"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-api-support" = callPackage @@ -186253,8 +174866,6 @@ self: { ]; description = "Toolkit for building http client libraries over Network.Http.Conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-arbitrary" = callPackage @@ -186276,8 +174887,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Arbitrary Instances for Network Types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-attoparsec" = callPackage @@ -186301,8 +174910,6 @@ self: { doCheck = false; description = "Utility functions for running a parser against a socket"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-bitcoin" = callPackage @@ -186325,8 +174932,6 @@ self: { ]; description = "An interface to bitcoind"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-bsd" = callPackage @@ -186361,8 +174966,6 @@ self: { ]; description = "Linux NetworkNameSpace Builder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-byte-order" = callPackage @@ -186390,8 +174993,6 @@ self: { libraryHaskellDepends = [ base bytestring network unix ]; description = "Fast, memory-efficient, low-level networking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-carbon" = callPackage @@ -186405,8 +175006,6 @@ self: { ]; description = "A Haskell implementation of the Carbon protocol (part of the Graphite monitoring tools)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-conduit" = callPackage @@ -186454,8 +175053,6 @@ self: { ]; description = "A wrapper around a generic stream-like connection"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-data" = callPackage @@ -186506,8 +175103,6 @@ self: { ]; description = "Domain Name System data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-enumerator" = callPackage @@ -186523,8 +175118,6 @@ self: { ]; description = "Enumerators for network sockets"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-fancy" = callPackage @@ -186547,8 +175140,6 @@ self: { libraryHaskellDepends = [ base bytestring hans parsec ]; description = "HaNS to Network shims for easier HaNS integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-house" = callPackage @@ -186560,8 +175151,6 @@ self: { libraryHaskellDepends = [ array base containers mtl ]; description = "data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-info" = callPackage @@ -186586,8 +175175,6 @@ self: { libraryHaskellDepends = [ base bytestring ioctl network ]; description = "Haskell bindings for the ifreq structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-ip" = callPackage @@ -186669,8 +175256,6 @@ self: { ]; description = "WebSocket backend for MessagePack RPC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-metrics" = callPackage @@ -186706,8 +175291,6 @@ self: { ]; description = "A ByteString based library for writing HTTP(S) servers and clients"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-msg" = callPackage @@ -186742,8 +175325,6 @@ self: { testHaskellDepends = [ async base bytestring hspec mtl network ]; description = "A MessagePack-RPC Implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-multicast" = callPackage @@ -186771,8 +175352,6 @@ self: { ]; description = "Haskell bindings for low-level packet sockets (AF_PACKET)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-packet-linux" = callPackage @@ -186790,8 +175369,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Types for working with Linux packet sockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-pgi" = callPackage @@ -186824,8 +175401,6 @@ self: { ]; description = "Client library for the XMPP protocol"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-rpca" = callPackage @@ -186843,8 +175418,6 @@ self: { ]; description = "A cross-platform RPC library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-run" = callPackage @@ -186870,8 +175443,6 @@ self: { executableHaskellDepends = [ base network unix ]; description = "A light abstraction over sockets & co. for servers"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-service" = callPackage @@ -186887,8 +175458,6 @@ self: { ]; description = "Provide a service at the data type level"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-simple" = callPackage @@ -186920,8 +175489,6 @@ self: { ]; description = "network-simple for resolved addresses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-simple-tls" = callPackage @@ -186972,8 +175539,6 @@ self: { ]; description = "Simple interface to TLS secured WebSockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-socket-options" = callPackage @@ -186985,8 +175550,6 @@ self: { libraryHaskellDepends = [ base network ]; description = "Type-safe, portable alternative to getSocketOption/setSocketOption"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-stream" = callPackage @@ -187003,8 +175566,6 @@ self: { ]; description = "ByteString and Text streams for networking"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-topic-models" = callPackage @@ -187026,8 +175587,6 @@ self: { ]; description = "A few network topic model implementations for bayes-stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-transport" = callPackage @@ -187068,8 +175627,6 @@ self: { ]; description = "AMQP-based transport layer for distributed-process (aka Cloud Haskell)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-transport-composed" = callPackage @@ -187101,8 +175658,6 @@ self: { ]; description = "In-memory instantiation of Network.Transport"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-transport-tcp" = callPackage @@ -187229,8 +175784,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "FromJSON and ToJSON Instances for Network.URI"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-uri-lenses" = callPackage @@ -187270,8 +175823,6 @@ self: { ]; description = "VoiceText Web API wrapper"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-wai-router" = callPackage @@ -187283,8 +175834,6 @@ self: { libraryHaskellDepends = [ base wai ]; description = "A routing library for wai"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "network-websocket" = callPackage @@ -187298,8 +175847,6 @@ self: { libraryHaskellDepends = [ base haskell98 network webserver ]; description = "WebSocket library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "networked-game" = callPackage @@ -187317,8 +175864,6 @@ self: { ]; description = "Networked-game support library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neural" = callPackage @@ -187351,8 +175896,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Neural Networks in native Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neural-network-base" = callPackage @@ -187383,8 +175926,6 @@ self: { ]; description = "Yet Another High Performance and Extendable Neural Network in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "neural-network-hmatrix" = callPackage @@ -187402,8 +175943,6 @@ self: { librarySystemDepends = [ blas ]; description = "Yet Another High Performance and Extendable Neural Network in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) blas;}; "neuron" = callPackage @@ -187505,8 +176044,6 @@ self: { ]; description = "Library implementing the NewHope cryptographic key-exchange protocol"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newports" = callPackage @@ -187520,8 +176057,6 @@ self: { executableHaskellDepends = [ base directory old-time ]; description = "List ports newer than N days on a FreeBSD system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newsletter" = callPackage @@ -187550,8 +176085,6 @@ self: { ]; description = "A basic newsletter implimentation, using various backends"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newsletter-mailgun" = callPackage @@ -187567,8 +176100,6 @@ self: { ]; description = "A mailgun backend for the newsletter package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newsynth" = callPackage @@ -187606,8 +176137,6 @@ self: { executableHaskellDepends = [ base cmdargs containers mtl ]; description = "A trivially simple app to create things from simple templates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newtype" = callPackage @@ -187637,8 +176166,6 @@ self: { ]; description = "Instance derivers for newtype wrappers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newtype-generics" = callPackage @@ -187671,8 +176198,6 @@ self: { ]; description = "A template haskell deriver to create Control.Newtype instances."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newtype-zoo" = callPackage @@ -187689,8 +176214,6 @@ self: { ]; description = "Newtype Wrapper Zoo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "newtyper" = callPackage @@ -187714,8 +176237,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A concurrency primitive for a slow consumer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nextstep-plist" = callPackage @@ -187727,8 +176248,6 @@ self: { libraryHaskellDepends = [ base parsec pretty QuickCheck ]; description = "NextStep style plist parser and printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nf" = callPackage @@ -187755,8 +176274,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "libnfc bindings"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {nfc = null;}; "ngram" = callPackage @@ -187796,8 +176313,6 @@ self: { executableHaskellDepends = [ base parseargs ]; description = "Ngrams loader based on http://www.ngrams.info format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ngx-export" = callPackage @@ -187851,8 +176366,6 @@ self: { ]; description = "More extra tools for Nginx haskell module"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "niagra" = callPackage @@ -187869,8 +176382,6 @@ self: { testHaskellDepends = [ base HUnit QuickCheck ]; description = "High performance CSS EDSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nibblestring" = callPackage @@ -187891,8 +176402,6 @@ self: { ]; description = "Packed, strict nibble arrays with a list interface (ByteString for nibbles)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nice-html" = callPackage @@ -187916,8 +176425,6 @@ self: { ]; description = "A fast and nice HTML templating library with distinct compilation/rendering phases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nicify" = callPackage @@ -187964,8 +176471,6 @@ self: { executableHaskellDepends = [ base ]; description = "Nico Nico Douga (ニコニコ動画) Comment Translator"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nikepub" = callPackage @@ -187986,8 +176491,6 @@ self: { ]; description = "Command line utility publishes Nike+ runs on blogs and Twitter"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nimber" = callPackage @@ -188037,8 +176540,6 @@ self: { ]; description = "IDL compiler and RPC/distributed object framework for microservices"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nist-beacon" = callPackage @@ -188063,8 +176564,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Haskell bindings for Nitro"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "niv" = callPackage @@ -188120,8 +176619,6 @@ self: { executableHaskellDepends = [ base ]; description = "Convenient utility for distributed Nix builds"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nix-deploy" = callPackage @@ -188140,8 +176637,6 @@ self: { ]; description = "Deploy Nix-built software to a NixOS machine"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nix-derivation" = callPackage @@ -188200,8 +176695,6 @@ self: { testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; description = "Evaluate Haskell expressions using Nix to get packages"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nix-freeze-tree" = callPackage @@ -188231,8 +176724,6 @@ self: { doHaddock = false; description = "Convert a tree of files into fixed-output derivations"; license = lib.licenses.agpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nix-narinfo" = callPackage @@ -188293,8 +176784,6 @@ self: { ]; description = "Lightweight dependency management with Nix"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nix-tools" = callPackage @@ -188325,8 +176814,6 @@ self: { ]; description = "cabal/stack to nix translation tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nix-tree" = callPackage @@ -188421,8 +176908,6 @@ self: { ]; description = "Generate nix expressions from npm packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nixos-types" = callPackage @@ -188458,8 +176943,6 @@ self: { ]; description = "Tool for semi-automatic updating of nixpkgs repository"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nkjp" = callPackage @@ -188478,8 +176961,6 @@ self: { ]; description = "Manipulating the National Corpus of Polish (NKJP)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nlopt-haskell" = callPackage @@ -188504,8 +176985,6 @@ self: { libraryHaskellDepends = [ base containers strict ]; description = "Scoring functions commonly used for evaluation in NLP and IR"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nlp-scores-scripts" = callPackage @@ -188521,8 +177000,6 @@ self: { ]; description = "NLP scoring command-line programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nm" = callPackage @@ -188539,8 +177016,6 @@ self: { executableHaskellDepends = [ base ]; description = "Network Manager, binding to libnm-glib"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {g = null; inherit (pkgs) glib; libnm-glib = null; nm-glib = null;}; @@ -188597,8 +177072,6 @@ self: { ]; description = "Library to connect to an NNTP Server"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "no-buffering-workaround" = callPackage @@ -188622,8 +177095,6 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Role annotations without -XRoleAnnotations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "no-value" = callPackage @@ -188657,8 +177128,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Math in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nofib-analyse" = callPackage @@ -188672,8 +177141,6 @@ self: { executableHaskellDepends = [ array base containers regex-compat ]; description = "Parse and compare nofib runs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nofib-analyze" = callPackage @@ -188687,8 +177154,6 @@ self: { executableHaskellDepends = [ array base containers regex-compat ]; description = "Parse and compare nofib runs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "noise" = callPackage @@ -188712,8 +177177,6 @@ self: { ]; description = "A friendly language for graphic design"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "noli" = callPackage @@ -188730,8 +177193,6 @@ self: { ]; description = "A static site generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nom" = callPackage @@ -188756,8 +177217,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Name-binding & alpha-equivalence"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nominal" = callPackage @@ -188970,8 +177429,6 @@ self: { testHaskellDepends = [ base checkers QuickCheck ]; description = "The Zipper for NonEmpty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "non-negative" = callPackage @@ -189060,8 +177517,6 @@ self: { testHaskellDepends = [ base hedgehog hedgehog-classes ]; description = "nonempty structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nonempty-vector" = callPackage @@ -189206,8 +177661,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion deepseq ]; description = "Normalization insensitive string comparison"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "normalize" = callPackage @@ -189276,8 +177729,6 @@ self: { ]; description = "examples for not-gloss"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "not-in-base" = callPackage @@ -189302,8 +177753,6 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Avoiding the C preprocessor via cunning use of Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nothunks" = callPackage @@ -189349,8 +177798,6 @@ self: { transformers tuple ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "notmuch" = callPackage @@ -189388,8 +177835,6 @@ self: { executableSystemDepends = [ notmuch ]; description = "Binding for notmuch MUA library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) notmuch;}; "notmuch-web" = callPackage @@ -189427,8 +177872,6 @@ self: { ]; description = "A web interface to the notmuch email indexer"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "notzero" = callPackage @@ -189482,8 +177925,6 @@ self: { ]; description = "Zeit Now haskell-side integration and introspection tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nowdoc" = callPackage @@ -189511,8 +177952,6 @@ self: { libraryHaskellDepends = [ base containers numeric-prelude primes ]; description = "NumericPrelude extras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "np-linear" = callPackage @@ -189528,8 +177967,6 @@ self: { ]; description = "Linear algebra for the numeric-prelude framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nptools" = callPackage @@ -189548,8 +177985,6 @@ self: { ]; description = "A collection of random tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nqe" = callPackage @@ -189716,8 +178151,6 @@ self: { ]; description = "Client library for NTP control messaging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ntrip-client" = callPackage @@ -189742,8 +178175,6 @@ self: { ]; description = "NTRIP client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ntype" = callPackage @@ -189767,8 +178198,6 @@ self: { testHaskellDepends = [ base vector ]; description = "Multidimensional arrays, Linear algebra, Numerical analysis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "null-canvas" = callPackage @@ -189786,8 +178215,6 @@ self: { ]; description = "HTML5 Canvas Graphics Library - forked Blank Canvas"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nullary" = callPackage @@ -189799,8 +178226,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A package for working with nullary type classes"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nullpipe" = callPackage @@ -189813,8 +178238,6 @@ self: { testHaskellDepends = [ base hspec pipes ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "num-non-negative" = callPackage @@ -189882,8 +178305,6 @@ self: { libraryHaskellDepends = [ base call-stack semigroups ]; description = "A sequence of semigroups, for composing stuff in multiple spatial directions"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numbering" = callPackage @@ -189932,8 +178353,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Convert numbers to number words"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numerals-base" = callPackage @@ -189955,8 +178374,6 @@ self: { ]; description = "Convert numbers to number words"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numeric-domains" = callPackage @@ -190018,8 +178435,6 @@ self: { ]; description = "Ode solvers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numeric-prelude" = callPackage @@ -190060,8 +178475,6 @@ self: { doCheck = false; description = "Quasi-quoters for numbers of different bases"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numeric-quest" = callPackage @@ -190088,8 +178501,6 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck ]; description = "A framework for numeric ranges"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numeric-tools" = callPackage @@ -190123,8 +178534,6 @@ self: { ]; description = "core package for Numerical Haskell project"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numericpeano" = callPackage @@ -190184,8 +178593,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Multi-dimensional array interface for numhask"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numhask-free" = callPackage @@ -190202,8 +178609,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "numerical free algebras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numhask-hedgehog" = callPackage @@ -190220,8 +178625,6 @@ self: { testHaskellDepends = [ base hedgehog numhask numhask-prelude ]; description = "Laws and tests for numhask"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numhask-histogram" = callPackage @@ -190238,8 +178641,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "See readme.md"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numhask-prelude" = callPackage @@ -190252,8 +178653,6 @@ self: { testHaskellDepends = [ doctest ]; description = "A numeric prelude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numhask-range" = callPackage @@ -190274,8 +178673,6 @@ self: { ]; description = "Numbers that are range representations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numhask-space" = callPackage @@ -190294,8 +178691,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Numerical spaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "numhask-test" = callPackage @@ -190312,8 +178707,6 @@ self: { testHaskellDepends = [ base numhask-prelude QuickCheck tasty ]; description = "Laws and tests for numhask"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nums" = callPackage @@ -190531,8 +178924,6 @@ self: { ]; description = "Client for the Nylas API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nymphaea" = callPackage @@ -190551,8 +178942,6 @@ self: { ]; description = "An interactive GUI for manipulating L-systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "nyx-game" = callPackage @@ -190579,8 +178968,6 @@ self: { ]; description = "A bullet-hell game made with SDL2"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "o-clock" = callPackage @@ -190628,8 +179015,6 @@ self: { ]; description = "Client to the OANDA REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oasis-xrd" = callPackage @@ -190652,8 +179037,6 @@ self: { ]; description = "Extensible Resource Descriptor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oauth10a" = callPackage @@ -190698,8 +179081,6 @@ self: { ]; description = "OAuth2 jwt-bearer client flow as per rfc7523"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oauthenticated" = callPackage @@ -190725,8 +179106,6 @@ self: { ]; description = "Simple OAuth for http-client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "obd" = callPackage @@ -190751,8 +179130,6 @@ self: { testHaskellDepends = [ base ]; description = "Communicate to OBD interfaces over ELM327"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "obdd" = callPackage @@ -190769,8 +179146,6 @@ self: { testHaskellDepends = [ array base containers text ]; description = "Ordered Reduced Binary Decision Diagrams"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oberon0" = callPackage @@ -190790,8 +179165,6 @@ self: { doHaddock = false; description = "Oberon0 Compiler"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "obj" = callPackage @@ -190811,8 +179184,6 @@ self: { ]; description = "Reads and writes obj models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "objectid" = callPackage @@ -190833,8 +179204,6 @@ self: { ]; description = "Rather unique identifier for things that need to be stored"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "objective" = callPackage @@ -190853,8 +179222,6 @@ self: { ]; description = "Composable objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oblivious-transfer" = callPackage @@ -190878,8 +179245,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "An implementation of the Oblivious Transfer protocol in Haskell"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "observable" = callPackage @@ -190929,8 +179294,6 @@ self: { ]; description = "Convert Haskell types in OCaml types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ocap-io" = callPackage @@ -190961,8 +179324,6 @@ self: { ]; description = "Owned channels in the Ownership Monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ochintin-daicho" = callPackage @@ -191003,8 +179364,6 @@ self: { ]; description = "Parse Rocket League replays"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "octohat" = callPackage @@ -191035,8 +179394,6 @@ self: { ]; description = "A tested, minimal wrapper around GitHub's API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "octopus" = callPackage @@ -191057,8 +179414,6 @@ self: { ]; description = "Lisp with more dynamism, more power, more simplicity"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oculus" = callPackage @@ -191078,8 +179433,6 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libGL; inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXinerama; ovr = null; inherit (pkgs) systemd;}; @@ -191110,8 +179463,6 @@ self: { benchmarkHaskellDepends = [ async base text weigh ]; description = "Haskell binding to the ODBC API, aimed at SQL Server driver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) unixODBC;}; "odd-jobs" = callPackage @@ -191163,8 +179514,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A full-featured PostgreSQL-backed job queue (with an admin UI)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oden-go-packages" = callPackage @@ -191180,8 +179529,6 @@ self: { ]; description = "Provides Go package metadata"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "odpic-raw" = callPackage @@ -191238,8 +179585,6 @@ self: { ]; description = "Interface for Online Encyclopedia of Integer Sequences (OEIS)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "off-simple" = callPackage @@ -191251,8 +179596,6 @@ self: { libraryHaskellDepends = [ base parsec3 vector ]; description = "A parser for simplified-syntax OFF files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ofx" = callPackage @@ -191283,8 +179626,6 @@ self: { ]; description = "A lightweight markup language for story writers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ohloh-hs" = callPackage @@ -191308,8 +179649,6 @@ self: { ]; description = "Interface to the Ohloh API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oi" = callPackage @@ -191326,8 +179665,6 @@ self: { executableHaskellDepends = [ base directory filepath parallel ]; description = "Library for purely functional lazy interactions with the outer world"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oidc-client" = callPackage @@ -191353,8 +179690,6 @@ self: { ]; description = "OpenID Connect 1.0 library for RP"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ois-input-manager" = callPackage @@ -191367,8 +179702,6 @@ self: { librarySystemDepends = [ OIS ]; description = "wrapper for OIS input manager for use with hogre"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {OIS = null;}; "old-locale" = callPackage @@ -191432,8 +179765,6 @@ self: { ]; description = "An OpenLayers JavaScript Wrapper and Webframework with snaplet-fay"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "om-actor" = callPackage @@ -191445,8 +179776,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Actor pattern utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "om-doh" = callPackage @@ -191463,8 +179792,6 @@ self: { ]; description = "om-doh"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "om-elm" = callPackage @@ -191482,8 +179809,6 @@ self: { ]; description = "Haskell utilities for building embedded Elm programs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "om-fail" = callPackage @@ -191498,8 +179823,6 @@ self: { ]; description = "Monad transformer providing MonadFail"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "om-http-logging" = callPackage @@ -191515,8 +179838,6 @@ self: { ]; description = "om-http-logging"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "omaketex" = callPackage @@ -191534,8 +179855,6 @@ self: { ]; description = "A simple tool to generate OMakefile for latex files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ombra" = callPackage @@ -191555,8 +179874,6 @@ self: { ]; description = "Render engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "omega" = callPackage @@ -191575,8 +179892,6 @@ self: { ]; description = "A purely functional programming language and a proof system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "omnicodec" = callPackage @@ -191622,8 +179937,6 @@ self: { ]; description = "A pretty-printer wrapper to faciliate ease of formatting during development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "on-a-horse" = callPackage @@ -191642,8 +179955,6 @@ self: { ]; description = "\"Haskell on a Horse\" - A combinatorial web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "on-demand-ssh-tunnel" = callPackage @@ -191664,8 +179975,6 @@ self: { ]; description = "Program that sends traffic through SSH tunnels on-demand"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "onama" = callPackage @@ -191677,8 +179986,6 @@ self: { libraryHaskellDepends = [ base containers parsec tagsoup ]; description = "HTML-parsing primitives for Parsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "once" = callPackage @@ -191799,8 +180106,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A never-empty list type"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "online" = callPackage @@ -191821,8 +180126,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "online-csv" = callPackage @@ -191841,8 +180144,6 @@ self: { testHaskellDepends = [ base doctest numhask-prelude ]; description = "See readme.md"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "only" = callPackage @@ -191867,8 +180168,6 @@ self: { libraryHaskellDepends = [ base ]; description = "partition lenses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "onu-course" = callPackage @@ -191880,8 +180179,6 @@ self: { libraryHaskellDepends = [ base smallcheck ]; description = "Code for the Haskell course taught at the Odessa National University in 2012"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oo-prototypes" = callPackage @@ -191905,8 +180202,6 @@ self: { testHaskellDepends = [ base containers doctest ]; description = "Common operators encouraging large-scale easy reading"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opaleye" = callPackage @@ -191955,8 +180250,6 @@ self: { ]; description = "Opaleye wrapped up in classy MTL attire"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opaleye-sqlite" = callPackage @@ -191981,8 +180274,6 @@ self: { ]; description = "An SQL-generating DSL targeting SQLite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opaleye-trans" = callPackage @@ -192004,8 +180295,6 @@ self: { ]; description = "A monad transformer for Opaleye"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-adt" = callPackage @@ -192021,8 +180310,6 @@ self: { ]; description = "Open algebraic data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-adt-tutorial" = callPackage @@ -192042,8 +180329,6 @@ self: { executableHaskellDepends = [ base ]; description = "Open algebraic data type examples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-browser" = callPackage @@ -192071,8 +180356,6 @@ self: { executableHaskellDepends = [ base basic-prelude text turtle ]; description = "Open haddock HTML documentation"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-pandoc" = callPackage @@ -192095,8 +180378,6 @@ self: { ]; description = "Conversion between markup formats"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-signals" = callPackage @@ -192109,8 +180390,6 @@ self: { testHaskellDepends = [ base ]; description = "A mechanism similar to checked exceptions that integrates with MTL and transformer stacks"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-symbology" = callPackage @@ -192138,8 +180417,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Open type representations and dynamic types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-union" = callPackage @@ -192154,8 +180431,6 @@ self: { executableHaskellDepends = [ base type-fun ]; description = "Extensible, type-safe unions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "open-witness" = callPackage @@ -192196,8 +180471,6 @@ self: { ]; description = "Unofficial OpenAI client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openai-servant" = callPackage @@ -192214,8 +180487,6 @@ self: { ]; description = "Unofficial OpenAI servant types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openapi-petstore" = callPackage @@ -192243,8 +180514,6 @@ self: { ]; description = "Auto-generated openapi-petstore API Client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openapi-typed" = callPackage @@ -192264,8 +180533,6 @@ self: { ]; description = "Types for OpenAPI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openapi3" = callPackage @@ -192337,8 +180604,6 @@ self: { ]; description = "OpenAPI3 Haskell Client Code Generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opench-meteo" = callPackage @@ -192350,8 +180615,6 @@ self: { libraryHaskellDepends = [ aeson base data-default text time ]; description = "A Haskell implementation of the Swiss Meteo Net data API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opencog-atomspace" = callPackage @@ -192432,8 +180695,6 @@ self: { libraryPkgconfigDepends = [ opencv ]; description = "Raw Haskell bindings to OpenCV >= 2.0"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) opencv;}; "opendatatable" = callPackage @@ -192445,8 +180706,6 @@ self: { libraryHaskellDepends = [ base hxt template-haskell th-lift ]; description = "A library for working with Open Data Tables"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openexchangerates" = callPackage @@ -192553,8 +180812,6 @@ self: { testHaskellDepends = [ base ]; description = "Functional interface for OpenGL 4.1+ and OpenGL ES 2.0+"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {EGL = null; GLESv2 = null;}; "openid" = callPackage @@ -192598,8 +180855,6 @@ self: { ]; description = "An OpenID Connect library that does all the heavy lifting for you"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openpgp" = callPackage @@ -192707,8 +180962,6 @@ self: { ]; description = "Haskell OpenSoundControl utilities"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opensource" = callPackage @@ -192750,8 +181003,6 @@ self: { ]; description = "Fetch OpenSSH keys from a GitHub team"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openssh-protocol" = callPackage @@ -192768,8 +181019,6 @@ self: { testHaskellDepends = [ base cereal hedgehog time ]; description = "Haskell implementation of openssh protocol primitives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openssl-createkey" = callPackage @@ -192863,8 +181112,6 @@ self: { base http-client http-types opentelemetry text ]; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opentelemetry-lightstep" = callPackage @@ -192971,8 +181218,6 @@ self: { ]; description = "Unicode characters"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opentheory-divides" = callPackage @@ -193138,8 +181383,6 @@ self: { ]; description = "An OpenTok SDK for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opentracing" = callPackage @@ -193192,8 +181435,6 @@ self: { ]; description = "Jaeger backend for OpenTracing"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opentracing-wai" = callPackage @@ -193235,8 +181476,6 @@ self: { ]; description = "Zipkin V1 backend for OpenTracing"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opentracing-zipkin-v2" = callPackage @@ -193271,8 +181510,6 @@ self: { ]; description = "Opentype loading and writing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "openweathermap" = callPackage @@ -193295,8 +181532,6 @@ self: { ]; description = "Access data at OpenWeatherMap"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "operate-do" = callPackage @@ -193313,8 +181548,6 @@ self: { testHaskellDepends = [ base doctest filemanip hspec QuickCheck ]; description = "Simple project template from stack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "operational" = callPackage @@ -193367,8 +181600,6 @@ self: { ]; description = "Interpretation functions and simple instruction sets for operational"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oplang" = callPackage @@ -193387,8 +181618,6 @@ self: { ]; description = "Compiler for OpLang, an esoteric programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "opml" = callPackage @@ -193446,8 +181675,6 @@ self: { ]; description = "Open files or URLs using associated programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optics" = callPackage @@ -193646,8 +181873,6 @@ self: { testHaskellDepends = [ attoparsec-data rerebase ]; description = "Simple command line interface arguments parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optima-for-hasql" = callPackage @@ -193663,8 +181888,6 @@ self: { ]; description = "Command-line arguments parsing for Hasql"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optimal-blocks" = callPackage @@ -193689,8 +181912,6 @@ self: { ]; description = "Optimal Block boundary determination for rsync-like behaviours"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optimization" = callPackage @@ -193706,8 +181927,6 @@ self: { ]; description = "Numerical optimization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optimusprime" = callPackage @@ -193726,8 +181945,6 @@ self: { ]; description = "A supercompiler for f-lite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "option" = callPackage @@ -193753,8 +181970,6 @@ self: { ]; description = "Using type-classes for optional function arguments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optional-args" = callPackage @@ -193796,8 +182011,6 @@ self: { testHaskellDepends = [ base chell options time ]; description = "Command-line option types for dates and times"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optparse-applicative_0_15_1_0" = callPackage @@ -193849,8 +182062,6 @@ self: { testHaskellDepends = [ attoparsec-data rerebase ]; description = "Simple command line interface arguments parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optparse-declarative" = callPackage @@ -193876,8 +182087,6 @@ self: { ]; description = "An enum-text based toolkit for optparse-applicative"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optparse-generic" = callPackage @@ -193909,8 +182118,6 @@ self: { libraryHaskellDepends = [ base optparse-applicative ]; description = "Helper functions for optparse-applicative"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "optparse-simple" = callPackage @@ -193989,8 +182196,6 @@ self: { ]; description = "Orchestration-style co-ordination EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "orchestrate" = callPackage @@ -194014,8 +182219,6 @@ self: { ]; description = "An API client for http://orchestrate.io/."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "orchid" = callPackage @@ -194036,8 +182239,6 @@ self: { ]; description = "Haskell Wiki Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "orchid-demo" = callPackage @@ -194057,8 +182258,6 @@ self: { ]; description = "Haskell Wiki Demo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ord-adhoc" = callPackage @@ -194086,8 +182285,6 @@ self: { ]; description = "Algorithms for the order maintenance problem with a safe interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "order-statistic-tree" = callPackage @@ -194120,8 +182317,6 @@ self: { ]; description = "L-Estimators for robust statistics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ordered" = callPackage @@ -194188,8 +182383,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Convert numbers to words in different languages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ordrea" = callPackage @@ -194204,8 +182397,6 @@ self: { testHaskellDepends = [ base directory process split ]; description = "Push-pull implementation of discrete-time FRP"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oref" = callPackage @@ -194220,8 +182411,6 @@ self: { testHaskellDepends = [ base containers either mtl transformers ]; description = "Owned references in the Ownership Monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "org-mode" = callPackage @@ -194239,8 +182428,6 @@ self: { testHaskellDepends = [ base megaparsec tasty tasty-hunit text ]; description = "Parser for Emacs org-mode files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "org-mode-lucid" = callPackage @@ -194255,8 +182442,6 @@ self: { ]; description = "Lucid integration for org-mode"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "org2anki" = callPackage @@ -194283,8 +182468,6 @@ self: { executableHaskellDepends = [ attoparsec base text ]; description = "Organize scala imports"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "orgmode" = callPackage @@ -194304,8 +182487,6 @@ self: { ]; description = "Org Mode library for haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "orgmode-parse" = callPackage @@ -194380,8 +182561,6 @@ self: { ]; description = "An un-SYB framework for transforming heterogenous data through folds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "orion-hs" = callPackage @@ -194422,8 +182601,6 @@ self: { testHaskellDepends = [ base hspec jwt mtl time ]; description = "Token-based authentication and authorization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ormolu" = callPackage @@ -194562,8 +182739,6 @@ self: { ]; description = "A library to handle messages in the OSC protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oscpacking" = callPackage @@ -194575,8 +182750,6 @@ self: { libraryHaskellDepends = [ base colour gloss random ]; description = "Implements an osculatory packing (kissing circles) algorithm and display"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "osdkeys" = callPackage @@ -194612,8 +182785,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "An insertion-order-preserving set"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "osm-conduit" = callPackage @@ -194633,8 +182804,6 @@ self: { ]; description = "Parse and operate on OSM data in efficient way"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "osm-download" = callPackage @@ -194656,8 +182825,6 @@ self: { ]; description = "Download Open Street Map tiles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "oso2pdf" = callPackage @@ -194676,8 +182843,6 @@ self: { ]; description = "Better conversion of Oxford Scholarship Online material to PDF"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "osx-ar" = callPackage @@ -194690,8 +182855,6 @@ self: { libraryHaskellDepends = [ base binary bytestring containers ]; description = "Parser for OS X static archive format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ot" = callPackage @@ -194712,8 +182875,6 @@ self: { ]; description = "Real-time collaborative editing with Operational Transformation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "otp-authenticator" = callPackage @@ -194739,8 +182900,6 @@ self: { ]; description = "OTP Authenticator (a la google) command line client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ottparse-pretty" = callPackage @@ -194758,8 +182917,6 @@ self: { ]; description = "Pretty-printer for Ott parse trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "outsort" = callPackage @@ -194839,8 +182996,6 @@ self: { doHaddock = false; description = "Overloaded pragmas as a plugin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "overloaded-records" = callPackage @@ -194862,8 +183017,6 @@ self: { ]; description = "Overloaded Records based on current GHC proposal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "overture" = callPackage @@ -194877,8 +183030,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "An alternative to some of the Prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pack" = callPackage @@ -194894,8 +183045,6 @@ self: { ]; description = "Bidirectional fast ByteString packer/unpacker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "package-description-remote" = callPackage @@ -194910,8 +183059,6 @@ self: { testHaskellDepends = [ base ]; description = "Fetches a 'GenericPackageDescription' from Hackage"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "package-o-tron" = callPackage @@ -194930,8 +183077,6 @@ self: { ]; description = "Utilities for working with cabal packages and your package database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "package-vt" = callPackage @@ -194947,8 +183092,6 @@ self: { ]; description = "Haskell Package Versioning Tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "packcheck" = callPackage @@ -195002,8 +183145,6 @@ self: { ]; benchmarkHaskellDepends = [ base gauge ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "packed-dawg" = callPackage @@ -195031,8 +183172,6 @@ self: { ]; description = "Generation and traversal of highly compressed directed acyclic word graphs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "packed-multikey-map" = callPackage @@ -195051,8 +183190,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ]; description = "Efficient “spreadsheet table” like maps with multiple marginals"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "packedstring" = callPackage @@ -195066,8 +183203,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "(Deprecated) Packed Strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "packer" = callPackage @@ -195102,8 +183237,6 @@ self: { ]; description = "MessagePack Serialization an Deserialization for Packer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "packman" = callPackage @@ -195123,8 +183256,6 @@ self: { ]; description = "Serialization library for GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "packunused" = callPackage @@ -195145,8 +183276,6 @@ self: { ]; description = "Tool for detecting redundant Cabal package dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pacman-memcache" = callPackage @@ -195160,8 +183289,6 @@ self: { executableHaskellDepends = [ base deepseq directory-tree ]; description = "Read whole Pacman database which pushes it into the memory cache"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pact-time" = callPackage @@ -195195,8 +183322,6 @@ self: { ]; description = "Controlling padKONTROL native mode"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "paddle" = callPackage @@ -195242,8 +183367,6 @@ self: { ]; description = "PADS data description language for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pagarme" = callPackage @@ -195262,8 +183385,6 @@ self: { executableHaskellDepends = [ base text wreq ]; description = "Pagarme API wrapper"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pager" = callPackage @@ -195354,8 +183475,6 @@ self: { ]; description = "Receive hooks from pagure and do things with them"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "paint" = callPackage @@ -195397,8 +183516,6 @@ self: { ]; description = "Bilinear pairings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "palette" = callPackage @@ -195414,8 +183531,6 @@ self: { ]; description = "Utilities for choosing and creating color schemes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "palindromes" = callPackage @@ -195464,8 +183579,6 @@ self: { benchmarkHaskellDepends = [ base byteslice gauge primitive ]; description = "Parse syslog traffic from PAN-OS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "panda" = callPackage @@ -195486,8 +183599,6 @@ self: { ]; description = "A simple static blog engine"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc" = callPackage @@ -195581,8 +183692,6 @@ self: { doCheck = false; description = "Supports using pandoc with citeproc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-citeproc-preamble" = callPackage @@ -195653,8 +183762,6 @@ self: { executableHaskellDepends = [ base csv pandoc pandoc-types ]; description = "Convert CSV to Pandoc Table Markdown"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-dhall-decoder" = callPackage @@ -195710,8 +183817,6 @@ self: { ]; description = "A Pandoc filter to use graphviz"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-filter-indent" = callPackage @@ -195742,8 +183847,6 @@ self: { ]; description = "Pandoc filter formatting Haskell code fragments using GHC lexer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-highlighting-extensions" = callPackage @@ -195780,8 +183883,6 @@ self: { doHaddock = false; description = "Include other Markdown files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-include-code" = callPackage @@ -195825,8 +183926,6 @@ self: { ]; description = "Japanese-specific markup filters for pandoc"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-lens" = callPackage @@ -195838,8 +183937,6 @@ self: { libraryHaskellDepends = [ base containers lens pandoc-types text ]; description = "Lenses for Pandoc documents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-link-context" = callPackage @@ -195878,8 +183975,6 @@ self: { ]; description = "Pandoc-filter to evaluate `code` section in markdown and auto-embed output"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-placetable" = callPackage @@ -195901,8 +183996,6 @@ self: { ]; description = "Pandoc filter to include CSV files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-plantuml-diagrams" = callPackage @@ -195926,8 +184019,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Render and insert PlantUML diagrams with Pandoc"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-plot" = callPackage @@ -195992,8 +184083,6 @@ self: { ]; description = "A Pandoc filter to include figures generated from Python code blocks"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-sidenote" = callPackage @@ -196072,8 +184161,6 @@ self: { executableHaskellDepends = [ base pandoc ]; description = "Literate Haskell support for GitHub's Markdown flavor"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-utils" = callPackage @@ -196091,8 +184178,6 @@ self: { ]; description = "Utility functions to work with Pandoc in Haskell applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-vimhl" = callPackage @@ -196140,8 +184225,6 @@ self: { ]; description = "A super-pang clone"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pango" = callPackage @@ -196178,8 +184261,6 @@ self: { testHaskellDepends = [ base bytestring containers HUnit ]; description = "A set of parsers for graph languages and conversions to graph libaries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "panhandle" = callPackage @@ -196235,8 +184316,6 @@ self: { ]; description = "Pandoc filter to execute code blocks"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pansite" = callPackage @@ -196265,8 +184344,6 @@ self: { testHaskellDepends = [ base doctest Glob hspec QuickCheck ]; description = "Pansite: a simple web site management tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pantry" = callPackage @@ -196362,8 +184439,6 @@ self: { ]; description = "Content addressable Haskell package management"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa" = callPackage @@ -196387,8 +184462,6 @@ self: { ]; description = "Reasonable default import"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-base" = callPackage @@ -196402,8 +184475,6 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-base-export" = callPackage @@ -196415,8 +184486,6 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-base-implement" = callPackage @@ -196428,8 +184497,6 @@ self: { libraryHaskellDepends = [ base papa-base-export semigroups ]; description = "Useful base functions reimplemented"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-bifunctors" = callPackage @@ -196489,8 +184556,6 @@ self: { ]; description = "Reasonable default import"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-implement" = callPackage @@ -196512,8 +184577,6 @@ self: { ]; description = "Reasonable default import"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-include" = callPackage @@ -196530,8 +184593,6 @@ self: { ]; description = "Third party libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-lens" = callPackage @@ -196583,8 +184644,6 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-prelude-core" = callPackage @@ -196601,8 +184660,6 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-prelude-lens" = callPackage @@ -196619,8 +184676,6 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-prelude-semigroupoids" = callPackage @@ -196637,8 +184692,6 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-prelude-semigroups" = callPackage @@ -196655,8 +184708,6 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-semigroupoids" = callPackage @@ -196672,8 +184723,6 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-semigroupoids-export" = callPackage @@ -196696,8 +184745,6 @@ self: { libraryHaskellDepends = [ base semigroupoids semigroups ]; description = "useful `semigroupoids` functions reimplemented"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papa-x" = callPackage @@ -196744,8 +184791,6 @@ self: { executableHaskellDepends = [ base bytestring containers ]; description = "A passphrase generator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "papillon" = callPackage @@ -196766,8 +184811,6 @@ self: { ]; description = "packrat parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pappy" = callPackage @@ -196781,8 +184824,6 @@ self: { executableHaskellDepends = [ base ]; description = "Packrat parsing; linear-time parsers for grammars in TDPL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "paprika" = callPackage @@ -196805,8 +184846,6 @@ self: { ]; description = "The Haskell library and examples for the kids programming robot paprika"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "par-dual" = callPackage @@ -196823,8 +184862,6 @@ self: { ]; description = "ParDual class for Parallel <-> Sequential"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "par-traverse" = callPackage @@ -196874,8 +184911,6 @@ self: { executableToolDepends = [ alex ]; description = "Paragon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parallel" = callPackage @@ -196921,8 +184956,6 @@ self: { transformers vector vector-algorithms ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parallel-tree-search" = callPackage @@ -196979,8 +185012,6 @@ self: { ]; description = "Classes and data structures for working with data-kind indexed types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "paramtree" = callPackage @@ -197024,8 +185055,6 @@ self: { testHaskellDepends = [ base ]; description = "http proxy server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parco" = callPackage @@ -197037,8 +185066,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Generalised parser combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parco-attoparsec" = callPackage @@ -197050,8 +185077,6 @@ self: { libraryHaskellDepends = [ attoparsec base mtl parco ]; description = "Generalised parser combinators - Attoparsec interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parco-parsec" = callPackage @@ -197063,8 +185088,6 @@ self: { libraryHaskellDepends = [ base mtl parco parsec ]; description = "Generalised parser combinators - Parsec interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parcom-lib" = callPackage @@ -197080,8 +185103,6 @@ self: { ]; description = "A simple parser-combinator library, a bit like Parsec but without the frills"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parconc-examples" = callPackage @@ -197110,8 +185131,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Examples to accompany the book \"Parallel and Concurrent Programming in Haskell\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pareto" = callPackage @@ -197123,8 +185142,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for cause-effect relationships"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "paripari" = callPackage @@ -197171,8 +185188,6 @@ self: { ]; description = "Help Manage project specific documentation"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parport" = callPackage @@ -197209,8 +185224,6 @@ self: { ]; description = "Streaming Parquet reader"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parse-dimacs" = callPackage @@ -197258,8 +185271,6 @@ self: { testHaskellDepends = [ cmdargs ]; description = "generate command line arguments from a --help output"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parseargs" = callPackage @@ -197275,8 +185286,6 @@ self: { testHaskellDepends = [ base process ]; description = "Parse command-line arguments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsec_3_1_14_0" = callPackage @@ -197333,8 +185342,6 @@ self: { ]; description = "Parsec API encoded as a deeply-embedded DSL, for debugging and analysis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsec-numbers" = callPackage @@ -197378,8 +185385,6 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Parsing instances for Parsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsec-permutation" = callPackage @@ -197406,8 +185411,6 @@ self: { executableHaskellDepends = [ base containers mtl parsec pretty ]; description = "Pratt Parser combinator for Parsec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsec-tagsoup" = callPackage @@ -197463,8 +185466,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Monadic parser combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsec3" = callPackage @@ -197476,8 +185477,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl text ]; description = "Monadic parser combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsec3-numbers" = callPackage @@ -197512,8 +185511,6 @@ self: { testHaskellDepends = [ base hspec parsec ]; description = "Adds and Eq instance for Parsec's ParseError if needed"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsek" = callPackage @@ -197535,8 +185532,6 @@ self: { sha256 = "16sg32qs1kq184wk6d83z20b9firh1kjmysqwd2aqaiyq37zjyyb"; libraryHaskellDepends = [ base mtl parsec ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parser-combinators" = callPackage @@ -197582,8 +185577,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Test suite of parser-combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parser-combinators-tests_1_3_0" = callPackage @@ -197605,7 +185598,6 @@ self: { description = "Test suite of parser-combinators"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parser-helper" = callPackage @@ -197621,8 +185613,6 @@ self: { ]; description = "Prints Haskell parse trees in JSON"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parser241" = callPackage @@ -197637,8 +185627,6 @@ self: { testHaskellDepends = [ base containers hspec mtl ]; description = "An interface to create production rules using augmented grammars"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsergen" = callPackage @@ -197660,8 +185648,6 @@ self: { ]; description = "TH parser generator for splitting bytestring into fixed-width fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsers" = callPackage @@ -197702,8 +185688,6 @@ self: { ]; description = "`parsers` instances for Megaparsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsestar" = callPackage @@ -197727,8 +185711,6 @@ self: { ]; description = "NMR-STAR file format parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsimony" = callPackage @@ -197740,8 +185722,6 @@ self: { libraryHaskellDepends = [ base bytestring text ]; description = "Monadic parser combinators derived from Parsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "parsix" = callPackage @@ -197778,8 +185758,6 @@ self: { ]; description = "A fast, minimal parser"; license = "(BSD-2-Clause OR Apache-2.0)"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "partage" = callPackage @@ -197798,8 +185776,6 @@ self: { testHaskellDepends = [ base containers HUnit tasty tasty-hunit ]; description = "Parsing factorized"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "partial" = callPackage @@ -197848,8 +185824,6 @@ self: { ]; description = "Haskell 98 Partial Lenses"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "partial-order" = callPackage @@ -197878,8 +185852,6 @@ self: { libraryHaskellDepends = [ base template-haskell transformers ]; description = "Template haskell utilities for constructing records with default values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "partial-semigroup" = callPackage @@ -197949,8 +185921,6 @@ self: { ]; description = "Inspect, create, and alter MBRs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "passage" = callPackage @@ -197969,8 +185939,6 @@ self: { ]; description = "Parallel code generation for hierarchical Bayesian modeling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "passman" = callPackage @@ -197998,8 +185966,6 @@ self: { ]; description = "a simple password manager"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "passman-cli" = callPackage @@ -198124,8 +186090,6 @@ self: { libraryHaskellDepends = [ base containers MonadRandom random ]; description = "Password generation/validation library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pasta" = callPackage @@ -198142,8 +186106,6 @@ self: { testHaskellDepends = [ base hspec microlens protolude ]; description = "PostgreSQL Abstract Syntax Tree Assember"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pastis" = callPackage @@ -198155,8 +186117,6 @@ self: { libraryHaskellDepends = [ base HTTP network ]; description = "Interface to the past.is URL shortening service"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pasty" = callPackage @@ -198170,8 +186130,6 @@ self: { executableHaskellDepends = [ base bytestring mtl ]; description = "A simple command line pasting utility"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "patat" = callPackage @@ -198201,8 +186159,6 @@ self: { ]; description = "Terminal-based presentations using Pandoc"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "patch" = callPackage @@ -198279,8 +186235,6 @@ self: { ]; description = "Patches (diffs) on vectors: composable, mergeable, and invertible"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "path" = callPackage @@ -198479,8 +186433,6 @@ self: { ]; description = "A toy pathfinding library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pathological-bytestrings" = callPackage @@ -198582,8 +186534,6 @@ self: { executableHaskellDepends = [ base HandsomeSoup hxt ]; description = "A webpage scraper for Patreon which dumps a list of patrons to a text file"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pattern-arrows" = callPackage @@ -198647,8 +186597,6 @@ self: { ]; description = "Common patterns in message-oriented applications"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pava" = callPackage @@ -198698,8 +186646,6 @@ self: { ]; description = "Client for a limited part of PayPal's Adaptive Payments API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "paypal-api" = callPackage @@ -198716,8 +186662,6 @@ self: { ]; description = "PayPal API, currently supporting \"ButtonManager\""; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "paypal-rest-client" = callPackage @@ -198734,8 +186678,6 @@ self: { ]; description = "A client to connect to PayPal's REST API (v1)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pb" = callPackage @@ -198751,8 +186693,6 @@ self: { ]; description = "pastebin command line application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pb-next" = callPackage @@ -198772,8 +186712,6 @@ self: { testHaskellDepends = [ base parsec tasty tasty-hunit ]; description = "Utility CLI for working with protobuf files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pbc4hs" = callPackage @@ -198785,8 +186723,6 @@ self: { libraryHaskellDepends = [ base hslua string-qq ]; description = "pbc for HsLua"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pbkdf" = callPackage @@ -198843,8 +186779,6 @@ self: { ]; description = "Convert a pcap into an enumerator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pcapng" = callPackage @@ -198874,8 +186808,6 @@ self: { text unliftio-core validity ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pcd-loader" = callPackage @@ -198900,8 +186832,6 @@ self: { ]; description = "PCD file loader"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pcf" = callPackage @@ -198919,8 +186849,6 @@ self: { ]; description = "A one file compiler for PCF"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pcf-font" = callPackage @@ -198935,8 +186863,6 @@ self: { ]; description = "PCF font parsing and rendering library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pcf-font-embed" = callPackage @@ -198952,8 +186878,6 @@ self: { ]; description = "Template Haskell for embedding text rendered using PCF fonts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pcg-random" = callPackage @@ -199040,8 +186964,6 @@ self: { libraryHaskellDepends = [ base bytestring pcre-light ]; description = "pcre-light extra functionality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pcre-utils" = callPackage @@ -199106,8 +187028,6 @@ self: { ]; description = "Tool to generate PDF from haskintex templates and YAML input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdf-slave-server" = callPackage @@ -199158,8 +187078,6 @@ self: { ]; description = "Template format definition for pdf-slave tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdf-toolbox-content" = callPackage @@ -199181,8 +187099,6 @@ self: { ]; description = "A collection of tools for processing PDF files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdf-toolbox-core" = callPackage @@ -199208,8 +187124,6 @@ self: { ]; description = "A collection of tools for processing PDF files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdf-toolbox-document" = callPackage @@ -199231,8 +187145,6 @@ self: { ]; description = "A collection of tools for processing PDF files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdf-toolbox-viewer" = callPackage @@ -199253,8 +187165,6 @@ self: { ]; description = "Simple pdf viewer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdf2line" = callPackage @@ -199304,8 +187214,6 @@ self: { ]; description = "Name a PDF file using information from the pdfinfo command"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdfsplit" = callPackage @@ -199321,8 +187229,6 @@ self: { ]; description = "split two-column PDFs, so there is one column per page"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pdftotext" = callPackage @@ -199344,8 +187250,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Extracts text from PDF using poppler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {poppler-cpp = null;}; "pdynload" = callPackage @@ -199362,8 +187266,6 @@ self: { ]; description = "pdynload is polymorphic dynamic linking library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "peakachu" = callPackage @@ -199379,8 +187281,6 @@ self: { ]; description = "Experiemental library for composable interactive programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "peano" = callPackage @@ -199430,8 +187330,6 @@ self: { ]; description = "pec embedded compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pecoff" = callPackage @@ -199444,8 +187342,6 @@ self: { libraryHaskellDepends = [ base binary bytestring containers ]; description = "Parser for PE/COFF format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pedersen-commitment" = callPackage @@ -199466,8 +187362,6 @@ self: { ]; description = "An implementation of Pedersen commitment schemes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pedestrian-dag" = callPackage @@ -199481,8 +187375,6 @@ self: { libraryHaskellDepends = [ array base binary containers ]; description = "A pedestrian implementation of directed acyclic graphs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "peg" = callPackage @@ -199500,8 +187392,6 @@ self: { ]; description = "a lazy non-deterministic concatenative programming language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "peggy" = callPackage @@ -199520,8 +187410,6 @@ self: { ]; description = "The Parser Generator for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pell" = callPackage @@ -199539,8 +187427,6 @@ self: { ]; description = "Package to solve the Generalized Pell Equation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pem" = callPackage @@ -199582,8 +187468,6 @@ self: { ]; description = "Static site generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "penn-treebank" = callPackage @@ -199615,8 +187499,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Parser combinators for trees in the Penn Treebank format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "penny" = callPackage @@ -199645,8 +187527,6 @@ self: { ]; description = "Extensible double-entry accounting system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "penny-bin" = callPackage @@ -199665,8 +187545,6 @@ self: { ]; description = "Deprecated - use penny package instead"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "penny-lib" = callPackage @@ -199688,8 +187566,6 @@ self: { ]; description = "Deprecated - use penny package instead"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "penrose" = callPackage @@ -199725,8 +187601,6 @@ self: { ]; description = "Create beautiful diagrams just by typing mathematical notation in plain text"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "peparser" = callPackage @@ -199738,8 +187612,6 @@ self: { libraryHaskellDepends = [ base binary bytestring haskell98 ]; description = "A parser for PE object files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "percent-encoder" = callPackage @@ -199759,8 +187631,6 @@ self: { ]; description = "Percent encode/decode ByteStrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "percent-format" = callPackage @@ -199784,8 +187654,6 @@ self: { libraryHaskellDepends = [ base ]; description = "The perceptron learning algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "perceptual-hash" = callPackage @@ -199813,8 +187681,6 @@ self: { benchmarkToolDepends = [ cpphs ]; description = "Find duplicate images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "perdure" = callPackage @@ -199861,8 +187727,6 @@ self: { ]; description = "Database migration support for use in other libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "perf" = callPackage @@ -199879,8 +187743,6 @@ self: { testHaskellDepends = [ base deepseq doctest rdtsc ]; description = "Low-level run time measurement"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "perf-analysis" = callPackage @@ -199903,8 +187765,6 @@ self: { ]; description = "analysis example using perf"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "perfect-hash-generator" = callPackage @@ -199983,8 +187843,6 @@ self: { ]; description = "A perfect hashing library for mapping bytestrings to values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "perhaps" = callPackage @@ -200002,8 +187860,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Perhaps, a monad"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "period" = callPackage @@ -200040,8 +187896,6 @@ self: { testHaskellDepends = [ base cereal hedis hspec text time ]; description = "A reliable at-least-once periodic job scheduler backed by redis"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "periodic-client" = callPackage @@ -200059,8 +187913,6 @@ self: { ]; description = "Periodic task system haskell client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "periodic-client-exe" = callPackage @@ -200085,8 +187937,6 @@ self: { ]; description = "Periodic task system haskell client executables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "periodic-common" = callPackage @@ -200103,8 +187953,6 @@ self: { ]; description = "Periodic task system common"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "periodic-polynomials" = callPackage @@ -200145,8 +187993,6 @@ self: { ]; description = "Periodic task system haskell server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "perm" = callPackage @@ -200163,8 +188009,6 @@ self: { ]; description = "permutation Applicative and Monad with many mtl instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "permutation" = callPackage @@ -200179,8 +188023,6 @@ self: { libraryHaskellDepends = [ base ghc-prim QuickCheck ]; description = "A library for permutations and combinations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "permutations" = callPackage @@ -200204,8 +188046,6 @@ self: { ]; description = "Permutations of finite sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "permute" = callPackage @@ -200217,8 +188057,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Generalised permutation parser combinator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persist" = callPackage @@ -200270,8 +188108,6 @@ self: { ]; description = "Transforms persist's quasi-quoted syntax into ER format"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistable-record" = callPackage @@ -200410,8 +188246,6 @@ self: { ]; description = "Parses a Persist Model file and produces Audit Models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-cereal" = callPackage @@ -200423,8 +188257,6 @@ self: { libraryHaskellDepends = [ base cereal persistent text ]; description = "Helper functions for writing Persistent instances"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-database-url" = callPackage @@ -200444,8 +188276,6 @@ self: { ]; description = "Parse DATABASE_URL into configuration types for Persistent"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-discover" = callPackage @@ -200504,8 +188334,6 @@ self: { libraryHaskellDepends = [ array base diffarray ]; description = "Persistent equivalence relations (aka union-find)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-generic" = callPackage @@ -200533,8 +188361,6 @@ self: { ]; description = "Declare Persistent entities using SQL SELECT query syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-instances-iproute" = callPackage @@ -200578,8 +188404,6 @@ self: { ]; description = "A thread-safe (STM) persistency interface for finite map types"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-migration" = callPackage @@ -200604,8 +188428,6 @@ self: { ]; description = "Manual migrations for the persistent library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-mongoDB" = callPackage @@ -200633,8 +188455,6 @@ self: { ]; description = "Backend for the persistent library using mongoDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-mtl" = callPackage @@ -200747,8 +188567,6 @@ self: { ]; description = "A pure haskell backend for the persistent library using MySQL database server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-odbc" = callPackage @@ -200769,8 +188587,6 @@ self: { ]; description = "Backend for the persistent library using ODBC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-pagination" = callPackage @@ -200884,8 +188700,6 @@ self: { ]; description = "Template-Haskell helpers for integrating protobufs with persistent"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-qq" = callPackage @@ -200941,8 +188755,6 @@ self: { libraryHaskellDepends = [ base time yesod ]; description = "A library for rate limiting activities with a persistent backend"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-redis" = callPackage @@ -200965,8 +188777,6 @@ self: { ]; description = "Backend for persistent library using Redis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-refs" = callPackage @@ -201003,8 +188813,6 @@ self: { ]; description = "relational-record on persisten backends"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-spatial" = callPackage @@ -201156,8 +188964,6 @@ self: { ]; description = "Generate classy lens field accessors for persistent models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-test" = callPackage @@ -201181,8 +188987,6 @@ self: { ]; description = "Tests for Persistent"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-test_2_13_0_0" = callPackage @@ -201209,7 +189013,6 @@ self: { description = "Tests for Persistent"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-typed-db" = callPackage @@ -201276,8 +189079,6 @@ self: { benchmarkHaskellDepends = [ base containers criterion deepseq ]; description = "A persistent sequence based on array mapped tries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persistent-zookeeper" = callPackage @@ -201307,8 +189108,6 @@ self: { ]; description = "Backend for persistent library using Zookeeper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persona" = callPackage @@ -201325,8 +189124,6 @@ self: { ]; description = "Persona (BrowserID) library"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "persona-idp" = callPackage @@ -201348,8 +189145,6 @@ self: { ]; description = "Persona (BrowserID) Identity Provider"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pesca" = callPackage @@ -201364,8 +189159,6 @@ self: { executableHaskellDepends = [ base process ]; description = "Proof Editor for Sequent Calculus"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "peyotls" = callPackage @@ -201392,8 +189185,6 @@ self: { ]; description = "Pretty Easy YOshikuni-made TLS library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "peyotls-codec" = callPackage @@ -201411,8 +189202,6 @@ self: { ]; description = "Codec parts of Pretty Easy YOshikuni-made TLS library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pez" = callPackage @@ -201429,8 +189218,6 @@ self: { ]; description = "A Pretty Extraordinary Zipper library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pg-extras" = callPackage @@ -201447,8 +189234,6 @@ self: { testHaskellDepends = [ base HUnit text ]; description = "PostgreSQL database performance insights"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pg-harness" = callPackage @@ -201468,8 +189253,6 @@ self: { ]; description = "REST service and library for creating/consuming temporary PostgreSQL databases"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pg-harness-client" = callPackage @@ -201500,8 +189283,6 @@ self: { ]; description = "REST service for creating temporary PostgreSQL databases"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pg-recorder" = callPackage @@ -201527,8 +189308,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pg-store" = callPackage @@ -201552,8 +189331,6 @@ self: { ]; description = "Simple storage interface to PostgreSQL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pg-transact" = callPackage @@ -201575,8 +189352,6 @@ self: { ]; description = "A postgresql-simple transaction monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pgdl" = callPackage @@ -201602,8 +189377,6 @@ self: { ]; description = "browse directory listing webpages and download files from them"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pgf2" = callPackage @@ -201616,8 +189389,6 @@ self: { librarySystemDepends = [ gu pgf ]; description = "Bindings to the C version of the PGF runtime"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gu = null; inherit (pkgs) pgf;}; "pgm" = callPackage @@ -201665,8 +189436,6 @@ self: { ]; description = "A mid-level PostgreSQL client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pgstream" = callPackage @@ -201691,8 +189460,6 @@ self: { ]; description = "Streaming Postgres bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phantom-state" = callPackage @@ -201719,8 +189486,6 @@ self: { ]; description = "Freezing, thawing, and copy elision"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phaser" = callPackage @@ -201735,8 +189500,6 @@ self: { ]; description = "Incremental multiple pass parser library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phash" = callPackage @@ -201794,8 +189557,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Deprecated - ghci debug viewer with simple editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phoityne-vscode" = callPackage @@ -201846,8 +189607,6 @@ self: { testHaskellDepends = [ base bytestring ]; description = "Haskell bindings to the libphonenumber library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {phonenumber = null; inherit (pkgs) protobuf;}; "phone-push" = callPackage @@ -201865,8 +189624,6 @@ self: { ]; description = "Push notifications for Android and iOS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phonetic-code" = callPackage @@ -201955,8 +189712,6 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-examples functionality"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phonetic-languages-filters-array" = callPackage @@ -202062,8 +189817,6 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-properties package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phonetic-languages-rhythmicity" = callPackage @@ -202233,8 +189986,6 @@ self: { ]; description = "Simplified and somewhat optimized version of the phonetic-languages-examples"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phonetic-languages-simplified-properties-array" = callPackage @@ -202270,8 +190021,6 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-properties package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phonetic-languages-simplified-properties-lists-double" = callPackage @@ -202290,8 +190039,6 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-properties package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phonetic-languages-ukrainian" = callPackage @@ -202340,8 +190087,6 @@ self: { ]; description = "Functional user interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "photoname" = callPackage @@ -202363,8 +190108,6 @@ self: { ]; description = "Rename photo image files based on EXIF shoot date"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phraskell" = callPackage @@ -202378,8 +190121,6 @@ self: { executableHaskellDepends = [ base mtl SDL transformers ]; description = "A fractal viewer"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "phybin" = callPackage @@ -202412,8 +190153,6 @@ self: { ]; description = "Utility for clustering phylogenetic trees in Newick format based on Robinson-Foulds distance"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "physics" = callPackage @@ -202445,8 +190184,6 @@ self: { ]; description = "Applied pi-calculus interpreter"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pi-forall" = callPackage @@ -202470,8 +190207,6 @@ self: { ]; description = "Demo implementation of typechecker for dependently-typed language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pi-hoole" = callPackage @@ -202497,8 +190232,6 @@ self: { testHaskellDepends = [ base ]; description = "Lightweight access control solution for the pijul vcs"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pi-lcd" = callPackage @@ -202540,8 +190273,6 @@ self: { ]; description = "Set up port forwarding with the Private Internet Access VPN service"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pianola" = callPackage @@ -202564,8 +190295,6 @@ self: { ]; description = "Remotely controlling Java Swing applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "picedit" = callPackage @@ -202580,8 +190309,6 @@ self: { executableHaskellDepends = [ base cli hmatrix ]; description = "simple image manipulation functions"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pickle" = callPackage @@ -202593,8 +190320,6 @@ self: { libraryHaskellDepends = [ base containers network stm text ]; description = "Instant StatsD in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "picologic" = callPackage @@ -202617,8 +190342,6 @@ self: { ]; description = "Utilities for symbolic predicate logic expressions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "picoparsec" = callPackage @@ -202651,8 +190374,6 @@ self: { ]; description = "Fast combinator parsing for bytestrings and text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "picosat" = callPackage @@ -202678,8 +190399,6 @@ self: { executableHaskellDepends = [ base matrix transformers xml ]; description = "Converts a svg image to tikz code"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pid1" = callPackage @@ -202727,8 +190446,6 @@ self: { ]; description = "Yet another Haskell build system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pier-core" = callPackage @@ -202748,8 +190465,6 @@ self: { ]; description = "A library for writing forwards-declared build systems in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "piet" = callPackage @@ -202763,8 +190478,6 @@ self: { libraryHaskellDepends = [ array base containers Imlib mtl ]; description = "A Piet interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pig" = callPackage @@ -202781,8 +190494,6 @@ self: { ]; description = "dice game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "piki" = callPackage @@ -202821,8 +190532,6 @@ self: { ]; description = "Access to the Pinboard API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pinboard-notes-backup" = callPackage @@ -202868,8 +190577,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "An alternative implementation of Thrift for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pinch-gen" = callPackage @@ -202889,8 +190596,6 @@ self: { ]; description = "A code generator for the pinch Thrift library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pinchot" = callPackage @@ -202909,8 +190614,6 @@ self: { ]; description = "Write grammars, not parsers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pine" = callPackage @@ -202952,8 +190655,6 @@ self: { ]; description = "icmp echo requests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ping-parser-attoparsec" = callPackage @@ -203045,8 +190746,6 @@ self: { testHaskellDepends = [ base doctest protolude ]; description = "A gateway for various cloud notification services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipe-enumerator" = callPackage @@ -203058,8 +190757,6 @@ self: { libraryHaskellDepends = [ base enumerator pipes transformers ]; description = "A bidirectional bridge between pipes and iteratees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipeclip" = callPackage @@ -203191,8 +190888,6 @@ self: { ]; description = "A higher-level interface to using concurrency with pipes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-attoparsec" = callPackage @@ -203232,8 +190927,6 @@ self: { ]; description = "Streaming parsing in the pipes-core framework with Attoparsec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-bgzf" = callPackage @@ -203249,8 +190942,6 @@ self: { ]; description = "Blocked GZip"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-binary" = callPackage @@ -203304,8 +190995,6 @@ self: { ]; description = "Brotli (RFC7932) compressors and decompressors for the Pipes package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-bytestring" = callPackage @@ -203361,8 +191050,6 @@ self: { testHaskellDepends = [ base hlint ]; description = "Pipes for Noise-secured network connections"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-category" = callPackage @@ -203438,8 +191125,6 @@ self: { ]; description = "Encode and decode binary streams using the pipes and cereal libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-cereal-plus" = callPackage @@ -203455,8 +191140,6 @@ self: { ]; description = "A streaming serialization library on top of \"pipes\" and \"cereal-plus\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-cliff" = callPackage @@ -203503,8 +191186,6 @@ self: { libraryHaskellDepends = [ base conduit mtl pipes-core ]; description = "Conduit adapters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-core" = callPackage @@ -203520,8 +191201,6 @@ self: { ]; description = "Compositional pipelines"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-courier" = callPackage @@ -203533,8 +191212,6 @@ self: { libraryHaskellDepends = [ base courier pipes ]; description = "Pipes utilities for interfacing with the courier message-passing framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-csv" = callPackage @@ -203567,8 +191244,6 @@ self: { libraryHaskellDepends = [ base errors pipes ]; description = "Integration between pipes and errors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-extra" = callPackage @@ -203596,8 +191271,6 @@ self: { ]; description = "Various basic utilities for Pipes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-extras" = callPackage @@ -203658,8 +191331,6 @@ self: { ]; description = "Fast traversal of directory trees using pipes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-fluid" = callPackage @@ -203732,8 +191403,6 @@ self: { ]; description = "Illumina NGS data processing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-interleave" = callPackage @@ -203747,8 +191416,6 @@ self: { libraryHaskellDepends = [ base containers heaps pipes ]; description = "Interleave and merge streams of elements"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-io" = callPackage @@ -203763,8 +191430,6 @@ self: { testHaskellDepends = [ base hspec pipes ]; description = "Stateful IO streams based on pipes"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-kafka" = callPackage @@ -203805,8 +191470,6 @@ self: { ]; description = "Streaming processing of CSV files preceded by key-value pairs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-lines" = callPackage @@ -203874,8 +191537,6 @@ self: { testHaskellDepends = [ base monad-control mongoDB pipes text ]; description = "Stream results from MongoDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-network" = callPackage @@ -203951,8 +191612,6 @@ self: { ]; description = "P2P network nodes with pipes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-p2p-examples" = callPackage @@ -203971,8 +191630,6 @@ self: { ]; description = "Examples using pipes-p2p"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-parse" = callPackage @@ -204023,8 +191680,6 @@ self: { testHaskellDepends = [ base ]; description = "Alternate Prelude for the pipes ecosystem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-pulse-simple" = callPackage @@ -204064,8 +191719,6 @@ self: { executableHaskellDepends = [ base pipes time ]; description = "A few pipes to control the timing of yields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-s3" = callPackage @@ -204088,8 +191741,6 @@ self: { ]; description = "A simple interface for streaming data to and from Amazon S3"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-safe" = callPackage @@ -204126,8 +191777,6 @@ self: { ]; description = "Create proper Pipes from System.Process"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-sqlite-simple" = callPackage @@ -204141,8 +191790,6 @@ self: { ]; description = "Functions that smash Pipes and sqlite-simple together"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-text" = callPackage @@ -204183,8 +191830,6 @@ self: { ]; description = "Interfacing pipes with foldl folds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-vector" = callPackage @@ -204200,8 +191845,6 @@ self: { ]; description = "Various proxies for streaming data into vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-wai" = callPackage @@ -204252,8 +191895,6 @@ self: { ]; description = "Pipes integration for ZeroMQ messaging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pipes-zlib" = callPackage @@ -204293,8 +191934,6 @@ self: { ]; description = "A dependently typed core language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pit" = callPackage @@ -204317,8 +191956,6 @@ self: { ]; description = "Account management tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pitchtrack" = callPackage @@ -204339,8 +191976,6 @@ self: { ]; description = "Pitch tracking library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pivotal-tracker" = callPackage @@ -204364,8 +191999,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A library and a CLI tool for accessing Pivotal Tracker API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pixel-printer" = callPackage @@ -204383,8 +192016,6 @@ self: { testHaskellDepends = [ base ]; description = "A program for turning pixel art into 3D prints"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pixela" = callPackage @@ -204429,8 +192060,6 @@ self: { ]; description = "A library and application for generating pixelated avatars"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pixiv" = callPackage @@ -204458,8 +192087,6 @@ self: { ]; description = "Pixiv API binding based on servant-client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "piyo" = callPackage @@ -204519,8 +192146,6 @@ self: { ]; description = "PKCS#10 library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pkcs7" = callPackage @@ -204533,8 +192158,6 @@ self: { testHaskellDepends = [ base bytestring Cabal HUnit QuickCheck ]; description = "PKCS #7 padding in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pkggraph" = callPackage @@ -204548,8 +192171,6 @@ self: { executableHaskellDepends = [ base Cabal split ]; description = "Package dependency graph for installed packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pkgtreediff" = callPackage @@ -204570,8 +192191,6 @@ self: { ]; description = "Package tree diff tool"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pktree" = callPackage @@ -204651,8 +192270,6 @@ self: { libraryHaskellDepends = [ base bytestring mtl time unix ]; description = "plaimi's prelude"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plan-applicative" = callPackage @@ -204673,8 +192290,6 @@ self: { ]; description = "Applicative/Arrow for resource estimation and progress tracking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plan-b" = callPackage @@ -204693,8 +192308,6 @@ self: { testHaskellDepends = [ base hspec path path-io ]; description = "Failure-tolerant file and directory editing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "planar-graph" = callPackage @@ -204711,8 +192324,6 @@ self: { ]; description = "A representation of planar graphs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "planb-token-introspection" = callPackage @@ -204736,8 +192347,6 @@ self: { ]; description = "Token Introspection for PlanB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "planet-mitchell" = callPackage @@ -204792,8 +192401,6 @@ self: { ]; description = "Planet Mitchell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "planet-mitchell-test" = callPackage @@ -204810,8 +192417,6 @@ self: { ]; description = "Planet Mitchell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plankton" = callPackage @@ -204823,8 +192428,6 @@ self: { libraryHaskellDepends = [ adjunctions base protolude ]; description = "The core of a numeric prelude, taken from numhask"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plat" = callPackage @@ -204838,8 +192441,6 @@ self: { ]; description = "Simple templating library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "platinum-parsing" = callPackage @@ -204863,8 +192464,6 @@ self: { testHaskellDepends = [ base containers fgl hspec vector ]; description = "General Framework for compiler development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "playlists" = callPackage @@ -204936,8 +192535,6 @@ self: { libraryHaskellDepends = [ base base64-bytestring bytestring hxt ]; description = "Generate and parse Mac OS X property list format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plist-buddy" = callPackage @@ -204961,8 +192558,6 @@ self: { ]; description = "Remote monad for editing plists"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plivo" = callPackage @@ -204996,8 +192591,6 @@ self: { executableHaskellDepends = [ base optparse-applicative socketed ]; description = "plot data from stdin through socketed"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plot" = callPackage @@ -205024,8 +192617,6 @@ self: { libraryHaskellDepends = [ base glib gtk hmatrix mtl plot process ]; description = "GTK plots and interaction with GHCi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plot-gtk-ui" = callPackage @@ -205042,8 +192633,6 @@ self: { ]; description = "A quick way to use Mathematica like Manipulation abilities"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plot-gtk3" = callPackage @@ -205057,8 +192646,6 @@ self: { ]; description = "GTK3 plots and interaction with GHCi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plot-lab" = callPackage @@ -205075,8 +192662,6 @@ self: { ]; description = "A plotting tool with Mathematica like Manipulation abilities"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plot-light" = callPackage @@ -205227,8 +192812,6 @@ self: { ]; description = "Dynamic linking for Haskell and C objects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plugins-auto" = callPackage @@ -205245,8 +192828,6 @@ self: { testHaskellDepends = [ base directory process ]; description = "Automatic recompilation and reloading of haskell modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plugins-multistage" = callPackage @@ -205265,8 +192846,6 @@ self: { ]; description = "Dynamic linking for embedded DSLs with staged compilation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plumbers" = callPackage @@ -205278,8 +192857,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Pointless plumbing combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plur" = callPackage @@ -205292,8 +192869,6 @@ self: { testHaskellDepends = [ base hedgehog hedgehog-classes ]; description = "Plurality monad: Zero, one, or at least two"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "plural" = callPackage @@ -205306,8 +192881,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Pluralize"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ply-loader" = callPackage @@ -205346,8 +192919,6 @@ self: { testHaskellDepends = [ base hspec mtl text unordered-containers ]; description = "A front-end framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "png-file" = callPackage @@ -205363,8 +192934,6 @@ self: { ]; description = "read/write png file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pngload" = callPackage @@ -205381,8 +192950,6 @@ self: { ]; description = "Pure Haskell loader for PNG images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pngload-fixed" = callPackage @@ -205395,8 +192962,6 @@ self: { libraryHaskellDepends = [ array base bytestring mtl parsec zlib ]; description = "Pure Haskell loader for PNG images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pnm" = callPackage @@ -205423,8 +192988,6 @@ self: { ]; description = "Bindings for the Pocket API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pocket-dns" = callPackage @@ -205459,8 +193022,6 @@ self: { ]; description = "Multi-backend (zookeeper and sqlite) DNS Server using persistent-library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "point-octree" = callPackage @@ -205479,8 +193040,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Point octree, with bounding boxes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pointed" = callPackage @@ -205510,8 +193069,6 @@ self: { libraryHaskellDepends = [ base mtl semigroups transformers ]; description = "Alternative done right"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pointedlist" = callPackage @@ -205570,8 +193127,6 @@ self: { doHaddock = false; description = "Tool for refactoring expressions into pointfree form"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pointful" = callPackage @@ -205590,8 +193145,6 @@ self: { executableHaskellDepends = [ base ]; description = "Pointful refactoring tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pointless-fun" = callPackage @@ -205614,8 +193167,6 @@ self: { libraryHaskellDepends = [ base GHood process syb ]; description = "Pointless Haskell library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pointless-lenses" = callPackage @@ -205631,8 +193182,6 @@ self: { ]; description = "Pointless Lenses library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pointless-rewrite" = callPackage @@ -205648,8 +193197,6 @@ self: { ]; description = "Pointless Rewrite library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "poke" = callPackage @@ -205681,8 +193228,6 @@ self: { ]; description = "Discord verification bot"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pokemon-go-protobuf-types" = callPackage @@ -205699,8 +193244,6 @@ self: { ]; description = "Haskell types for the Pokemon Go protobuf protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "poker-eval" = callPackage @@ -205713,8 +193256,6 @@ self: { librarySystemDepends = [ poker-eval ]; description = "Binding to libpoker-eval"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {poker-eval = null;}; "pokitdok" = callPackage @@ -205732,8 +193273,6 @@ self: { ]; description = "PokitDok Platform API Client for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polar" = callPackage @@ -205757,8 +193296,6 @@ self: { testHaskellDepends = [ base containers HUnit MissingH mtl parsec ]; description = "Fork of ConfigFile for Polar Game Engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polar-shader" = callPackage @@ -205771,8 +193308,6 @@ self: { testHaskellDepends = [ base containers hspec ]; description = "High-level shader compiler framework"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polh-lexicon" = callPackage @@ -205791,8 +193326,6 @@ self: { ]; description = "A library for manipulating the historical dictionary of Polish (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "policeman" = callPackage @@ -205886,8 +193419,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Poly-kinded continuations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "poly-control" = callPackage @@ -205899,8 +193430,6 @@ self: { libraryHaskellDepends = [ base lens ]; description = "This package provides abstraction for polymorphic controls, like PolyMonads or PolyApplicatives"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "poly-rec" = callPackage @@ -205941,8 +193470,6 @@ self: { ]; description = "Wrap together data and it's constraints"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polydata-core" = callPackage @@ -205954,8 +193481,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Core data definitions for the \"polydata\" package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polymap" = callPackage @@ -206013,8 +193538,6 @@ self: { ]; description = "Polynomials"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polynomials-bernstein" = callPackage @@ -206093,8 +193616,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Experimental, RandomFu effect and interpreters for polysemy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-chronos" = callPackage @@ -206116,8 +193637,6 @@ self: { ]; description = "Polysemy effect for chronos"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-conc" = callPackage @@ -206141,8 +193660,6 @@ self: { ]; description = "Polysemy Effects for Concurrency"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-extra" = callPackage @@ -206158,8 +193675,6 @@ self: { ]; description = "Extra Input and Output functions for polysemy.."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-fs" = callPackage @@ -206190,8 +193705,6 @@ self: { ]; description = "Run a KVStore as a filesystem in polysemy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-http" = callPackage @@ -206221,8 +193734,6 @@ self: { ]; description = "Polysemy effect for http-client"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-kvstore-jsonfile" = callPackage @@ -206239,8 +193750,6 @@ self: { ]; description = "Run a KVStore as a single json file in polysemy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-log" = callPackage @@ -206264,8 +193773,6 @@ self: { ]; description = "Polysemy effects for logging"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-log-co" = callPackage @@ -206288,8 +193795,6 @@ self: { ]; description = "polysemy-log interpreter for co-log"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-log-di" = callPackage @@ -206311,8 +193816,6 @@ self: { ]; description = "polysemy-log interpreter for di"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-methodology" = callPackage @@ -206328,8 +193831,6 @@ self: { ]; description = "Domain modelling algebra for polysemy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-methodology-composite" = callPackage @@ -206346,8 +193847,6 @@ self: { ]; description = "Functions for using polysemy-methodology with composite"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-mocks" = callPackage @@ -206374,8 +193873,6 @@ self: { libraryHaskellDepends = [ base optics polysemy polysemy-zoo ]; description = "Optics for Polysemy"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-path" = callPackage @@ -206391,8 +193888,6 @@ self: { ]; description = "Polysemy versions of Path functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-plugin" = callPackage @@ -206433,8 +193928,6 @@ self: { ]; description = "Polysemy error tracking"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-test" = callPackage @@ -206459,8 +193952,6 @@ self: { ]; description = "Polysemy effects for testing"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-time" = callPackage @@ -206484,8 +193975,6 @@ self: { ]; description = "Polysemy effect for time"; license = "BSD-2-Clause-Patent"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-video" = callPackage @@ -206511,8 +194000,6 @@ self: { libraryHaskellDepends = [ base polysemy polysemy-extra vinyl ]; description = "Functions for mapping vinyl records in polysemy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysemy-webserver" = callPackage @@ -206558,8 +194045,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Experimental, user-contributed effects and interpreters for polysemy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polyseq" = callPackage @@ -206580,8 +194065,6 @@ self: { executableHaskellDepends = [ cgi free-theorems utf8-string xhtml ]; description = "Taming Selective Strictness"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polysoup" = callPackage @@ -206606,8 +194089,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Typeable for polymorphic types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polytypeable-utils" = callPackage @@ -206619,8 +194100,6 @@ self: { libraryHaskellDepends = [ base haskell98 polytypeable ]; description = "Utilities for polytypeable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "polyvariadic" = callPackage @@ -206658,8 +194137,6 @@ self: { ]; description = "Maps and sets of partial orders"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pomodoro" = callPackage @@ -206678,8 +194155,6 @@ self: { ]; description = "pomodoro timer"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pomohoro" = callPackage @@ -206703,8 +194178,6 @@ self: { testHaskellDepends = [ base hspec protolude ]; description = "Initial project template from stack"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ponder" = callPackage @@ -206716,8 +194189,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "PEG parser combinator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pong-server" = callPackage @@ -206735,8 +194206,6 @@ self: { testHaskellDepends = [ base hspec network QuickCheck ]; description = "A simple embedded pingable server that runs in the background"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pontarius-mediaserver" = callPackage @@ -206805,8 +194274,6 @@ self: { ]; description = "An XMPP client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pontarius-xmpp-extras" = callPackage @@ -206865,8 +194332,6 @@ self: { libraryHaskellDepends = [ base monad-control transformers ]; description = "Thread-safe resource pools. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pool-conduit" = callPackage @@ -206884,8 +194349,6 @@ self: { ]; description = "Resource pool allocations via ResourceT. (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pooled-io" = callPackage @@ -206916,8 +194379,6 @@ self: { libraryHaskellDepends = [ base mtl network ]; description = "POP3 Client Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "popenhs" = callPackage @@ -206930,8 +194391,6 @@ self: { libraryHaskellDepends = [ base directory haskell98 unix ]; description = "popenhs is a popen-like library for Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "popkey" = callPackage @@ -206953,8 +194412,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Static key-value storage backed by poppy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "poppler" = callPackage @@ -206975,8 +194432,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the Poppler"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gdk-pixbuf; inherit (pkgs) gtk2; inherit (pkgs) pango; inherit (pkgs) poppler_gi;}; @@ -207031,8 +194486,6 @@ self: { ]; description = "Express portable, composable and reusable data tasks and pipelines"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "porcupine-http" = callPackage @@ -207061,8 +194514,6 @@ self: { ]; description = "A location accessor for porcupine to connect to HTTP sources/sinks"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "porcupine-s3" = callPackage @@ -207093,8 +194544,6 @@ self: { ]; description = "A location accessor for porcupine to connect to AWS S3 sources/sinks"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "porpoise" = callPackage @@ -207166,8 +194615,6 @@ self: { testHaskellDepends = [ base containers hspec mtl QuickCheck text ]; description = "DSL for configuring Gentoo portage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "portaudio" = callPackage @@ -207198,8 +194645,6 @@ self: { ]; description = "FreeBSD ports index search and analysis tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "porter" = callPackage @@ -207222,8 +194667,6 @@ self: { libraryHaskellDepends = [ base haskell98 unix ]; description = "The Haskell Ports Library"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ports-tools" = callPackage @@ -207258,8 +194701,6 @@ self: { ]; description = "Simple extensible library to run SQL file against PostgreSQL database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "poseidon-postgis" = callPackage @@ -207280,8 +194721,6 @@ self: { ]; description = "Extension of Poseidon library for Postgis (Spatial and Geographic objects for PostgreSQL)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "positive" = callPackage @@ -207310,8 +194749,6 @@ self: { testHaskellDepends = [ base ]; description = "Experiment"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "posix-acl" = callPackage @@ -207329,8 +194766,6 @@ self: { librarySystemDepends = [ acl ]; description = "Support for Posix ACL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) acl;}; "posix-api" = callPackage @@ -207354,8 +194789,6 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) systemd;}; "posix-error-codes" = callPackage @@ -207433,8 +194866,6 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "POSIX Realtime functionality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "posix-socket" = callPackage @@ -207475,8 +194906,6 @@ self: { libraryHaskellDepends = [ base unix ]; description = "Low-level wrapping of POSIX waitpid(2)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "posplyu" = callPackage @@ -207538,8 +194967,6 @@ self: { libraryHaskellDepends = [ aeson base bytestring HTTP ]; description = "A library that gets postcode information from the uk-postcodes.com"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgres-embedded" = callPackage @@ -207558,8 +194985,6 @@ self: { ]; description = "Library for easily running embedded PostgreSQL server for tests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgres-options" = callPackage @@ -207587,8 +195012,6 @@ self: { libraryHaskellDepends = [ base bytestring postgresql-simple text ]; description = "Create a temporary database that is deleted after performing some operation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgres-websockets" = callPackage @@ -207621,8 +195044,6 @@ self: { ]; description = "Middleware to map LISTEN/NOTIFY messages to Websockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-binary" = callPackage @@ -207799,8 +195220,6 @@ self: { ]; description = "Utilities for streaming PostgreSQL LargeObjects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-named" = callPackage @@ -207818,8 +195237,6 @@ self: { testHaskellDepends = [ base generics-sop hspec postgresql-simple ]; description = "Generic deserialization of PostgreSQL rows based on column names"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-orm" = callPackage @@ -207938,8 +195355,6 @@ self: { ]; description = "Sql interpolating quasiquote plus some kind of primitive ORM using it"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-schema" = callPackage @@ -208011,8 +195426,6 @@ self: { ]; description = "FFI-like bindings for PostgreSQL stored functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-simple-interpolate" = callPackage @@ -208053,8 +195466,6 @@ self: { testHaskellDepends = [ base bytestring hspec postgresql-simple ]; description = "PostgreSQL Schema Migrations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-simple-named" = callPackage @@ -208074,8 +195485,6 @@ self: { ]; description = "Implementation of named parameters for `postgresql-simple` library"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-simple-opts" = callPackage @@ -208124,8 +195533,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A PostgreSQL backed queue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-simple-sop" = callPackage @@ -208137,8 +195544,6 @@ self: { libraryHaskellDepends = [ base generics-sop postgresql-simple ]; description = "Generic functions for postgresql-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-simple-typed" = callPackage @@ -208155,8 +195560,6 @@ self: { ]; description = "Typed extension for PostgreSQL simple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-simple-url" = callPackage @@ -208177,8 +195580,6 @@ self: { ]; description = "Parse postgres:// url into ConnectInfo"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-syntax" = callPackage @@ -208203,8 +195604,6 @@ self: { ]; description = "PostgreSQL AST parsing and rendering"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-transactional" = callPackage @@ -208259,8 +195658,6 @@ self: { ]; description = "postgresql-tx interfacing for use with postgresql-query"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-tx-simple" = callPackage @@ -208292,8 +195689,6 @@ self: { ]; description = "postgresql-tx interfacing for use with squeal-postgresql"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-tx-squeal-compat-simple" = callPackage @@ -208307,8 +195702,6 @@ self: { ]; description = "Connection interop from postgresql-simple connections to postgresql-libpq connections"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgresql-typed" = callPackage @@ -208353,8 +195746,6 @@ self: { ]; description = "postgresql-typed operations lifted to any instance of MonadBase or MonadBaseControl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postgrest" = callPackage @@ -208438,8 +195829,6 @@ self: { ]; description = "PostgREST extension to map LISTEN/NOTIFY messages to Websockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postie" = callPackage @@ -208458,8 +195847,6 @@ self: { ]; description = "SMTP server library to receive emails from within Haskell programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postmark" = callPackage @@ -208478,8 +195865,6 @@ self: { ]; description = "Library for postmarkapp.com HTTP Api"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postmark-streams" = callPackage @@ -208496,8 +195881,6 @@ self: { ]; description = "Send email via Postmark using io-streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "postmaster" = callPackage @@ -208518,8 +195901,6 @@ self: { ]; description = "Postmaster ESMTP Server"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potato-tool" = callPackage @@ -208533,8 +195914,6 @@ self: { executableHaskellDepends = [ base binary bytestring split ]; description = "Command line Dreamcast VMU filesystem toolset"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potoki" = callPackage @@ -208546,8 +195925,6 @@ self: { libraryHaskellDepends = [ potoki-core ]; description = "Simple streaming in IO"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potoki-cereal" = callPackage @@ -208570,8 +195947,6 @@ self: { ]; description = "Streaming serialization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potoki-conduit" = callPackage @@ -208594,8 +195969,6 @@ self: { ]; description = "Integration of \"potoki\" and \"conduit\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potoki-core" = callPackage @@ -208623,8 +195996,6 @@ self: { benchmarkHaskellDepends = [ criterion rerebase ]; description = "Low-level components of \"potoki\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potoki-hasql" = callPackage @@ -208640,8 +196011,6 @@ self: { ]; description = "Integration of \"potoki\" and \"hasql\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potoki-zlib" = callPackage @@ -208655,8 +196024,6 @@ self: { ]; description = "Streaming ZLib decompression"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "potrace" = callPackage @@ -208686,8 +196053,6 @@ self: { libraryHaskellDepends = [ base diagrams-lib JuicyPixels potrace ]; description = "Potrace bindings for the diagrams library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "powermate" = callPackage @@ -208702,8 +196067,6 @@ self: { executableHaskellDepends = [ base ]; description = "bindings for Griffin PowerMate USB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "powerpc" = callPackage @@ -208715,8 +196078,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Tools for PowerPC programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "powerqueue" = callPackage @@ -208774,8 +196135,6 @@ self: { benchmarkSystemDepends = [ leveldb snappy ]; description = "A high performance in memory and LevelDB backend for powerqueue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) leveldb; inherit (pkgs) snappy;}; "powerqueue-sqs" = callPackage @@ -208789,8 +196148,6 @@ self: { ]; description = "A Amazon SQS backend for powerqueue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ppm" = callPackage @@ -208813,8 +196170,6 @@ self: { libraryHaskellDepends = [ base boxes ]; description = "A library for pretty printing Records"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pptable" = callPackage @@ -208849,8 +196204,6 @@ self: { libraryHaskellDepends = [ base QuickCheck random stm ]; description = "Parallel batch driver for QuickCheck"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pqueue" = callPackage @@ -208878,8 +196231,6 @@ self: { ]; description = "Fully encapsulated monad transformers with queuelike functionality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "practice-room" = callPackage @@ -208898,8 +196249,6 @@ self: { ]; description = "Practice Room"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "praglude" = callPackage @@ -208920,8 +196269,6 @@ self: { ]; description = "A pragmatic Prelude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pragmatic-show" = callPackage @@ -208977,8 +196324,6 @@ self: { ]; description = "Yet another prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "precis" = callPackage @@ -209014,8 +196359,6 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "Prelude replacement"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pred-set" = callPackage @@ -209027,8 +196370,6 @@ self: { libraryHaskellDepends = [ base hashable hashtables HSet ]; description = "Simple cached predicates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pred-trie" = callPackage @@ -209057,8 +196398,6 @@ self: { ]; description = "Predicative tries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "predicate-class" = callPackage @@ -209070,8 +196409,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Helper class for passing context along a predicate value"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "predicate-transformers" = callPackage @@ -209083,8 +196420,6 @@ self: { libraryHaskellDepends = [ adjunctions base deepseq lens mtl ]; description = "A library for writing predicates and transformations over predicates in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "predicate-typed" = callPackage @@ -209111,8 +196446,6 @@ self: { ]; description = "Predicates, Refinement types and Dsl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "predicates" = callPackage @@ -209156,8 +196489,6 @@ self: { ]; description = "Evaluate and display trees of predicates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prednote-test" = callPackage @@ -209180,8 +196511,6 @@ self: { ]; description = "Tests and QuickCheck generators to accompany prednote"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prefetch" = callPackage @@ -209245,8 +196574,6 @@ self: { ]; description = "A library for building a prefork-style server quickly"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pregame" = callPackage @@ -209266,8 +196593,6 @@ self: { ]; description = "Prelude for applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "preliminaries" = callPackage @@ -209289,8 +196614,6 @@ self: { ]; description = "A larger alternative to the Prelude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prelude-compat" = callPackage @@ -209335,8 +196658,6 @@ self: { libraryHaskellDepends = [ base comonad logict transformers ]; description = "Another kind of alternate Prelude file"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prelude-plus" = callPackage @@ -209350,8 +196671,6 @@ self: { libraryHaskellDepends = [ base utf8-string ]; description = "Prelude for rest of us"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prelude-prime" = callPackage @@ -209415,8 +196734,6 @@ self: { ]; description = "Preprocess Haskell Repositories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "preprocessor" = callPackage @@ -209437,8 +196754,6 @@ self: { ]; description = "Remove cpp annotations to get the source ready for static analysis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "preprocessor-tools" = callPackage @@ -209488,8 +196803,6 @@ self: { benchmarkToolDepends = [ alex happy ]; description = "safe PostgreSQL queries using Quasiquoters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "presburger" = callPackage @@ -209504,8 +196817,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "A decision procedure for quantifier-free linear arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "present" = callPackage @@ -209517,8 +196828,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Make presentations for data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "press" = callPackage @@ -209530,8 +196839,6 @@ self: { libraryHaskellDepends = [ base containers json mtl parsec ]; description = "Text template library targeted at the web / HTML generation"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "presto-hdbc" = callPackage @@ -209551,8 +196858,6 @@ self: { ]; description = "An HDBC connector for Presto"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prettify" = callPackage @@ -209676,8 +196981,6 @@ self: { ]; description = "Functionality for beautifying GHCi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pretty-hex" = callPackage @@ -209711,8 +197014,6 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "A implementation of multi-column layout w/ Text.PrettyPrint"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pretty-relative-time" = callPackage @@ -209845,8 +197146,6 @@ self: { testHaskellDepends = [ base hspec tagged ]; description = "A small pretty printing DSL for complex types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prettyFunctionComposing" = callPackage @@ -209992,8 +197291,6 @@ self: { libraryHaskellDepends = [ base lucid prettyprinter text ]; description = "A prettyprinter backend for lucid"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prettyprinter-vty" = callPackage @@ -210007,8 +197304,6 @@ self: { libraryHaskellDepends = [ base prettyprinter vty ]; description = "prettyprinter backend for vty"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "preview" = callPackage @@ -210024,8 +197319,6 @@ self: { ]; description = "The method of previewing data (instead of wholly show-ing it)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prim" = callPackage @@ -210050,8 +197343,6 @@ self: { libraryHaskellDepends = [ base ghc-prim primitive semigroups ]; description = "Primitive byte array with type variable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prim-instances" = callPackage @@ -210064,8 +197355,6 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "Prim typeclass instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prim-ref" = callPackage @@ -210077,8 +197366,6 @@ self: { libraryHaskellDepends = [ base ghc-prim primitive semigroups ]; description = "Primitive byte array with type variable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prim-spoon" = callPackage @@ -210126,8 +197413,6 @@ self: { ]; description = "Primeval world of Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primal-memory" = callPackage @@ -210147,8 +197432,6 @@ self: { ]; description = "Unified interface for memory managemenet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prime" = callPackage @@ -210185,8 +197468,6 @@ self: { benchmarkHaskellDepends = [ base criterion primes ]; description = "Type-safe prime numbers"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primesieve" = callPackage @@ -210246,8 +197527,6 @@ self: { testHaskellDepends = [ base primitive primitive-unlifted ]; description = "Wrappers for primops around atomic operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-checked" = callPackage @@ -210259,8 +197538,6 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "primitive functions with bounds-checking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-containers" = callPackage @@ -210286,8 +197563,6 @@ self: { ]; description = "containers backed by arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-convenience" = callPackage @@ -210299,8 +197574,6 @@ self: { libraryHaskellDepends = [ primitive ]; description = "convenience class for PrimMonad m/PrimState m"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-extras" = callPackage @@ -210335,8 +197608,6 @@ self: { testHaskellDepends = [ base primitive QuickCheck ]; description = "using the `Prim` interface for the FFI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-indexed" = callPackage @@ -210348,8 +197619,6 @@ self: { libraryHaskellDepends = [ base primitive ]; testHaskellDepends = [ base doctest QuickCheck ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-maybe" = callPackage @@ -210367,8 +197636,6 @@ self: { ]; description = "Arrays of Maybes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-offset" = callPackage @@ -210394,8 +197661,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq random vector ]; description = "SIMD data types and functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-sort" = callPackage @@ -210417,8 +197682,6 @@ self: { benchmarkHaskellDepends = [ base gauge ghc-prim primitive random ]; description = "Sort primitive arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-stablename" = callPackage @@ -210430,8 +197693,6 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "primitive operations on StableNames"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primitive-unaligned" = callPackage @@ -210498,8 +197759,6 @@ self: { ]; description = "ImageBoard on Happstack and HSP"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "primula-bot" = callPackage @@ -210518,8 +197777,6 @@ self: { ]; description = "Jabber-bot for primula-board ImageBoard"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pringletons" = callPackage @@ -210536,8 +197793,6 @@ self: { ]; description = "Classes and data structures complementing the singletons library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "print-console-colors" = callPackage @@ -210563,8 +197818,6 @@ self: { libraryHaskellDepends = [ base split ]; description = "Debug print formatting library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "print-info" = callPackage @@ -210592,8 +197845,6 @@ self: { ]; description = "Pretty printing with indentation, mixfix operators, and automatic line breaks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "printf-mauke" = callPackage @@ -210635,8 +197886,6 @@ self: { ]; description = "The Artist Formerly Known as Prints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "printxosd" = callPackage @@ -210661,8 +197910,6 @@ self: { libraryHaskellDepends = [ base containers queue reord stateref ]; description = "Simple implementation of a priority queue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "priority-sync" = callPackage @@ -210765,8 +198012,6 @@ self: { ]; description = "Easy and reasonably efficient probabilistic programming and random generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proc" = callPackage @@ -210785,8 +198030,6 @@ self: { ]; description = "Parse process information for Linux"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proc-net" = callPackage @@ -210839,8 +198082,6 @@ self: { ]; description = "Conduits for processes (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "process-extras" = callPackage @@ -210876,8 +198117,6 @@ self: { ]; description = "IterIO Process Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "process-leksah" = callPackage @@ -210889,8 +198128,6 @@ self: { libraryHaskellDepends = [ base directory filepath unix ]; description = "Process libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "process-listlike" = callPackage @@ -210907,8 +198144,6 @@ self: { ]; description = "Process extras"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "process-progress" = callPackage @@ -210925,8 +198160,6 @@ self: { ]; description = "Run a process and do reportsing on its progress"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "process-qq" = callPackage @@ -210943,8 +198176,6 @@ self: { ]; description = "Quasi-Quoters for exec process"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "process-sequential" = callPackage @@ -210987,8 +198218,6 @@ self: { ]; description = "Streaming interface to system processes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "processing" = callPackage @@ -211007,8 +198236,6 @@ self: { ]; description = "Web graphic applications with processing.js."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "processing-for-haskell" = callPackage @@ -211036,8 +198263,6 @@ self: { libraryHaskellDepends = [ base binary bytestring process ]; description = "C bindings for the gnu-extension functions process_vm_readv and process_vm_writev"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "processor-creative-kit" = callPackage @@ -211076,8 +198301,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell values that cannot be evaluated immediately"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "procstat" = callPackage @@ -211089,8 +198312,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring ]; description = "get information on processes in Linux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proctest" = callPackage @@ -211126,8 +198347,6 @@ self: { ]; description = "Simple streaming datatype"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "product" = callPackage @@ -211184,8 +198403,6 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Generate flamegraphs from ghc RTS .prof files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prof2dot" = callPackage @@ -211201,8 +198418,6 @@ self: { ]; description = "Convert GHC profiles into GraphViz's dot format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prof2pretty" = callPackage @@ -211221,8 +198436,6 @@ self: { ]; description = "generate pretty source from time/allocation profiles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "profiterole" = callPackage @@ -211311,8 +198524,6 @@ self: { ]; description = "Monadic bidirectional programming"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "profunctor-optics" = callPackage @@ -211382,8 +198593,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "Simple progress tracking & projection library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "progress-meter" = callPackage @@ -211395,8 +198604,6 @@ self: { libraryHaskellDepends = [ ansi-terminal async base stm ]; description = "Live diagnostics for concurrent activity"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "progress-reporting" = callPackage @@ -211410,8 +198617,6 @@ self: { libraryHaskellDepends = [ base deepseq mtl time ]; description = "Functionality for reporting function progress"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "progressbar" = callPackage @@ -211425,8 +198630,6 @@ self: { libraryHaskellDepends = [ base io-reactive ]; description = "Progressbar API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "progression" = callPackage @@ -211443,8 +198646,6 @@ self: { ]; description = "Automates the recording and graphing of criterion benchmarks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "progressive" = callPackage @@ -211463,8 +198664,6 @@ self: { ]; description = "Multilabel classification model which learns sequentially (online)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proj4-hs-bindings" = callPackage @@ -211477,8 +198676,6 @@ self: { librarySystemDepends = [ proj ]; description = "Haskell bindings for the Proj4 C dynamic library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) proj;}; "project-m36" = callPackage @@ -211549,8 +198746,6 @@ self: { ]; description = "Relational Algebra Engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "project-template" = callPackage @@ -211591,8 +198786,6 @@ self: { ]; description = "Go to README.md"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "projection" = callPackage @@ -211634,8 +198827,6 @@ self: { ]; description = "Profunctor-based lightweight implementation of optics"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prolog" = callPackage @@ -211669,8 +198860,6 @@ self: { ]; description = "A command line tool to visualize query resolution in Prolog"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prolog-graph-lib" = callPackage @@ -211707,8 +198896,6 @@ self: { ]; description = "Better, more general Prelude exporting common utilities"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prolude" = callPackage @@ -211730,8 +198917,6 @@ self: { ]; description = "ITProTV's custom prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prometheus" = callPackage @@ -211802,8 +198987,6 @@ self: { benchmarkHaskellDepends = [ base criterion text ]; description = "Instrument applications with metrics and publish/push to Prometheus"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prometheus-metrics-ghc" = callPackage @@ -211867,8 +199050,6 @@ self: { libraryHaskellDepends = [ async base ]; description = "A monadic interface for async"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "promises" = callPackage @@ -211911,8 +199092,6 @@ self: { ]; description = "A library for interfacing with the CMU Pronouncing Dictionary"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proof-combinators" = callPackage @@ -211924,8 +199103,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Proof Combinators used in Liquid Haskell for Theorem Proving"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "propane" = callPackage @@ -211941,8 +199118,6 @@ self: { ]; description = "Functional synthesis of images and animations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "propeller" = callPackage @@ -211987,8 +199162,6 @@ self: { libraryHaskellDepends = [ base ]; description = "check quickCheck properties in real time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "property" = callPackage @@ -212019,8 +199192,6 @@ self: { ]; description = "Apple property list parser"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proplang" = callPackage @@ -212032,8 +199203,6 @@ self: { libraryHaskellDepends = [ base glade glib gtk ]; description = "A library for functional GUI development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "props" = callPackage @@ -212073,8 +199242,6 @@ self: { ]; description = "A simple language for writing documents"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prosidyc" = callPackage @@ -212091,8 +199258,6 @@ self: { ]; description = "A DSL for processing Prosidy documents"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prospect" = callPackage @@ -212128,8 +199293,6 @@ self: { ]; description = "Bindings to the Prosper marketplace API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proteaaudio" = callPackage @@ -212148,8 +199311,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Simple audio library for Windows, Linux, OSX"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {libpulse = null; libpulse-simple = null; inherit (pkgs) libpulseaudio;}; @@ -212167,8 +199328,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Simple audio library for SDL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) SDL2;}; "proteome" = callPackage @@ -212208,8 +199367,6 @@ self: { ]; description = "neovim project manager"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proto-lens" = callPackage @@ -212246,8 +199403,6 @@ self: { ]; description = "Arbitrary instances for proto-lens"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proto-lens-combinators" = callPackage @@ -212269,8 +199424,6 @@ self: { ]; description = "Utilities functions to proto-lens"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proto-lens-descriptors" = callPackage @@ -212287,8 +199440,6 @@ self: { ]; description = "Protocol buffers for describing the definitions of messages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proto-lens-jsonpb" = callPackage @@ -212318,8 +199469,6 @@ self: { ]; description = "Adapting proto-lens to optparse-applicative ReadMs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proto-lens-protobuf-types" = callPackage @@ -212431,8 +199580,6 @@ self: { ]; description = "A low level library for writing out data in the Protocol Buffers wire format"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proto3-wire" = callPackage @@ -212456,8 +199603,6 @@ self: { ]; description = "A low-level implementation of the Protocol Buffers (version 3) wire format"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "protobuf" = callPackage @@ -212502,8 +199647,6 @@ self: { ]; description = "Protocol Buffers via C++"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "protobuf-simple" = callPackage @@ -212540,8 +199683,6 @@ self: { libraryHaskellDepends = [ base freer-indexed singletons ]; description = "Model distributed system as type-level multi-party protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "protocol-buffers" = callPackage @@ -212591,8 +199732,6 @@ self: { ]; description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "protocol-buffers-fork" = callPackage @@ -212609,8 +199748,6 @@ self: { ]; description = "Parse Google Protocol Buffer specifications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "protocol-radius" = callPackage @@ -212677,8 +199814,6 @@ self: { ]; description = "Protolude with lifted-base and lifted-async"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proton" = callPackage @@ -212696,8 +199831,6 @@ self: { transformers ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proton-haskell" = callPackage @@ -212716,8 +199849,6 @@ self: { ]; description = "Simple XML templating library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prototype" = callPackage @@ -212729,8 +199860,6 @@ self: { libraryHaskellDepends = [ base monads-tf ]; description = "prototype-based programming on Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prove-everywhere-server" = callPackage @@ -212751,8 +199880,6 @@ self: { ]; description = "The server for ProveEverywhere"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "provenience" = callPackage @@ -212771,8 +199898,6 @@ self: { ]; description = "Computations that automatically track data dependencies"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proxied" = callPackage @@ -212806,8 +199931,6 @@ self: { libraryHaskellDepends = [ base tagged ]; description = "A library for kind-polymorphic manipulation and inspection of Proxy values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "proxy-mapping" = callPackage @@ -212819,8 +199942,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Mapping of Proxy Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "prune-juice" = callPackage @@ -212880,8 +200001,6 @@ self: { ]; description = "Language support for the PureScript programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pseudo-boolean" = callPackage @@ -212906,8 +200025,6 @@ self: { ]; description = "Reading/Writing OPB/WBO files used in pseudo boolean competition"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pseudo-trie" = callPackage @@ -212921,8 +200038,6 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "A tagged rose-tree with short circuited unique leaves"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pseudomacros" = callPackage @@ -213060,8 +200175,6 @@ self: { benchmarkHaskellDepends = [ gauge rerebase ]; description = "Pointer poking action construction and composition toolkit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ptrdiff" = callPackage @@ -213142,8 +200255,6 @@ self: { testHaskellDepends = [ base cereal HUnit publicsuffixlist ]; description = "Create the publicsuffixlist package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "publish" = callPackage @@ -213170,8 +200281,6 @@ self: { ]; description = "Publishing tools for papers, books, and presentations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pubnub" = callPackage @@ -213204,8 +200313,6 @@ self: { ]; description = "PubNub Haskell SDK"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pubsub" = callPackage @@ -213224,8 +200331,6 @@ self: { executableHaskellDepends = [ fastcgi ]; description = "A library for Google/SixApart pubsub hub interaction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "puffytools" = callPackage @@ -213255,8 +200360,6 @@ self: { ]; description = "A CLI assistant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pugixml" = callPackage @@ -213273,8 +200376,6 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hunit ]; description = "pugixml binding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pugs-DrIFT" = callPackage @@ -213298,8 +200399,6 @@ self: { ]; description = "DrIFT with pugs-specific rules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pugs-HsSyck" = callPackage @@ -213332,8 +200431,6 @@ self: { ]; description = "Portable Haskell/POSIX layer for Pugs"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pugs-hsregex" = callPackage @@ -213345,8 +200442,6 @@ self: { libraryHaskellDepends = [ array base haskell98 ]; description = "Haskell PCRE binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pulse" = callPackage @@ -213403,8 +200498,6 @@ self: { ]; description = "Multilingual unsupervised sentence tokenization with Punkt"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "punycode" = callPackage @@ -213439,8 +200532,6 @@ self: { ]; description = "A program that displays the puppet resources associated to a node given .pp files."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pure-cdb" = callPackage @@ -213459,8 +200550,6 @@ self: { ]; description = "Another pure-haskell CDB (Constant Database) implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pure-fft" = callPackage @@ -213485,8 +200574,6 @@ self: { libraryHaskellDepends = [ base containers mtl safe ]; description = "Pure IO monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pure-priority-queue" = callPackage @@ -213498,8 +200585,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A pure priority queue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pure-priority-queue-tests" = callPackage @@ -213518,8 +200603,6 @@ self: { ]; description = "Tests for the pure-priority-queue package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pure-shuffle" = callPackage @@ -213560,8 +200643,6 @@ self: { benchmarkHaskellDepends = [ base base-compat bytestring time ]; description = "A Haskell-only implementation of zlib / DEFLATE"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pureMD5" = callPackage @@ -213631,8 +200712,6 @@ self: { testHaskellDepends = [ base ]; description = "Simple Routing functions for Wai Applications"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "purescript" = callPackage @@ -213707,8 +200786,6 @@ self: { doCheck = false; description = "PureScript Programming Language Compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "purescript-ast" = callPackage @@ -213726,8 +200803,6 @@ self: { ]; description = "PureScript Programming Language Abstract Syntax Tree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "purescript-bridge" = callPackage @@ -213789,8 +200864,6 @@ self: { testToolDepends = [ happy ]; description = "PureScript Programming Language Concrete Syntax Tree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "purescript-iso" = callPackage @@ -213820,8 +200893,6 @@ self: { ]; description = "Isomorphic trivial data type definitions over JSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "purescript-tsd-gen" = callPackage @@ -213844,8 +200915,6 @@ self: { ]; description = "TypeScript Declaration File (.d.ts) generator for PureScript"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pursuit-client" = callPackage @@ -213881,8 +200950,6 @@ self: { ]; description = "Push notifications for Android and iOS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "push-notify" = callPackage @@ -213906,8 +200973,6 @@ self: { ]; description = "A server-side library for sending push notifications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "push-notify-apn" = callPackage @@ -213933,8 +200998,6 @@ self: { testHaskellDepends = [ aeson base hspec ]; description = "Send push notifications to mobile iOS devices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "push-notify-ccs" = callPackage @@ -213954,8 +201017,6 @@ self: { ]; description = "A server-side library for sending/receiving push notifications through CCS (Google Cloud Messaging)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "push-notify-general" = callPackage @@ -213974,8 +201035,6 @@ self: { ]; description = "A general library for sending/receiving push notif. through dif. services."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pushbullet" = callPackage @@ -214024,8 +201083,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A Pusher.com client written in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pusher-http-haskell" = callPackage @@ -214066,8 +201123,6 @@ self: { ]; description = "Implementation of the Pusher WebSocket protocol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pushme" = callPackage @@ -214093,8 +201148,6 @@ self: { ]; description = "Tool to synchronize directories with rsync, zfs or git-annex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pushover" = callPackage @@ -214131,8 +201184,6 @@ self: { ]; description = "Put-based lens library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "puzzle-draw" = callPackage @@ -214164,8 +201215,6 @@ self: { ]; description = "Creating graphics for pencil puzzles"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "puzzle-draw-cmdline" = callPackage @@ -214184,8 +201233,6 @@ self: { ]; description = "Creating graphics for pencil puzzles, command line tools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pvar" = callPackage @@ -214223,8 +201270,6 @@ self: { executableSystemDepends = [ libdevil ]; description = "A photo viewer daemon application with remote controlling abilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libdevil;}; "pvss" = callPackage @@ -214329,8 +201374,6 @@ self: { libraryPkgconfigDepends = [ python ]; description = "Call python inline from haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {python = null;}; "pyfi" = callPackage @@ -214347,8 +201390,6 @@ self: { libraryPkgconfigDepends = [ python ]; description = "Call python inline from haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {python = null;}; "python-pickle" = callPackage @@ -214372,8 +201413,6 @@ self: { ]; description = "Serialization/deserialization using Python Pickle format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "q4c12-twofinger" = callPackage @@ -214392,8 +201431,6 @@ self: { ]; description = "Efficient alternating finger trees"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qc-oi-testgenerator" = callPackage @@ -214407,8 +201444,6 @@ self: { ]; description = "Compile time generation of operation invariance tests for QuickCheck"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qchas" = callPackage @@ -214437,8 +201472,6 @@ self: { librarySystemDepends = [ qd ]; description = "double-double and quad-double number type via libqd"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {qd = null;}; "qd-vec" = callPackage @@ -214450,8 +201483,6 @@ self: { libraryHaskellDepends = [ base qd Vec ]; description = "'Vec' instances for 'qd' types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qed" = callPackage @@ -214470,8 +201501,6 @@ self: { testHaskellDepends = [ base transformers ]; description = "Simple prover"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qhs" = callPackage @@ -214495,8 +201524,6 @@ self: { ]; description = "Command line tool qhs, SQL queries on CSV and TSV files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qhull-simple" = callPackage @@ -214509,8 +201536,6 @@ self: { librarySystemDepends = [ qhull ]; description = "Simple bindings to Qhull, a library for computing convex hulls"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) qhull;}; "qif" = callPackage @@ -214530,8 +201555,6 @@ self: { ]; description = "A simple QIF file format parser / printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qlinear" = callPackage @@ -214552,8 +201575,6 @@ self: { ]; description = "Typesafe library for linear algebra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qm-interpolated-string" = callPackage @@ -214601,8 +201622,6 @@ self: { ]; description = "Decrypt files encrypted by QNAP's Hybrid Backup Sync"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qq-literals" = callPackage @@ -214654,8 +201673,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Library to generate images"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) qrencode;}; "qr-repa" = callPackage @@ -214675,8 +201692,6 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Library to generate QR codes from bytestrings and objects and scale image files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qrcode" = callPackage @@ -214732,8 +201747,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "quantity semaphores"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qt" = callPackage @@ -214908,8 +201921,6 @@ self: { executableHaskellDepends = [ base ]; description = "Quant finance library in pure Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quantification" = callPackage @@ -214926,8 +201937,6 @@ self: { ]; description = "Rage against the quantification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quantities" = callPackage @@ -214959,8 +201968,6 @@ self: { libraryHaskellDepends = [ base MonadRandom mtl QuickCheck random ]; description = "An embedding of quantum computation as a Haskell arrow"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quantum-random" = callPackage @@ -214983,8 +201990,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Retrieve, store and manage real quantum random data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quarantimer" = callPackage @@ -215006,8 +202011,6 @@ self: { ]; description = "Coronavirus quarantine timer web app for your things"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "qudb" = callPackage @@ -215026,8 +202029,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Quite Useless DB"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quenya-verb" = callPackage @@ -215050,8 +202051,6 @@ self: { executableHaskellDepends = [ base ]; description = "Quenya verb conjugator"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "queryparser" = callPackage @@ -215071,8 +202070,6 @@ self: { benchmarkHaskellDepends = [ base criterion text ]; description = "Analysis and parsing library for SQL queries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "queryparser-demo" = callPackage @@ -215089,8 +202086,6 @@ self: { ]; description = "Demo package containing queryparser examples"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "queryparser-hive" = callPackage @@ -215110,8 +202105,6 @@ self: { ]; description = "Parsing for Hive SQL queries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "queryparser-presto" = callPackage @@ -215131,8 +202124,6 @@ self: { ]; description = "Parsing for Presto SQL queries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "queryparser-vertica" = callPackage @@ -215152,8 +202143,6 @@ self: { ]; description = "Parsing for Vertica SQL queries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "querystring-pickle" = callPackage @@ -215187,8 +202176,6 @@ self: { ]; description = "A package for prompting values from the command-line"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "queue" = callPackage @@ -215211,8 +202198,6 @@ self: { libraryHaskellDepends = [ array base containers mtl stateful-mtl ]; description = "A library of queuelike data structures, both functional and stateful"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quick-generator" = callPackage @@ -215243,8 +202228,6 @@ self: { ]; description = "Slimmed down json schema language and validator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickbench" = callPackage @@ -215265,8 +202248,6 @@ self: { testHaskellDepends = [ base ]; description = "quick & easy benchmarking of command-line programs"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickbooks" = callPackage @@ -215285,8 +202266,6 @@ self: { ]; description = "QuickBooks API binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-arbitrary-adt" = callPackage @@ -215320,8 +202299,6 @@ self: { ]; description = "Generate QuickCheck Gen for Sum Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-assertions" = callPackage @@ -215460,8 +202437,6 @@ self: { ]; description = "Automating QuickCheck for polymorphic and overlaoded properties"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-properties" = callPackage @@ -215484,8 +202459,6 @@ self: { libraryHaskellDepends = [ base mtl QuickCheck ]; description = "Combinators for Quickcheck Property construction and diagnostics"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-property-monad" = callPackage @@ -215497,8 +202470,6 @@ self: { libraryHaskellDepends = [ base either QuickCheck transformers ]; description = "A monad for generating QuickCheck properties without Arbitrary instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-regex" = callPackage @@ -215514,8 +202485,6 @@ self: { ]; description = "Generate regex-constrained strings for QuickCheck"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-relaxng" = callPackage @@ -215531,8 +202500,6 @@ self: { ]; description = "Generate RelaxNG-constrained XML documents for QuickCheck"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-rematch" = callPackage @@ -215545,8 +202512,6 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck rematch ]; description = "QuickCheck support for rematch"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-report" = callPackage @@ -215562,8 +202527,6 @@ self: { ]; description = "Customizable reports for quickcheck properties"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-script" = callPackage @@ -215638,8 +202601,6 @@ self: { ]; description = "Test monadic programs using state machine based models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-state-machine-distributed" = callPackage @@ -215663,8 +202624,6 @@ self: { ]; description = "Test monadic programs using state machine based models"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-string-random" = callPackage @@ -215681,8 +202640,6 @@ self: { ]; description = "Helper to build generators with Text.StringRandom"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-text" = callPackage @@ -215728,8 +202685,6 @@ self: { libraryHaskellDepends = [ base QuickCheck transformers webdriver ]; description = "Utilities for using WebDriver with QuickCheck"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickcheck-with-counterexamples" = callPackage @@ -215764,8 +202719,6 @@ self: { ]; description = "Wrapper for the QuickJS Javascript Engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quicklz" = callPackage @@ -215798,8 +202751,6 @@ self: { testHaskellDepends = [ base directory filepath QuickCheck ]; description = "Generate Main module with QuickCheck tests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickselect" = callPackage @@ -215825,8 +202776,6 @@ self: { libraryHaskellDepends = [ base vector vector-algorithms ]; description = "Very fast and memory-compact query-only set and map structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickson" = callPackage @@ -215856,8 +202805,6 @@ self: { ]; description = "Equational laws for free!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickterm" = callPackage @@ -215891,8 +202838,6 @@ self: { ]; description = "A reflective batch tester for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quickwebapp" = callPackage @@ -215911,8 +202856,6 @@ self: { ]; description = "A quick webapp generator for any file processing tool"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiet" = callPackage @@ -215941,8 +202884,6 @@ self: { doHaddock = false; description = "Meta-package for Quipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-algorithms" = callPackage @@ -215966,8 +202907,6 @@ self: { executableHaskellDepends = [ base ]; description = "A set of algorithms implemented in Quipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-all" = callPackage @@ -215983,8 +202922,6 @@ self: { doHaddock = false; description = "Meta-package for Quipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-cabal" = callPackage @@ -215996,8 +202933,6 @@ self: { libraryHaskellDepends = [ base Cabal process quipper-language ]; description = "Some functions to aid in the creation of Cabal packages for Quipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-core" = callPackage @@ -216013,8 +202948,6 @@ self: { ]; description = "An embedded, scalable functional programming language for quantum computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-demos" = callPackage @@ -216035,8 +202968,6 @@ self: { doHaddock = false; description = "Miscellaneous code snippets that illustrate various Quipper features"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-language" = callPackage @@ -216057,8 +202988,6 @@ self: { executableHaskellDepends = [ base process ]; description = "Quipper, an embedded functional programming language for quantum computation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-libraries" = callPackage @@ -216081,8 +203010,6 @@ self: { ]; description = "The standard libraries for Quipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-rendering" = callPackage @@ -216099,8 +203026,6 @@ self: { ]; description = "An embedded, scalable functional programming language for quantum computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-tools" = callPackage @@ -216122,8 +203047,6 @@ self: { doHaddock = false; description = "Miscellaneous stand-alone tools for Quipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quipper-utils" = callPackage @@ -216140,8 +203063,6 @@ self: { ]; description = "Utility libraries for Quipper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver" = callPackage @@ -216153,8 +203074,6 @@ self: { libraryHaskellDepends = [ base mmorph transformers ]; description = "Quiver finite stream processing library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-binary" = callPackage @@ -216171,8 +203090,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck quiver transformers ]; description = "Binary serialisation support for Quivers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-bytestring" = callPackage @@ -216184,8 +203101,6 @@ self: { libraryHaskellDepends = [ base bytestring quiver ]; description = "Quiver combinators for bytestring streaming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-cell" = callPackage @@ -216197,8 +203112,6 @@ self: { libraryHaskellDepends = [ base data-cell quiver ]; description = "Quiver combinators for cellular data processing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-csv" = callPackage @@ -216214,8 +203127,6 @@ self: { ]; description = "Quiver combinators for cellular CSV data processing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-enumerator" = callPackage @@ -216227,8 +203138,6 @@ self: { libraryHaskellDepends = [ base enumerator quiver ]; description = "Bridge between Quiver and Iteratee paradigms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-groups" = callPackage @@ -216241,8 +203150,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck quiver ]; description = "Group and chunk values within a Quiver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-http" = callPackage @@ -216260,8 +203167,6 @@ self: { ]; description = "Adapter to stream over HTTP(s) with quiver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-instances" = callPackage @@ -216277,8 +203182,6 @@ self: { ]; description = "Extra instances for Quiver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-interleave" = callPackage @@ -216291,8 +203194,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck quiver ]; description = "Interleave values from multiple Quivers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quiver-sort" = callPackage @@ -216316,8 +203217,6 @@ self: { ]; description = "Sort the values in a quiver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quokka" = callPackage @@ -216336,8 +203235,6 @@ self: { ]; description = "Test helpers which help generate data for projects that use postgresql"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quoridor-hs" = callPackage @@ -216362,8 +203259,6 @@ self: { testHaskellDepends = [ base HUnit mtl ]; description = "A Quoridor implementation in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "quote-quot" = callPackage @@ -216399,8 +203294,6 @@ self: { ]; description = "Command line binary for working with the Qux language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "r-glpk-phonetic-languages-ukrainian-durations" = callPackage @@ -216475,8 +203368,6 @@ self: { ]; description = "The raaz cryptographic library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rabocsv2qif" = callPackage @@ -216506,8 +203397,6 @@ self: { libraryHaskellDepends = [ array base containers data-reify ]; description = "Reverse Automatic Differentiation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "radian" = callPackage @@ -216522,8 +203411,6 @@ self: { testHaskellDepends = [ base HUnit lens ]; description = "Isomorphisms for measurements that use radians"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "radium" = callPackage @@ -216540,8 +203427,6 @@ self: { ]; description = "Chemistry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "radium-formula-parser" = callPackage @@ -216557,8 +203442,6 @@ self: { ]; description = "Chemistry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "radius" = callPackage @@ -216587,8 +203470,6 @@ self: { executableHaskellDepends = [ base filepath ]; description = "Command-line tool for emitting numbers in various bases"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "radix-tree" = callPackage @@ -216657,8 +203538,6 @@ self: { ]; description = "librados haskell bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {rados = null;}; "raft" = callPackage @@ -216677,8 +203556,6 @@ self: { ]; description = "Miscellaneous Haskell utilities for data structures and data manipulation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rail-compiler-editor" = callPackage @@ -216701,8 +203578,6 @@ self: { testHaskellDepends = [ base containers HUnit process ]; description = "Compiler and editor for the esolang rail"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rails-session" = callPackage @@ -216726,8 +203601,6 @@ self: { ]; description = "Decrypt Ruby on Rails sessions in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rainbow" = callPackage @@ -216758,8 +203631,6 @@ self: { ]; description = "Tests and QuickCheck generators to accompany rainbow"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rainbox" = callPackage @@ -216820,8 +203691,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "distributed-process node"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rakhana" = callPackage @@ -216838,8 +203707,6 @@ self: { ]; description = "Stream based PDF library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rakuten" = callPackage @@ -216864,8 +203731,6 @@ self: { ]; description = "The Rakuten API in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ral" = callPackage @@ -216923,8 +203788,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Random access list with a list compatible interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rallod" = callPackage @@ -216937,8 +203800,6 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "'$' in reverse"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "raml" = callPackage @@ -216954,8 +203815,6 @@ self: { ]; description = "RESTful API Modeling Language (RAML) library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rampart" = callPackage @@ -216994,8 +203853,6 @@ self: { libraryHaskellDepends = [ array base IntervalMap mtl random ]; description = "Random variable library, with Functor, Applicative and Monad instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "randfile" = callPackage @@ -217014,8 +203871,6 @@ self: { ]; description = "Program for picking a random file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rando" = callPackage @@ -217030,8 +203885,6 @@ self: { ]; description = "Easy-to-use randomness for livecoding"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "random" = callPackage @@ -217105,8 +203958,6 @@ self: { libraryHaskellDepends = [ array base containers ]; description = "Random-access lists in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "random-bytestring" = callPackage @@ -217148,8 +203999,6 @@ self: { libraryHaskellDepends = [ base random template-haskell ]; description = "A Template Haskell helper for deriving Random instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "random-eff" = callPackage @@ -217161,8 +204010,6 @@ self: { libraryHaskellDepends = [ base extensible-effects random ]; description = "A simple random generator library for extensible-effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "random-effin" = callPackage @@ -217174,8 +204021,6 @@ self: { libraryHaskellDepends = [ base effin random ]; description = "A simple random generator library for effin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "random-extras" = callPackage @@ -217254,8 +204099,6 @@ self: { ]; description = "Random variate generation from hypergeometric distributions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "random-names" = callPackage @@ -217324,8 +204167,6 @@ self: { libraryHaskellDepends = [ base binary bytestring random ]; description = "An infinite stream of random data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "random-string" = callPackage @@ -217470,8 +204311,6 @@ self: { ]; description = "Memory efficient sets with ranges of elements"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "range-space" = callPackage @@ -217492,8 +204331,6 @@ self: { ]; description = "A Range type with vector-space instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ranged-list" = callPackage @@ -217518,8 +204355,6 @@ self: { libraryHaskellDepends = [ base containers primitive vector ]; description = "Linear range-min algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ranges" = callPackage @@ -217601,8 +204436,6 @@ self: { ]; description = "Rapid prototyping with GHCi: hot reloading of running components and reload-surviving values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rapid-term" = callPackage @@ -217618,8 +204451,6 @@ self: { ]; description = "External terminal support for rapid"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa" = callPackage @@ -217644,8 +204475,6 @@ self: { ]; description = "A modular text editor"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-example-config" = callPackage @@ -217665,8 +204494,6 @@ self: { ]; description = "Example user config for Rasa"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-bufs" = callPackage @@ -217681,8 +204508,6 @@ self: { ]; description = "Rasa Ext for useful buffer utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-cmd" = callPackage @@ -217697,8 +204522,6 @@ self: { ]; description = "Rasa Ext for running commands"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-cursors" = callPackage @@ -217714,8 +204537,6 @@ self: { ]; description = "Rasa Ext adding cursor(s)"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-files" = callPackage @@ -217732,8 +204553,6 @@ self: { ]; description = "Rasa Ext for filesystem actions"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-logger" = callPackage @@ -217745,8 +204564,6 @@ self: { libraryHaskellDepends = [ base lens mtl rasa ]; description = "Rasa Ext for logging state/actions"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-slate" = callPackage @@ -217763,8 +204580,6 @@ self: { ]; description = "Rasa extension for rendering to terminal with vty"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-status-bar" = callPackage @@ -217776,8 +204591,6 @@ self: { libraryHaskellDepends = [ base data-default lens rasa yi-rope ]; description = "Rasa Ext for populating status-bar"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-style" = callPackage @@ -217789,8 +204602,6 @@ self: { libraryHaskellDepends = [ base data-default lens rasa ]; description = "Rasa Ext managing rendering styles"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-views" = callPackage @@ -217807,8 +204618,6 @@ self: { ]; description = "Rasa Ext managing rendering views"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasa-ext-vim" = callPackage @@ -217827,8 +204636,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Rasa Ext for vim bindings"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rascal" = callPackage @@ -217857,8 +204664,6 @@ self: { ]; description = "A command-line client for Reddit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rasterific-svg" = callPackage @@ -217976,8 +204781,6 @@ self: { benchmarkHaskellDepends = [ base-noprelude gauge relude ]; description = "Client for rating.chgk.info API and CSV tables (documentation in Russian)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rating-systems" = callPackage @@ -218016,8 +204819,6 @@ self: { ]; description = "finite or repeating lists"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rattle" = callPackage @@ -218051,8 +204852,6 @@ self: { ]; description = "Forward build system, with caching and speculation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rattletrap" = callPackage @@ -218073,8 +204872,6 @@ self: { testHaskellDepends = [ base bytestring filepath HUnit ]; description = "Parse and generate Rocket League replays"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "raven-haskell" = callPackage @@ -218110,8 +204907,6 @@ self: { ]; description = "Sentry http interface for Scotty web server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "raw-feldspar" = callPackage @@ -218135,8 +204930,6 @@ self: { ]; description = "Resource-Aware Feldspar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "raw-strings-qq" = callPackage @@ -218178,8 +204971,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Anonymous extensible records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rawstring-qm" = callPackage @@ -218208,8 +204999,6 @@ self: { ]; description = "Random Access Zippers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "razom-text-util" = callPackage @@ -218228,8 +205017,6 @@ self: { testHaskellDepends = [ base QuickCheck regex-applicative smaoin ]; description = "Common text/parsing tools for Razom language packages"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rbpcp-api" = callPackage @@ -218265,8 +205052,6 @@ self: { executableHaskellDepends = [ base bio bytestring containers ]; description = "Mask nucleotide (EST) sequences in Fasta format"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rbst" = callPackage @@ -218289,8 +205074,6 @@ self: { benchmarkHaskellDepends = [ base gauge mwc-random ]; description = "Randomized Binary Search Trees"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rc" = callPackage @@ -218314,8 +205097,6 @@ self: { ]; description = "Reservoir Computing, fast RNNs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rclient" = callPackage @@ -218331,8 +205112,6 @@ self: { ]; description = "Haskell client for Rserve"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rcu" = callPackage @@ -218426,8 +205205,6 @@ self: { ]; description = "A Haskell wrapper for Rdio's API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rdtsc" = callPackage @@ -218481,8 +205258,6 @@ self: { ]; description = "A binding to React based on the Flux application architecture for GHCJS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "react-flux-servant" = callPackage @@ -218494,8 +205269,6 @@ self: { libraryHaskellDepends = [ aeson base react-flux servant text ]; description = "Allow react-flux stores to send requests to a servant server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "react-haskell" = callPackage @@ -218513,8 +205286,6 @@ self: { ]; description = "Haskell React bindings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "react-tutorial-haskell-server" = callPackage @@ -218532,8 +205303,6 @@ self: { ]; description = "react-tutorial web server"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reaction-logic" = callPackage @@ -218548,8 +205317,6 @@ self: { executableHaskellDepends = [ base mtl QuickCheck ]; description = "pluggable pure logic serializable reactor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive" = callPackage @@ -218579,8 +205346,6 @@ self: { testHaskellDepends = [ base containers HUnit old-time stm ]; description = "FRP (functional reactive programming) framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-balsa" = callPackage @@ -218602,8 +205367,6 @@ self: { ]; description = "Programmatically edit MIDI events via ALSA and reactive-banana"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana" = callPackage @@ -218626,8 +205389,6 @@ self: { ]; description = "Library for functional reactive programming (FRP)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana-automation" = callPackage @@ -218644,8 +205405,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "home (etc) automation using reactive-banana"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana-bunch" = callPackage @@ -218661,8 +205420,6 @@ self: { ]; description = "Extend reactive-banana to multiple events per time point"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana-gi-gtk" = callPackage @@ -218679,8 +205436,6 @@ self: { testHaskellDepends = [ base ]; description = "Simple reactive programming with GTK GObject Introspection"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana-sdl" = callPackage @@ -218697,8 +205452,6 @@ self: { ]; description = "Reactive Banana bindings for SDL"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana-sdl2" = callPackage @@ -218711,8 +205464,6 @@ self: { testHaskellDepends = [ base ]; description = "Reactive Banana integration with SDL2"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana-threepenny" = callPackage @@ -218727,8 +205478,6 @@ self: { libraryHaskellDepends = [ base reactive-banana threepenny-gui ]; description = "Examples for the reactive-banana library, using threepenny-gui"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-banana-wx" = callPackage @@ -218746,8 +205495,6 @@ self: { ]; description = "Examples for the reactive-banana library, using wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-fieldtrip" = callPackage @@ -218764,8 +205511,6 @@ self: { ]; description = "Connect Reactive and FieldTrip"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-glut" = callPackage @@ -218781,8 +205526,6 @@ self: { ]; description = "Connects Reactive and GLUT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-haskell" = callPackage @@ -218825,8 +205568,6 @@ self: { ]; description = "Process MIDI events via reactive-banana and JACK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-midyim" = callPackage @@ -218846,8 +205587,6 @@ self: { ]; description = "Process MIDI events via reactive-banana"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactive-thread" = callPackage @@ -218864,8 +205603,6 @@ self: { ]; description = "Reactive programming via imperative threads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reactivity" = callPackage @@ -218900,8 +205637,6 @@ self: { ]; description = "Reactor - task parallel reactive programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "read-bounded" = callPackage @@ -218913,8 +205648,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Class for reading bounded values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "read-ctags" = callPackage @@ -218937,8 +205670,6 @@ self: { base bytestring containers directory hspec text ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "read-editor" = callPackage @@ -218976,8 +205707,6 @@ self: { testHaskellDepends = [ base containers directory filepath hspec ]; description = "Read IO library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "readability" = callPackage @@ -218998,8 +205727,6 @@ self: { ]; description = "Extracts text of main article from HTML document"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "readable" = callPackage @@ -219053,8 +205780,6 @@ self: { librarySystemDepends = [ ncurses readline ]; description = "An interface to the GNU readline library"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses; inherit (pkgs) readline;}; "readline-statevar" = callPackage @@ -219066,8 +205791,6 @@ self: { libraryHaskellDepends = [ base readline StateVar ]; description = "Readline with variables (setX/getY) wrapped in state vars"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "readme-lhs" = callPackage @@ -219089,8 +205812,6 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Literate programming support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "readpyc" = callPackage @@ -219104,8 +205825,6 @@ self: { executableHaskellDepends = [ base bliplib parseargs ]; description = "Read and pretty print Python bytecode (.pyc) files."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "readshp" = callPackage @@ -219123,8 +205842,6 @@ self: { ]; description = "Code for reading ESRI Shapefiles"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "real-day-end" = callPackage @@ -219152,8 +205869,6 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "A really simple XML parser"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reanimate" = callPackage @@ -219190,8 +205905,6 @@ self: { ]; description = "Animation library based on SVGs"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reanimate-svg" = callPackage @@ -219217,8 +205930,6 @@ self: { ]; description = "SVG file loader and serializer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reason-export" = callPackage @@ -219251,8 +205962,6 @@ self: { libraryHaskellDepends = [ base mtl split template-haskell ]; description = "Lens implementation. It is more small but adequately."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reasonable-operational" = callPackage @@ -219361,8 +206070,6 @@ self: { ]; description = "Anonymous records"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "record-aeson" = callPackage @@ -219379,8 +206086,6 @@ self: { testHaskellDepends = [ aeson base-prelude hspec record ]; description = "Instances of \"aeson\" classes for the \"record\" types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "record-dot-preprocessor" = callPackage @@ -219414,8 +206119,6 @@ self: { ]; description = "Generic encoding of records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "record-gl" = callPackage @@ -219439,8 +206142,6 @@ self: { ]; description = "Utilities for working with OpenGL's GLSL shading language and Nikita Volkov's \"Record\"s"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "record-hasfield" = callPackage @@ -219472,8 +206173,6 @@ self: { doHaddock = false; description = "Compiler preprocessor introducing a syntactic extension for anonymous records"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "record-syntax" = callPackage @@ -219497,8 +206196,6 @@ self: { ]; description = "A library for parsing and processing the Haskell syntax sprinkled with anonymous records"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "record-wrangler" = callPackage @@ -219524,8 +206221,6 @@ self: { libraryHaskellDepends = [ base kinds type-functions ]; description = "A flexible record system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "records-sop" = callPackage @@ -219558,8 +206253,6 @@ self: { ]; description = "Template Haskell declarations for the records package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "recover-rtti" = callPackage @@ -219610,8 +206303,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; - broken = true; }) {}; "recursion-schemes-ext" = callPackage @@ -219631,8 +206322,6 @@ self: { ]; description = "Amateur addenda to recursion-schemes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "recursion-schemes-ix" = callPackage @@ -219678,8 +206367,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck template-haskell ]; description = "Auto-generate final encodings and their isomorphisms using Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "red-black-record" = callPackage @@ -219698,8 +206385,6 @@ self: { doHaddock = false; description = "Extensible records and variants indexed by a type-level Red-Black tree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "red-black-tree" = callPackage @@ -219753,8 +206438,6 @@ self: { ]; description = "Library for interfacing with Reddit's API"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "redesigned-carnival" = callPackage @@ -219793,8 +206476,6 @@ self: { libraryHaskellDepends = [ base bytestring network utf8-string ]; description = "A simple Redis library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "redis-io" = callPackage @@ -219862,8 +206543,6 @@ self: { libraryHaskellDepends = [ base binary bytestring redis ]; description = "Simple redis bindings for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rediscaching-haxl" = callPackage @@ -219891,8 +206570,6 @@ self: { libraryPkgconfigDepends = [ raptor2 redland ]; description = "Redland RDF library bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {raptor2 = null; redland = null;}; "redo" = callPackage @@ -219935,8 +206612,6 @@ self: { ]; description = "Simplify a set of equations by removing redundancies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reducers" = callPackage @@ -219983,8 +206658,6 @@ self: { ]; description = "Reed-Solomon Erasure Coding in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reenact" = callPackage @@ -219998,8 +206671,6 @@ self: { ]; description = "A reimplementation of the Reactive library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reexport-crypto-random" = callPackage @@ -220021,8 +206692,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Generic Mutable Ref Abstraction Layer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ref-extras" = callPackage @@ -220061,8 +206730,6 @@ self: { libraryHaskellDepends = [ base mtl stm transformers ]; description = "A type class for monads with references compatible with the mtl2 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ref-tf" = callPackage @@ -220106,8 +206773,6 @@ self: { ]; description = "Container with element counts"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reference" = callPackage @@ -220141,8 +206806,6 @@ self: { ]; description = "Selectors for reading and updating data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "refh" = callPackage @@ -220160,8 +206823,6 @@ self: { ]; description = "A command-line tool for pasting to https://www.refheap.com"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "refined" = callPackage @@ -220190,8 +206851,6 @@ self: { libraryHaskellDepends = [ base http-api-data refined text ]; description = "http-api-data instances for refined types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "refinery_0_3_0_0" = callPackage @@ -220254,8 +206913,6 @@ self: { ]; description = "Utilities for the reflection package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflection-without-remorse" = callPackage @@ -220322,8 +206979,6 @@ self: { ]; description = "Continuous animations support for reflex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-backend-socket" = callPackage @@ -220349,8 +207004,6 @@ self: { ]; description = "Reflex bindings for TCP sockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-backend-wai" = callPackage @@ -220371,8 +207024,6 @@ self: { executableHaskellDepends = [ base http-types reflex wai ]; description = "Reflex interface to `wai`"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-basic-host" = callPackage @@ -220393,8 +207044,6 @@ self: { executableHaskellDepends = [ base lens reflex witherable ]; description = "A basic Reflex host for backend work"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-dom" = callPackage @@ -220565,8 +207214,6 @@ self: { ]; description = "Routing and retractable back button for reflex-dom"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-dom-svg" = callPackage @@ -220582,8 +207229,6 @@ self: { ]; description = "Reflex functions for SVG elements"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-dynamic-containers" = callPackage @@ -220606,8 +207251,6 @@ self: { ]; description = "various dynamic containers for Reflex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-external-ref" = callPackage @@ -220634,8 +207277,6 @@ self: { ]; description = "Reflex FRP interface for watching files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-gadt-api" = callPackage @@ -220660,8 +207301,6 @@ self: { ]; description = "Interact with a GADT API in your reflex-dom application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-ghci" = callPackage @@ -220689,8 +207328,6 @@ self: { ]; description = "A GHCi widget library for use in reflex applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-gi-gtk" = callPackage @@ -220716,8 +207353,6 @@ self: { ]; description = "Helper functions to use reflex with gi-gtk"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-gloss" = callPackage @@ -220733,8 +207368,6 @@ self: { ]; description = "An reflex interface for gloss"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-gloss-scene" = callPackage @@ -220762,8 +207395,6 @@ self: { ]; description = "A simple scene-graph using reflex and gloss"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-jsx" = callPackage @@ -220797,8 +207428,6 @@ self: { ]; description = "Reflex bindings for libtelnet"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-localize" = callPackage @@ -220814,8 +207443,6 @@ self: { ]; description = "Localization library for reflex"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-localize-dom" = callPackage @@ -220833,8 +207460,6 @@ self: { ]; description = "Helper widgets for reflex-localize"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-monad-auth" = callPackage @@ -220866,8 +207491,6 @@ self: { ]; description = "Useful missing instances for Reflex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-process" = callPackage @@ -220893,8 +207516,6 @@ self: { ]; description = "Reflex FRP interface for running system processes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-sdl2" = callPackage @@ -220914,8 +207535,6 @@ self: { executableHaskellDepends = [ base mtl reflex ]; description = "SDL2 and reflex FRP"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-test-host" = callPackage @@ -220951,8 +207570,6 @@ self: { ]; description = "Collections and switchable Monad transformers for Reflex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reflex-vty" = callPackage @@ -220979,8 +207596,6 @@ self: { ]; description = "Reflex FRP host and widgets for VTY applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reform" = callPackage @@ -221066,8 +207681,6 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "The parser and render to parsec and render the string"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "refractor" = callPackage @@ -221091,8 +207704,6 @@ self: { ]; description = "See README for more info"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "refresht" = callPackage @@ -221108,8 +207719,6 @@ self: { libraryHaskellDepends = [ base data-default exceptions lens mtl ]; description = "Environment Monad with automatic resource refreshment"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "refty" = callPackage @@ -221152,8 +207761,6 @@ self: { ]; description = "Tools for maintaining a database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reg-alloc" = callPackage @@ -221167,8 +207774,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Register allocation API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reg-alloc-graph-color" = callPackage @@ -221192,8 +207797,6 @@ self: { doHaddock = false; description = "Register allocation by graph colorization"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reg-alloc-types" = callPackage @@ -221312,8 +207915,6 @@ self: { ]; description = "Replaces/Enhances Text.Regex. Implementing regular expression matching using Brzozowski's Deriviatives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-dfa" = callPackage @@ -221327,8 +207928,6 @@ self: { libraryHaskellDepends = [ base mtl parsec regex-base ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-do" = callPackage @@ -221417,8 +208016,6 @@ self: { ]; description = "Generate a random string from a PCRE"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-genex" = callPackage @@ -221451,8 +208048,6 @@ self: { libraryHaskellDepends = [ base parsec regex-base ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-pcre" = callPackage @@ -221502,8 +208097,6 @@ self: { ]; description = "Text-based PCRE API for regex-base"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-pderiv" = callPackage @@ -221520,8 +208113,6 @@ self: { ]; description = "Replaces/Enhances Text.Regex. Implementing regular expression matching using Antimirov's partial derivatives."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-posix" = callPackage @@ -221566,8 +208157,6 @@ self: { ]; description = "Unit tests for the plaform's Posix regex library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-tdfa" = callPackage @@ -221604,8 +208193,6 @@ self: { ]; description = "Parse with regular expressions on Producers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-tdfa-quasiquoter" = callPackage @@ -221617,8 +208204,6 @@ self: { libraryHaskellDepends = [ base regex-tdfa template-haskell ]; description = "Quasi-quoter for TDFA (extended POSIX) regular expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-tdfa-rc" = callPackage @@ -221636,8 +208221,6 @@ self: { ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-tdfa-text" = callPackage @@ -221651,8 +208234,6 @@ self: { libraryHaskellDepends = [ array base regex-base regex-tdfa text ]; description = "Text interface for regex-tdfa"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-tdfa-unittest" = callPackage @@ -221671,8 +208252,6 @@ self: { ]; description = "Unit tests for the regex-tdfa"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-tdfa-utf8" = callPackage @@ -221690,8 +208269,6 @@ self: { ]; description = "This combines regex-tdfa with utf8-string to allow searching over UTF8 encoded lazy bytestrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-tre" = callPackage @@ -221706,8 +208283,6 @@ self: { librarySystemDepends = [ tre ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) tre;}; "regex-type" = callPackage @@ -221719,8 +208294,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Type-level regular expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-with-pcre" = callPackage @@ -221757,8 +208330,6 @@ self: { ]; description = "Types that can only be constructed if they match a regular expression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regex-xmlschema" = callPackage @@ -221770,8 +208341,6 @@ self: { libraryHaskellDepends = [ base haskell98 parsec ]; description = "A regular expression library for W3C XML Schema regular expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regexchar" = callPackage @@ -221827,8 +208396,6 @@ self: { ]; description = "Regular Expressions on Tries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regexpr" = callPackage @@ -221852,8 +208419,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Regular expressions via symbolic manipulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regexqq" = callPackage @@ -221867,8 +208432,6 @@ self: { ]; description = "A quasiquoter for PCRE regexes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regional-pointers" = callPackage @@ -221883,8 +208446,6 @@ self: { ]; description = "Regional memory pointers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regions" = callPackage @@ -221900,8 +208461,6 @@ self: { ]; description = "Provides the region monad for safely opening and working with scarce resources"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regions-monadsfd" = callPackage @@ -221917,8 +208476,6 @@ self: { ]; description = "Monads-fd instances for the RegionT monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regions-monadstf" = callPackage @@ -221934,8 +208491,6 @@ self: { ]; description = "Monads-tf instances for the RegionT monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regions-mtl" = callPackage @@ -221947,8 +208502,6 @@ self: { libraryHaskellDepends = [ base-unicode-symbols mtl regions ]; description = "mtl instances for the RegionT monad transformer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "register-machine-typelevel" = callPackage @@ -221960,8 +208513,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A computationally universal register machine implementation at the type-level"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "registry" = callPackage @@ -221989,8 +208540,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "data structure for assembling components"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "registry-hedgehog" = callPackage @@ -222016,8 +208565,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "utilities to work with Hedgehog generators and `registry`"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regress" = callPackage @@ -222029,8 +208576,6 @@ self: { libraryHaskellDepends = [ ad base vector ]; description = "Linear and logistic regression through automatic differentiation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regression-simple" = callPackage @@ -222042,8 +208587,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Simple linear and quadratic regression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regular" = callPackage @@ -222057,8 +208600,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Generic programming library for regular datatypes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regular-extras" = callPackage @@ -222070,8 +208611,6 @@ self: { libraryHaskellDepends = [ base binary deepseq QuickCheck regular ]; description = "Additional functions for regular: arbitrary, coarbitrary, and binary get/put"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regular-web" = callPackage @@ -222087,8 +208626,6 @@ self: { ]; description = "Generic programming for the web"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "regular-xmlpickler" = callPackage @@ -222100,8 +208637,6 @@ self: { libraryHaskellDepends = [ base hxt regular text ]; description = "Generic generation of HXT XmlPickler instances using Regular"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reheat" = callPackage @@ -222116,8 +208651,6 @@ self: { testHaskellDepends = [ base directory QuickCheck text vty vty-ui ]; description = "to make notes and reduce impact on idle time on writing other programms"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rehoo" = callPackage @@ -222135,8 +208668,6 @@ self: { ]; description = "Rebuild default.hoo from many .hoo files in the current directory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rei" = callPackage @@ -222154,8 +208685,6 @@ self: { ]; description = "Process lists easily"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reified-records" = callPackage @@ -222167,8 +208696,6 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Reify records to Maps and back again"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reify" = callPackage @@ -222184,8 +208711,6 @@ self: { executableHaskellDepends = [ base ghc ]; description = "Serialize data"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reinterpret-cast" = callPackage @@ -222212,8 +208737,6 @@ self: { libraryHaskellDepends = [ array base containers ]; description = "A relation data structure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "relapse" = callPackage @@ -222232,8 +208755,6 @@ self: { ]; description = "Sensible RLP encoding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "relation" = callPackage @@ -222271,8 +208792,6 @@ self: { ]; description = "PostgreSQL v8.x driver for haskell-relational-record"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "relational-query" = callPackage @@ -222347,8 +208866,6 @@ self: { ]; description = "The connector of relational-record and postgresql-pure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "relational-record" = callPackage @@ -222419,8 +208936,6 @@ self: { ]; description = "Durations and generalized time parsing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "releaser" = callPackage @@ -222451,8 +208966,6 @@ self: { libraryHaskellDepends = [ aeson base chronos text torsor ]; description = "humanised relevant time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reliable-io" = callPackage @@ -222512,8 +209025,6 @@ self: { ]; description = "A web based Haskell IDE"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "relude" = callPackage @@ -222576,8 +209087,6 @@ self: { ]; description = "A DSL for marking student work"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "remarks" = callPackage @@ -222599,8 +209108,6 @@ self: { ]; description = "A DSL for marking student work"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rematch" = callPackage @@ -222642,8 +209149,6 @@ self: { ]; description = "Cloud Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "remote-debugger" = callPackage @@ -222659,8 +209164,6 @@ self: { ]; description = "Interface to ghci debugger"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "remote-json" = callPackage @@ -222685,8 +209188,6 @@ self: { ]; description = "Remote Monad implementation of the JSON RPC protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "remote-json-client" = callPackage @@ -222704,8 +209205,6 @@ self: { ]; description = "Web client wrapper for remote-json"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "remote-json-server" = callPackage @@ -222723,8 +209222,6 @@ self: { ]; description = "Web server wrapper for remote-json"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "remote-monad" = callPackage @@ -222747,8 +209244,6 @@ self: { ]; description = "An parametrizable Remote Monad, and parametrizable Applicative Functor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "remotion" = callPackage @@ -222781,8 +209276,6 @@ self: { ]; description = "A library for client-server applications based on custom protocols"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "render-utf8" = callPackage @@ -222798,8 +209291,6 @@ self: { ]; description = "Simple Utf8 wrapper for ByteString Builder with conversion classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "renderable" = callPackage @@ -222835,8 +209326,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Reorder expressions in a syntax tree according to operator fixities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reorderable" = callPackage @@ -222883,8 +209372,6 @@ self: { libraryHaskellDepends = [ base repa vector ]; description = "Algorithms using the Repa array library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-array" = callPackage @@ -222902,8 +209389,6 @@ self: { ]; description = "Bulk array representations and operators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-bytestring" = callPackage @@ -222916,8 +209401,6 @@ self: { doHaddock = false; description = "(deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-convert" = callPackage @@ -222933,8 +209416,6 @@ self: { ]; description = "Packing and unpacking flat tables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-devil" = callPackage @@ -222947,8 +209428,6 @@ self: { librarySystemDepends = [ libdevil ]; description = "Support for image reading and writing of Repa arrays using in-place FFI calls"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libdevil;}; "repa-eval" = callPackage @@ -222960,8 +209439,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Low-level parallel operators on bulk random-accessble arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-examples" = callPackage @@ -222982,8 +209459,6 @@ self: { ]; description = "Examples using the Repa array library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-fftw" = callPackage @@ -223022,8 +209497,6 @@ self: { ]; description = "Data-parallel data flows"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-io" = callPackage @@ -223052,8 +209525,6 @@ self: { libraryHaskellDepends = [ base hmatrix repa vector ]; description = "HMatrix operations for Repa"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-plugin" = callPackage @@ -223070,8 +209541,6 @@ self: { ]; description = "Data Flow Fusion GHC Plugin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-scalar" = callPackage @@ -223089,8 +209558,6 @@ self: { ]; description = "Scalar data types and conversions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-series" = callPackage @@ -223102,8 +209569,6 @@ self: { libraryHaskellDepends = [ base ghc ghc-prim vector ]; description = "Series Expressionss API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-sndfile" = callPackage @@ -223133,8 +209598,6 @@ self: { libraryHaskellDepends = [ base mtl primitive repa-scalar vector ]; description = "Stream functions not present in the vector library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repa-v4l2" = callPackage @@ -223154,8 +209617,6 @@ self: { executableHaskellDepends = [ base gloss repa ]; description = "Provides high-level access to webcams"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repl" = callPackage @@ -223169,8 +209630,6 @@ self: { ]; description = "IRC friendly REPL library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repl-toolkit" = callPackage @@ -223241,8 +209700,6 @@ self: { wai-websockets websockets ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "replicant" = callPackage @@ -223269,8 +209726,6 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repline" = callPackage @@ -223315,8 +209770,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Blogging module using blaze html for markup"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repr" = callPackage @@ -223332,8 +209785,6 @@ self: { ]; description = "Render overloaded expressions to their textual representation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "repr-tree-syb" = callPackage @@ -223363,8 +209814,6 @@ self: { ]; description = "Representable functors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "representable-profunctors" = callPackage @@ -223395,8 +209844,6 @@ self: { ]; description = "Tries from representations of polynomial functors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reprinter" = callPackage @@ -223414,8 +209861,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Scrap Your Reprinter"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reproject" = callPackage @@ -223428,8 +209873,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Define and combine \"materialized\" projections"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "req" = callPackage @@ -223485,8 +209928,6 @@ self: { ]; description = "Conduit helpers for the req HTTP client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "req-oauth2" = callPackage @@ -223509,8 +209950,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Provides OAuth2 authentication for use with Req"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "req-url-extra" = callPackage @@ -223526,8 +209965,6 @@ self: { testHaskellDepends = [ base hspec modern-uri req ]; description = "Provides URI/URL helper functions for use with Req"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reqcatcher" = callPackage @@ -223544,8 +209981,6 @@ self: { ]; description = "A local http server to catch the HTTP redirect"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "request" = callPackage @@ -223572,8 +210007,6 @@ self: { libraryHaskellDepends = [ base free mtl transformers ]; description = "A transformer for generic requests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "require" = callPackage @@ -223640,8 +210073,6 @@ self: { ]; description = "Regular-expressions extended with fixpoints for context-free powers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rerebase" = callPackage @@ -223720,8 +210151,6 @@ self: { ]; description = "More understandable exceptions"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reserve" = callPackage @@ -223745,8 +210174,6 @@ self: { ]; description = "Reserve reloads web applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reservoir" = callPackage @@ -223758,8 +210185,6 @@ self: { libraryHaskellDepends = [ base containers random ]; description = "Unweighted reservoir sampling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resin" = callPackage @@ -223771,8 +210196,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ralist semigroupoids ]; description = "High performance variable binders"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resistor-cube" = callPackage @@ -223786,8 +210209,6 @@ self: { executableHaskellDepends = [ base comfort-array lapack ]; description = "Compute total resistance of a cube of resistors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resolv_0_1_1_2" = callPackage @@ -223844,8 +210265,6 @@ self: { ]; description = "A name resolusion library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resolve-trivial-conflicts" = callPackage @@ -223864,8 +210283,6 @@ self: { ]; description = "Remove trivial conflict markers in a git repository"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resource-effect" = callPackage @@ -223884,8 +210301,6 @@ self: { ]; description = "A port of the package 'resourcet' for extensible effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resource-embed" = callPackage @@ -223899,8 +210314,6 @@ self: { executableHaskellDepends = [ base bytestring directory ]; description = "Embed data files via C and FFI"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resource-pool" = callPackage @@ -223933,8 +210346,6 @@ self: { ]; description = "Fork of resource-pool, with a MonadCatchIO constraint"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resource-pool-monad" = callPackage @@ -223966,8 +210377,6 @@ self: { ]; description = "Allocate resources which are guaranteed to be released"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "resourcet" = callPackage @@ -224023,8 +210432,6 @@ self: { ]; description = "process and route HTTP requests and generate responses on top of WAI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-client" = callPackage @@ -224046,8 +210453,6 @@ self: { ]; description = "Utility library for use in generated API client libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-core" = callPackage @@ -224075,8 +210480,6 @@ self: { ]; description = "Rest API library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-example" = callPackage @@ -224099,8 +210502,6 @@ self: { executableHaskellDepends = [ base base-compat rest-gen ]; description = "Example project for rest"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-gen" = callPackage @@ -224128,8 +210529,6 @@ self: { ]; description = "Documentation and client generation from rest definition"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-happstack" = callPackage @@ -224147,8 +210546,6 @@ self: { ]; description = "Rest driver for Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-snap" = callPackage @@ -224166,8 +210563,6 @@ self: { ]; description = "Rest driver for Snap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-stringmap" = callPackage @@ -224184,8 +210579,6 @@ self: { ]; description = "Maps with stringy keys that can be transcoded to JSON and XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-types" = callPackage @@ -224205,8 +210598,6 @@ self: { ]; description = "Silk Rest Framework Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rest-wai" = callPackage @@ -224226,8 +210617,6 @@ self: { ]; description = "Rest driver for WAI applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "restartable" = callPackage @@ -224239,8 +210628,6 @@ self: { libraryHaskellDepends = [ aeson base bytestring unix ]; description = "Minimal live coding library for model-view-event-update applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "restful-snap" = callPackage @@ -224260,8 +210647,6 @@ self: { time-locale-compat xmlhtml ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "restless-git" = callPackage @@ -224298,8 +210683,6 @@ self: { ]; description = "Running worker processes under system resource restrictions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "restyle" = callPackage @@ -224314,8 +210697,6 @@ self: { executableHaskellDepends = [ base directory filepath utf8-string ]; description = "Convert between camel case and separated words style"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "result" = callPackage @@ -224363,8 +210744,6 @@ self: { benchmarkHaskellDepends = [ aeson async base criterion text ]; description = "A driver for RethinkDB 2.2"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rethinkdb-client-driver" = callPackage @@ -224393,8 +210772,6 @@ self: { ]; description = "Client driver for RethinkDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rethinkdb-model" = callPackage @@ -224410,8 +210787,6 @@ self: { ]; description = "Useful tools for modeling data with rethinkdb"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rethinkdb-wereHamster" = callPackage @@ -224431,8 +210806,6 @@ self: { ]; description = "RethinkDB driver for Haskell"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "retrie" = callPackage @@ -224494,8 +210867,6 @@ self: { executableHaskellDepends = [ base optparse-applicative process ]; description = "Retry failed commands"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rev-state" = callPackage @@ -224560,8 +210931,6 @@ self: { ]; description = "Simple reverse geocoding using OpenStreeMap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "reversi" = callPackage @@ -224575,8 +210944,6 @@ self: { executableHaskellDepends = [ array base process ]; description = "Text-only reversi (aka othelo) game"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rewrite" = callPackage @@ -224592,8 +210959,6 @@ self: { ]; description = "open file and rewrite it with new contents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rewrite-inspector" = callPackage @@ -224613,8 +210978,6 @@ self: { executableHaskellDepends = [ base prettyprinter ]; description = "Inspection of rewriting steps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rewriting" = callPackage @@ -224626,8 +210989,6 @@ self: { libraryHaskellDepends = [ base containers regular ]; description = "Generic rewriting library for regular datatypes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rex" = callPackage @@ -224663,8 +211024,6 @@ self: { ]; description = "Github resume generator"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc" = callPackage @@ -224698,8 +211057,6 @@ self: { ]; description = "Robert Fischer's Common library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc-env" = callPackage @@ -224711,8 +211068,6 @@ self: { libraryHaskellDepends = [ base envy network rfc-prelude time ]; description = "Environment variable support from the Robert Fischer Commons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc-http-client" = callPackage @@ -224730,8 +211085,6 @@ self: { ]; description = "The HTTP client extensions from the Robert Fischer Commons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc-prelude" = callPackage @@ -224755,8 +211108,6 @@ self: { ]; description = "The Prelude from the Robert Fischer Commons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc-psql" = callPackage @@ -224773,8 +211124,6 @@ self: { ]; description = "The PostgreSQL extensions from the Robert Fischer Commons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc-redis" = callPackage @@ -224786,8 +211135,6 @@ self: { libraryHaskellDepends = [ base hedis rfc-env rfc-prelude time ]; description = "The Redis extensions from the Robert Fischer Commons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc-servant" = callPackage @@ -224809,8 +211156,6 @@ self: { ]; description = "The Servant extensions from the Robert Fischer Commons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rfc1413-server" = callPackage @@ -224894,8 +211239,6 @@ self: { ]; description = "A dynamic/unbounded alternative to Bounded Enum"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rgb-color-model" = callPackage @@ -224927,8 +211270,6 @@ self: { testHaskellDepends = [ base simple-cmd ]; description = "Bugzilla query tool"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rhine" = callPackage @@ -224980,8 +211321,6 @@ self: { ]; description = "Haskell rhythm game tutorial"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "riak" = callPackage @@ -225083,8 +211422,6 @@ self: { ]; description = "Static site generator based on Shake"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rib-core" = callPackage @@ -225117,8 +211454,6 @@ self: { libraryHaskellDepends = [ base Only postgresql-simple text time ]; description = "Type-level Relational DB combinators"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ribosome" = callPackage @@ -225246,8 +211581,6 @@ self: { ]; description = "Quick metrics to grow your app strong"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ridley-extras" = callPackage @@ -225265,8 +211598,6 @@ self: { testHaskellDepends = [ base ]; description = "Handy metrics that don't belong to ridley"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "riemann" = callPackage @@ -225296,8 +211627,6 @@ self: { ]; description = "A Riemann client for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "riff" = callPackage @@ -225316,8 +211645,6 @@ self: { executableHaskellDepends = [ base bytestring filepath ]; description = "RIFF parser for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rigel-viz" = callPackage @@ -225348,8 +211675,6 @@ self: { testHaskellDepends = [ base HUnit QuickCheck vector ]; description = "A concurrent, mutable ring-buffer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ring-buffers" = callPackage @@ -225366,8 +211691,6 @@ self: { testHaskellDepends = [ base HUnit primitive QuickCheck ]; description = "mutable ring buffers with atomic updates in GHC Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rings" = callPackage @@ -225480,8 +211803,6 @@ self: { ]; description = "A library for process pools coupled with asynchronous message queues"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "riot" = callPackage @@ -225501,8 +211822,6 @@ self: { executableSystemDepends = [ ncurses ]; description = "Riot is an Information Organisation Tool"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses;}; "ripple" = callPackage @@ -225560,8 +211879,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "RISC-V"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "risc386" = callPackage @@ -225577,8 +211894,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Reduced instruction set i386 simulator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "riscv-isa" = callPackage @@ -225593,8 +211908,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Haskell representation of the RISC-V instruction set architecture"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rison" = callPackage @@ -225626,8 +211939,6 @@ self: { libraryHaskellDepends = [ base lazysmallcheck oeis QuickCheck ]; description = "Rivers are like Streams, but different"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rivet" = callPackage @@ -225641,8 +211952,6 @@ self: { executableHaskellDepends = [ base rivet-core rivet-simple-deploy ]; description = "A project management tool for Haskell applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rivet-adaptor-postgresql" = callPackage @@ -225690,8 +211999,6 @@ self: { libraryHaskellDepends = [ base postgresql-simple text ]; description = "Postgresql migration support for project management tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rivet-simple-deploy" = callPackage @@ -225703,8 +212010,6 @@ self: { libraryHaskellDepends = [ base configurator mtl rivet-core text ]; description = "Basic deployment support for project management tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rl-satton" = callPackage @@ -225730,8 +212035,6 @@ self: { ]; description = "Collection of Reinforcement Learning algorithms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rlglue" = callPackage @@ -225754,8 +212057,6 @@ self: { ]; description = "A Haskell codec for RL-Glue"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rlist" = callPackage @@ -225791,8 +212092,6 @@ self: { executableHaskellDepends = [ ansi-terminal base options time ]; description = "Ring-LWE/LWR challenges using Lol"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rmonad" = callPackage @@ -225809,8 +212108,6 @@ self: { ]; description = "Restricted monad library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rncryptor" = callPackage @@ -225839,8 +212136,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "Haskell implementation of the RNCryptor file format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rng-utils" = callPackage @@ -225879,8 +212174,6 @@ self: { testHaskellDepends = [ base directory ]; description = "Simple projects generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "robin" = callPackage @@ -225900,8 +212193,6 @@ self: { ]; description = "A build daemon for Haskell development"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roboservant" = callPackage @@ -225956,8 +212247,6 @@ self: { ]; description = "Parser for robots.txt"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roc-cluster" = callPackage @@ -225972,8 +212261,6 @@ self: { testHaskellDepends = [ base hspec HUnit ]; description = "ROC online clustering algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roc-cluster-demo" = callPackage @@ -225991,8 +212278,6 @@ self: { ]; description = "Gloss interactive demo for roc-cluster package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roc-id" = callPackage @@ -226037,8 +212322,6 @@ self: { ]; description = "A build system for incremental, parallel, and demand-driven computations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rocksdb-haskell" = callPackage @@ -226061,8 +212344,6 @@ self: { ]; description = "Haskell bindings to RocksDB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) rocksdb;}; "rocksdb-haskell-jprupp" = callPackage @@ -226083,8 +212364,6 @@ self: { ]; description = "Haskell bindings for RocksDB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) rocksdb;}; "rocksdb-query" = callPackage @@ -226104,8 +212383,6 @@ self: { ]; description = "RocksDB database querying library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roguestar" = callPackage @@ -226192,8 +212469,6 @@ self: { ]; description = "Bindings to Roku's External Control API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roles" = callPackage @@ -226221,8 +212496,6 @@ self: { ]; description = "error tracking through rollbar.com"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rollbar-cli" = callPackage @@ -226240,8 +212513,6 @@ self: { testHaskellDepends = [ base ]; description = "Simple CLI tool to perform commons tasks such as tracking deploys"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rollbar-client" = callPackage @@ -226265,8 +212536,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Core library to communicate with Rollbar API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rollbar-hs" = callPackage @@ -226289,8 +212558,6 @@ self: { ]; description = "Core Rollbar data types and APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rollbar-wai" = callPackage @@ -226315,8 +212582,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Provides error reporting capabilities to WAI based applications through Rollbar API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rollbar-yesod" = callPackage @@ -226338,8 +212603,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Provides error reporting capabilities to Yesod applications through Rollbar API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roller" = callPackage @@ -226360,8 +212623,6 @@ self: { ]; description = "Playing with applicatives and dice!"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rolling-queue" = callPackage @@ -226438,8 +212699,6 @@ self: { ]; description = "Replicated Data Types (RON-RDT)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ron-schema" = callPackage @@ -226457,8 +212716,6 @@ self: { ]; description = "RON-Schema"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ron-storage" = callPackage @@ -226476,8 +212733,6 @@ self: { ]; description = "RON Storage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roots" = callPackage @@ -226502,8 +212757,6 @@ self: { ]; description = "Tools for manipulating fingertrees of bytestrings with optional annotations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rope-utf16-splay" = callPackage @@ -226582,8 +212835,6 @@ self: { ]; description = "Various trie implementations in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rose-trie" = callPackage @@ -226599,8 +212850,6 @@ self: { ]; description = "Trees with polymorphic paths to nodes, combining properties of Rose Trees and Tries"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rosebud" = callPackage @@ -226616,8 +212865,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Common rose tree/forest functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rosezipper" = callPackage @@ -226661,8 +212908,6 @@ self: { ]; description = "Haskell support for the ROS robotics framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rosmsg" = callPackage @@ -226680,8 +212925,6 @@ self: { ]; description = "ROS message parser, render, TH"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rosmsg-bin" = callPackage @@ -226699,8 +212942,6 @@ self: { ]; description = "ROS message management tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rospkg" = callPackage @@ -226732,8 +212973,6 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "General purpose utility library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rot13" = callPackage @@ -226765,8 +213004,6 @@ self: { ]; description = "Size-limited, concurrent, automatically-rotating log writer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roundRobin" = callPackage @@ -226801,8 +213038,6 @@ self: { testHaskellDepends = [ base long-double ]; description = "Correctly-rounded arbitrary-precision floating-point arithmetic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gmp; inherit (pkgs) mpfr;}; "rounded-hw" = callPackage @@ -226827,8 +213062,6 @@ self: { ]; description = "Directed rounding for built-in floating types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rounding" = callPackage @@ -226840,8 +213073,6 @@ self: { libraryHaskellDepends = [ array base numeric-extras ]; description = "Explicit floating point rounding mode wrappers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roundtrip" = callPackage @@ -226877,8 +213108,6 @@ self: { ]; description = "Un-/parse JSON with roundtrip invertible syntax definitions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "roundtrip-string" = callPackage @@ -226911,8 +213140,6 @@ self: { ]; description = "Bidirectional (de-)serialization for XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "route-generator" = callPackage @@ -226947,8 +213174,6 @@ self: { ]; description = "A library and utilities for creating a route"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "row" = callPackage @@ -227018,8 +213243,6 @@ self: { libraryHaskellDepends = [ base containers template-haskell ]; description = "Build records from lists of strings, as from CSV files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rpc" = callPackage @@ -227036,8 +213259,6 @@ self: { ]; description = "type safe rpcs provided as basic IO actions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rpc-framework" = callPackage @@ -227056,8 +213277,6 @@ self: { executableHaskellDepends = [ base ]; description = "a remote procedure call framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rpf" = callPackage @@ -227077,8 +213296,6 @@ self: { ]; description = "Receiver Policy Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rpm" = callPackage @@ -227092,8 +213309,6 @@ self: { libraryHaskellDepends = [ base directory filepath HaXml process ]; description = "Cozy little project to question unruly rpm packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rpmbuild-order" = callPackage @@ -227117,8 +213332,6 @@ self: { testHaskellDepends = [ base extra hspec simple-cmd unix ]; description = "Order RPM packages by dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rrule" = callPackage @@ -227135,8 +213348,6 @@ self: { testHaskellDepends = [ base hspec text ]; description = "Recurrence rule parser and formatter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rsagl" = callPackage @@ -227156,8 +213367,6 @@ self: { ]; description = "The RogueStar Animation and Graphics Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rsagl-frp" = callPackage @@ -227173,8 +213382,6 @@ self: { ]; description = "The RogueStar Animation and Graphics Library: Functional Reactive Programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rsagl-math" = callPackage @@ -227191,8 +213398,6 @@ self: { ]; description = "The RogueStar Animation and Graphics Library: Mathematics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rset" = callPackage @@ -227217,8 +213422,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A Rational Street Performer Protocol solver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rss" = callPackage @@ -227232,8 +213435,6 @@ self: { libraryHaskellDepends = [ base HaXml network network-uri time ]; description = "A library for generating RSS 2.0 feeds."; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rss-conduit" = callPackage @@ -227264,8 +213465,6 @@ self: { ]; description = "Streaming parser/renderer for the RSS standard"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rss2irc" = callPackage @@ -227289,8 +213488,6 @@ self: { ]; description = "watches an RSS/Atom feed and writes it to an IRC channel"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rstream" = callPackage @@ -227302,8 +213499,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "stream-fusion framework from vector"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rtcm" = callPackage @@ -227332,8 +213527,6 @@ self: { ]; description = "Haskell bindings for RTCM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rtld" = callPackage @@ -227384,8 +213577,6 @@ self: { ]; description = "Manipulate network devices, addresses, and routes on Linux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rtorrent-rpc" = callPackage @@ -227402,8 +213593,6 @@ self: { ]; description = "A library for communicating with RTorrent over its XML-RPC interface"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rtorrent-state" = callPackage @@ -227443,8 +213632,6 @@ self: { executableHaskellDepends = [ base Cabal process ]; description = "Dynamically load Haskell libraries"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rubberband" = callPackage @@ -227483,8 +213670,6 @@ self: { ]; description = "Parse a subset of Ruby objects serialised with Marshal.dump."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ruby-qq" = callPackage @@ -227501,8 +213686,6 @@ self: { ]; description = "rubyish quasiquoters"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ruff" = callPackage @@ -227514,8 +213697,6 @@ self: { libraryHaskellDepends = [ array base mtl parsec safe strict Vec ]; description = "relatively useful fractal functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ruin" = callPackage @@ -227537,8 +213718,6 @@ self: { ]; description = "Pliable records"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ruler" = callPackage @@ -227557,8 +213736,6 @@ self: { ]; description = "Ruler tool for UHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ruler-core" = callPackage @@ -227576,8 +213753,6 @@ self: { uulib ]; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "run-haskell-module" = callPackage @@ -227600,8 +213775,6 @@ self: { libraryHaskellDepends = [ base primitive primitive-unlifted ]; description = "runST without boxing penalty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rungekutta" = callPackage @@ -227613,8 +213786,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A collection of explicit Runge-Kutta methods of various orders"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "runghc" = callPackage @@ -227651,8 +213822,6 @@ self: { testHaskellDepends = [ base directory hspec process ]; description = "Stack wrapper for single-file Haskell programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "runmany" = callPackage @@ -227670,8 +213839,6 @@ self: { ]; description = "Run multiple commands, interleaving output and errors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "runmemo" = callPackage @@ -227694,8 +213861,6 @@ self: { libraryHaskellDepends = [ base ifcxt QuickCheck template-haskell ]; description = "Runtime generation of Arbitrary values"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rv" = callPackage @@ -227713,8 +213878,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "RISC-V"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rvar" = callPackage @@ -227761,8 +213924,6 @@ self: { ]; description = "Packet Generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "rz-pipe" = callPackage @@ -227822,8 +213983,6 @@ self: { executableHaskellDepends = [ base ]; description = "simple general-purpose s-expressions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "s3-signer" = callPackage @@ -227883,8 +214042,6 @@ self: { ]; description = "A monadic buffer resilient to exceptions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-coerce" = callPackage @@ -227896,8 +214053,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A friendly shorthand for an old friend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-coloured-text" = callPackage @@ -228006,8 +214161,6 @@ self: { libraryHaskellDepends = [ base indexed mtl vector ]; description = "Support for safely freezing multiple arrays in the ST monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-globals" = callPackage @@ -228019,8 +214172,6 @@ self: { libraryHaskellDepends = [ base stm template-haskell ]; description = "Safe top-level mutable variables which scope like ordinary values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-json" = callPackage @@ -228059,8 +214210,6 @@ self: { ]; description = "A library providing safe lazy IO features"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-length" = callPackage @@ -228078,8 +214227,6 @@ self: { ]; description = "Tired of accidentally calling length on tuples? Relief at last!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-money" = callPackage @@ -228198,8 +214345,6 @@ self: { testHaskellDepends = [ base containers doctest ]; description = "Safe arithmetic operations"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-plugins" = callPackage @@ -228215,8 +214360,6 @@ self: { ]; description = "A small wrapper over hs-plugins to allow loading safe plugins"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-printf" = callPackage @@ -228236,8 +214379,6 @@ self: { ]; description = "Well-typed, flexible and variadic printf for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safe-tensor" = callPackage @@ -228293,8 +214434,6 @@ self: { ]; description = "Making SafeCopy migrations easier"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safecopy-store" = callPackage @@ -228318,8 +214457,6 @@ self: { ]; description = "Binary serialization with version control"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safeint" = callPackage @@ -228337,8 +214474,6 @@ self: { ]; description = "overflow-checked Int type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safeio" = callPackage @@ -228373,8 +214508,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Safe Paths in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safer-file-handles" = callPackage @@ -228391,8 +214524,6 @@ self: { ]; description = "Type-safe file handling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safer-file-handles-bytestring" = callPackage @@ -228409,8 +214540,6 @@ self: { ]; description = "Extends safer-file-handles with ByteString operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "safer-file-handles-text" = callPackage @@ -228426,8 +214555,6 @@ self: { ]; description = "Extends safer-file-handles with Text operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "saferoute" = callPackage @@ -228439,8 +214566,6 @@ self: { libraryHaskellDepends = [ base blaze-html containers text ]; description = "A simple type-safe routing library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sai-shape-syb" = callPackage @@ -228456,8 +214581,6 @@ self: { ]; description = "Obtain homogeneous values from arbitrary values, transforming or culling data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sajson" = callPackage @@ -228480,8 +214603,6 @@ self: { ]; description = "Fast JSON parsing powered by Chad Austin's sajson library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sak" = callPackage @@ -228503,8 +214624,6 @@ self: { executableToolDepends = [ cpphs ]; description = "Compression command-line tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sakuraio-platform" = callPackage @@ -228576,8 +214695,6 @@ self: { ]; description = "Configuration Loader for toml"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "salak-yaml" = callPackage @@ -228637,8 +214754,6 @@ self: { ]; description = "Quickcheck implementations for some NaCl data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libsodium;}; "salve" = callPackage @@ -228671,8 +214786,6 @@ self: { ]; description = "Modular web application framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "salvia-demo" = callPackage @@ -228695,8 +214808,6 @@ self: { doHaddock = false; description = "Demo Salvia servers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "salvia-extras" = callPackage @@ -228717,8 +214828,6 @@ self: { ]; description = "Collection of non-fundamental handlers for the Salvia web server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "salvia-protocol" = callPackage @@ -228735,8 +214844,6 @@ self: { ]; description = "Salvia webserver protocol suite supporting URI, HTTP, Cookie and MIME"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "salvia-sessions" = callPackage @@ -228754,8 +214861,6 @@ self: { ]; description = "Session support for the Salvia webserver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "salvia-websocket" = callPackage @@ -228772,8 +214877,6 @@ self: { ]; description = "Websocket implementation for the Salvia Webserver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sample-frame" = callPackage @@ -228830,8 +214933,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Binding to the C samtools library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zlib;}; "samtools-conduit" = callPackage @@ -228852,8 +214953,6 @@ self: { ]; description = "Conduit interface to SAM/BAM format files through samtools"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "samtools-enumerator" = callPackage @@ -228869,8 +214968,6 @@ self: { ]; description = "Enumerator interface to SamTools library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "samtools-iteratee" = callPackage @@ -228887,8 +214984,6 @@ self: { ]; description = "Iteratee interface to SamTools library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sandi" = callPackage @@ -228919,8 +215014,6 @@ self: { libraryHaskellDepends = [ base ]; description = "SAND data serialization and manipulation library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sandman" = callPackage @@ -228939,8 +215032,6 @@ self: { ]; description = "Manages Cabal sandboxes to avoid rebuilding packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sandwich" = callPackage @@ -229088,8 +215179,6 @@ self: { libraryHaskellDepends = [ base deepseq portaudio ]; description = "audio library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sarsi" = callPackage @@ -229118,8 +215207,6 @@ self: { ]; description = "A universal quickfix toolkit and his protocol"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sasl" = callPackage @@ -229136,8 +215223,6 @@ self: { ]; description = "SASL implementation using simple-pipe"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sat" = callPackage @@ -229151,8 +215236,6 @@ self: { executableHaskellDepends = [ base ]; description = "CNF SATisfier"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sat-micro-hs" = callPackage @@ -229170,8 +215253,6 @@ self: { ]; description = "A minimal SAT solver"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "satchmo" = callPackage @@ -229190,8 +215271,6 @@ self: { testHaskellDepends = [ array base ]; description = "SAT encoding monad"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "satchmo-backends" = callPackage @@ -229207,8 +215286,6 @@ self: { ]; description = "driver for external satchmo backends"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "satchmo-examples" = callPackage @@ -229226,8 +215303,6 @@ self: { ]; description = "examples that show how to use satchmo"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "satchmo-funsat" = callPackage @@ -229243,8 +215318,6 @@ self: { ]; description = "funsat driver as backend for satchmo"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "satchmo-minisat" = callPackage @@ -229256,8 +215329,6 @@ self: { libraryHaskellDepends = [ base containers process satchmo ]; description = "minisat driver as backend for satchmo"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "satchmo-toysat" = callPackage @@ -229273,8 +215344,6 @@ self: { ]; description = "toysat driver as backend for satchmo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "savage" = callPackage @@ -229293,8 +215362,6 @@ self: { ]; description = "re-export of the random generators from Hedgehog"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sax" = callPackage @@ -229313,8 +215380,6 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Monadic streaming XML parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "say" = callPackage @@ -229476,8 +215541,6 @@ self: { ]; description = "Formally prove properties of Haskell programs using SBV/SMT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sc2-lowlevel" = callPackage @@ -229497,8 +215560,6 @@ self: { ]; description = "Low-level Starcraft II API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sc2-proto" = callPackage @@ -229518,8 +215579,6 @@ self: { libraryToolDepends = [ proto-lens-protoc protoc ]; description = "A protocol buffer model for the Starcraft II bot API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {protoc = null;}; "sc2-support" = callPackage @@ -229536,8 +215595,6 @@ self: { ]; description = "Support and utility library for sc2hs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sc2hs" = callPackage @@ -229578,8 +215635,6 @@ self: { libraryHaskellDepends = [ base hsc3 hsc3-db ]; description = "Haskell bindings to sc3-rdu (sc3 rd ugens)"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scalable-server" = callPackage @@ -229597,8 +215652,6 @@ self: { ]; description = "Library for writing fast/scalable TCP-based services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scaleimage" = callPackage @@ -229612,8 +215665,6 @@ self: { executableHaskellDepends = [ base filepath gd ]; description = "Scale an image to a new geometry"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scalendar" = callPackage @@ -229630,8 +215681,6 @@ self: { ]; description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scalp-webhooks" = callPackage @@ -229658,8 +215707,6 @@ self: { ]; description = "Test webhooks locally"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scalpel" = callPackage @@ -229711,8 +215758,6 @@ self: { ]; description = "scalpel scrapers for search engines"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scan" = callPackage @@ -229745,8 +215790,6 @@ self: { ]; description = "Metadata types for Albedo Scanners"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scan-vector-machine" = callPackage @@ -229759,8 +215802,6 @@ self: { testHaskellDepends = [ array base HUnit ]; description = "An implementation of the Scan Vector Machine instruction set in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scanf" = callPackage @@ -229802,8 +215843,6 @@ self: { testHaskellDepends = [ attoparsec base bytestring hspec scanner ]; description = "Inject attoparsec parser with backtracking into non-backtracking scanner"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scat" = callPackage @@ -229859,8 +215898,6 @@ self: { ]; description = "Streaming component combinators"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scenegraph" = callPackage @@ -229878,8 +215915,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Scene Graph"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scgi" = callPackage @@ -229895,8 +215930,6 @@ self: { ]; description = "A Haskell library for writing SCGI programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "schedevr" = callPackage @@ -229914,8 +215947,6 @@ self: { ]; description = "Marge schedules and show EVR"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "schedule" = callPackage @@ -229956,8 +215987,6 @@ self: { ]; description = "Find the ideal lesson layout"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scheduler" = callPackage @@ -229989,8 +216018,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Exposes standard POSIX function sched_yield"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "schema" = callPackage @@ -230005,8 +216032,6 @@ self: { ]; description = "Encoding-independent schemas for Haskell data types"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "schemas" = callPackage @@ -230031,8 +216056,6 @@ self: { ]; description = "schema guided serialization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "schematic" = callPackage @@ -230061,8 +216084,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "JSON-biased spec and validation tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scholdoc" = callPackage @@ -230107,8 +216128,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Converts ScholarlyMarkdown documents to HTML5/LaTeX/Docx format"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scholdoc-citeproc" = callPackage @@ -230142,8 +216161,6 @@ self: { ]; description = "Scholdoc fork of pandoc-citeproc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scholdoc-texmath" = callPackage @@ -230166,8 +216183,6 @@ self: { ]; description = "Scholdoc fork of texmath"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scholdoc-types" = callPackage @@ -230183,8 +216198,6 @@ self: { ]; description = "Scholdoc fork of pandoc-types"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "schonfinkeling" = callPackage @@ -230208,8 +216221,6 @@ self: { testHaskellDepends = [ base ]; description = "Rational numbers in scientific notation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scidb-hquery" = callPackage @@ -230243,8 +216254,6 @@ self: { ]; description = "Haskell query for SciDB via shim"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "science-constants" = callPackage @@ -230318,8 +216327,6 @@ self: { ]; description = "Scientific notation intended for tokenization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scion" = callPackage @@ -230345,8 +216352,6 @@ self: { ]; description = "Haskell IDE library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scion-browser" = callPackage @@ -230381,8 +216386,6 @@ self: { ]; description = "Command-line interface for browsing and searching packages documentation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scons2dot" = callPackage @@ -230396,8 +216399,6 @@ self: { executableHaskellDepends = [ base bytestring containers process ]; description = "Generates graphviz file of scons dependency information"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scope" = callPackage @@ -230415,8 +216416,6 @@ self: { ]; description = "An interactive renderer for plotting time-series data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scope-cairo" = callPackage @@ -230440,8 +216439,6 @@ self: { ]; description = "An interactive renderer for plotting time-series data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scottish" = callPackage @@ -230459,8 +216456,6 @@ self: { ]; description = "scotty with batteries included"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty" = callPackage @@ -230512,8 +216507,6 @@ self: { ]; description = "The Play Framework style data binding in Scotty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-blaze" = callPackage @@ -230528,8 +216521,6 @@ self: { ]; description = "blaze-html integration for Scotty"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-cookie" = callPackage @@ -230570,8 +216561,6 @@ self: { ]; description = "Fay integration for Scotty"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-form" = callPackage @@ -230585,8 +216574,6 @@ self: { ]; description = "Html form validation using `ditto`"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-format" = callPackage @@ -230603,8 +216590,6 @@ self: { testHaskellDepends = [ base ]; description = "Response format helper for the Scotty web framework"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-hastache" = callPackage @@ -230621,8 +216606,6 @@ self: { ]; description = "Easy Mustache templating support for Scotty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-haxl" = callPackage @@ -230650,8 +216633,6 @@ self: { ]; description = "HTTP-request's query parameters parser abstraction for \"scotty\""; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-path-normalizer" = callPackage @@ -230679,8 +216660,6 @@ self: { ]; description = "A Better way of modeling web resources"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-rest" = callPackage @@ -230706,8 +216685,6 @@ self: { ]; description = "Webmachine-style REST library for scotty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-session" = callPackage @@ -230726,8 +216703,6 @@ self: { ]; description = "Adding session functionality to scotty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-tls" = callPackage @@ -230741,8 +216716,6 @@ self: { ]; description = "TLS for Scotty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scotty-utils" = callPackage @@ -230774,8 +216747,6 @@ self: { libraryHaskellDepends = [ base scotty text transformers ]; executableHaskellDepends = [ base scotty text transformers ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scp-streams" = callPackage @@ -230797,8 +216768,6 @@ self: { testHaskellDepends = [ base bytestring io-streams ]; description = "An SCP protocol implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scrabble-bot" = callPackage @@ -230818,8 +216787,6 @@ self: { ]; description = "Scrabble play generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scrapbook" = callPackage @@ -230843,8 +216810,6 @@ self: { ]; description = "collect posts of site that is wrote in config yaml using feed or scraping"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scrapbook-core" = callPackage @@ -230866,8 +216831,6 @@ self: { ]; description = "Core Package for scrapbook"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scrape-changes" = callPackage @@ -230894,8 +216857,6 @@ self: { ]; description = "Scrape websites for changes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "script-monad" = callPackage @@ -230922,8 +216883,6 @@ self: { ]; description = "Stack of error, reader, writer, state, and prompt monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scrobble" = callPackage @@ -230946,8 +216905,6 @@ self: { ]; description = "Scrobbling server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scroll" = callPackage @@ -231056,8 +217013,6 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Fast CSV lexing on ByteString"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "scyther-proof" = callPackage @@ -231079,8 +217034,6 @@ self: { executableToolDepends = [ alex ]; description = "Automatic generation of Isabelle/HOL correctness proofs for security protocols"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sde-solver" = callPackage @@ -231099,8 +217052,6 @@ self: { ]; description = "Distributed SDE solver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sdf2p1-parser" = callPackage @@ -231178,8 +217129,6 @@ self: { ]; description = "An image loading and rendering library for sdl2 / sdl2-cairo"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sdl2-compositor" = callPackage @@ -231203,8 +217152,6 @@ self: { ]; description = "image compositing with sdl2 - declarative style"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sdl2-fps" = callPackage @@ -231218,8 +217165,6 @@ self: { libraryHaskellDepends = [ base sdl2 ]; description = "Run of the mill, frames per second timer implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sdl2-gfx" = callPackage @@ -231517,8 +217462,6 @@ self: { description = "A software defined radio library"; license = lib.licenses.bsd3; platforms = [ "x86_64-darwin" "x86_64-linux" ]; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "seacat" = callPackage @@ -231554,8 +217497,6 @@ self: { libraryHaskellDepends = [ base bytestring free mtl text ]; description = "Pure SQL layer on top of other libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "seakale-postgresql" = callPackage @@ -231571,8 +217512,6 @@ self: { ]; description = "PostgreSQL backend for Seakale"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "seakale-tests" = callPackage @@ -231588,8 +217527,6 @@ self: { ]; description = "Helpers to test code using Seakale"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "seal-module" = callPackage @@ -231642,8 +217579,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Semantic Editor Combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "secd" = callPackage @@ -231674,8 +217609,6 @@ self: { executableHaskellDepends = [ base containers ]; description = "SECDH Machine Simulator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "seclib" = callPackage @@ -231687,8 +217620,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple library for static information-flow security in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "second-transfer" = callPackage @@ -231716,8 +217647,6 @@ self: { testToolDepends = [ cpphs ]; description = "Second Transfer HTTP/2 web server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "secp256k1" = callPackage @@ -231741,8 +217670,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bindings for secp256k1 library from Bitcoin Core"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) secp256k1;}; "secp256k1-haskell" = callPackage @@ -231768,8 +217695,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bindings for secp256k1"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) secp256k1;}; "secp256k1-legacy" = callPackage @@ -231795,8 +217720,6 @@ self: { ]; description = "fork of secp256k1"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "secret-santa" = callPackage @@ -231814,8 +217737,6 @@ self: { ]; description = "Secret Santa game assigner using QR-Codes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "secret-sharing" = callPackage @@ -231849,8 +217770,6 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "Example of writing \"secure\" file removal in Haskell rather than C"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "secure-sockets" = callPackage @@ -231866,8 +217785,6 @@ self: { ]; description = "Secure point-to-point connectivity library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "secureUDP" = callPackage @@ -231879,8 +217796,6 @@ self: { libraryHaskellDepends = [ base bytestring containers network ]; description = "Setups secure (unsorted) UDP packet transfer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "securemem" = callPackage @@ -231910,8 +217825,6 @@ self: { librarySystemDepends = [ sedna ]; description = "Sedna C API XML Binding"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {sedna = null;}; "seitz-symbol" = callPackage @@ -231931,8 +217844,6 @@ self: { ]; description = "Read and Display Seitz Symbol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "selda" = callPackage @@ -232055,8 +217966,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "CSS Selectors for DOM traversal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "selenium" = callPackage @@ -232068,8 +217977,6 @@ self: { libraryHaskellDepends = [ base HTTP HUnit mtl network pretty ]; description = "Test web applications through a browser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "selenium-server" = callPackage @@ -232089,8 +217996,6 @@ self: { testHaskellDepends = [ base hspec text webdriver ]; description = "Run the selenium standalone server for usage with webdriver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "self-extract" = callPackage @@ -232110,8 +218015,6 @@ self: { executableHaskellDepends = [ base ]; description = "A Haskell library to make self-extracting executables"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "selfrestart" = callPackage @@ -232135,8 +218038,6 @@ self: { librarySystemDepends = [ selinux ]; description = "SELinux bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {selinux = null;}; "semantic" = callPackage @@ -232168,8 +218069,6 @@ self: { ]; description = "Types and functionality for working with source code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semaphore-plus" = callPackage @@ -232201,8 +218100,6 @@ self: { executableHaskellDepends = [ base ]; description = "Evaluate code snippets in Literate Haskell"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semi-iso" = callPackage @@ -232218,8 +218115,6 @@ self: { ]; description = "Weakened partial isomorphisms, reversible computations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semialign" = callPackage @@ -232273,8 +218168,6 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "Extra functions for working with Semialigns"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semialign-indexed" = callPackage @@ -232349,8 +218242,6 @@ self: { testHaskellDepends = [ base ]; description = "A Haskell implementation of semibounded lattices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semigroupoid-extras" = callPackage @@ -232401,8 +218292,6 @@ self: { ]; description = "RebindableSyntax using the semigroupoids package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semigroups" = callPackage @@ -232425,8 +218314,6 @@ self: { libraryHaskellDepends = [ base containers semigroups ]; description = "Semigroups actions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semilattices" = callPackage @@ -232458,8 +218345,6 @@ self: { libraryHaskellDepends = [ base Boolean containers monoids ]; description = "Semirings, ring-like structures used for dynamic programming applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semiring-num" = callPackage @@ -232485,8 +218370,6 @@ self: { ]; description = "Basic semiring class and instances"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "semiring-simple" = callPackage @@ -232576,8 +218459,6 @@ self: { ]; description = "Sengrid API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sendgrid-v3" = callPackage @@ -232596,8 +218477,6 @@ self: { ]; description = "Sendgrid v3 API library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sensei" = callPackage @@ -232624,8 +218503,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Automatically run Hspec tests on file modifications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sensenet" = callPackage @@ -232643,8 +218520,6 @@ self: { ]; description = "Distributed sensor network for the raspberry pi"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sensu-run" = callPackage @@ -232666,8 +218541,6 @@ self: { ]; description = "A tool to send command execution results to Sensu"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sentence-jp" = callPackage @@ -232681,8 +218554,6 @@ self: { ]; description = "Easily generating message of japanese natural language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sentiwordnet-parser" = callPackage @@ -232719,8 +218590,6 @@ self: { executableHaskellDepends = [ base directory filepath unix ]; description = "Process monitoring tool written and configured in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "senza" = callPackage @@ -232768,8 +218637,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "SmartyPants for Korean language"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "separated" = callPackage @@ -232816,8 +218683,6 @@ self: { ]; description = "Dynamic strictness control, including space leak repair"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "seqalign" = callPackage @@ -232871,8 +218736,6 @@ self: { ]; description = "Handle sequence locations for bioinformatics"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "seqloc-datafiles" = callPackage @@ -232906,8 +218769,6 @@ self: { ]; description = "Read and write BED and GTF format genome annotations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sequence" = callPackage @@ -232986,8 +218847,6 @@ self: { ]; description = "Alternative Core language for GHC plugins"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sequential-index" = callPackage @@ -233022,8 +218881,6 @@ self: { ]; description = "A sequence labeler based on Collins's sequence perceptron"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serf" = callPackage @@ -233138,8 +218995,6 @@ self: { ]; description = "Instances for Serialize of cereal"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serialport" = callPackage @@ -233152,8 +219007,6 @@ self: { testHaskellDepends = [ base bytestring HUnit ]; description = "Cross platform serial port library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serokell-util" = callPackage @@ -233184,8 +219037,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "General-purpose functions by Serokell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serpentine" = callPackage @@ -233204,8 +219055,6 @@ self: { executableHaskellDepends = [ base singletons text ]; description = "Simple project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serv" = callPackage @@ -233219,8 +219068,6 @@ self: { ]; description = "Dependently typed API framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serv-wai" = callPackage @@ -233245,8 +219092,6 @@ self: { ]; description = "Dependently typed API servers with Serv"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant" = callPackage @@ -233293,8 +219138,6 @@ self: { ]; description = "Servant support for JuicyPixels"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-aeson-specs" = callPackage @@ -233320,8 +219163,6 @@ self: { ]; description = "generic tests for aeson serialization in servant"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth" = callPackage @@ -233393,8 +219234,6 @@ self: { ]; description = "Authentication via encrypted cookies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-docs" = callPackage @@ -233419,8 +219258,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "servant-docs/servant-auth compatibility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-hmac" = callPackage @@ -233456,8 +219293,6 @@ self: { ]; description = "Authentication via HMAC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-server" = callPackage @@ -233525,8 +219360,6 @@ self: { ]; description = "Servant based API and server for token based authorisation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-token-acid" = callPackage @@ -233548,8 +219381,6 @@ self: { ]; description = "Acid-state backend for servant-auth-token server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-token-api" = callPackage @@ -233566,8 +219397,6 @@ self: { ]; description = "Servant based API for token based authorisation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-token-leveldb" = callPackage @@ -233589,8 +219418,6 @@ self: { ]; description = "Leveldb backend for servant-auth-token server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-token-persistent" = callPackage @@ -233610,8 +219437,6 @@ self: { ]; description = "Persistent backend for servant-auth-token server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-token-rocksdb" = callPackage @@ -233634,8 +219459,6 @@ self: { ]; description = "RocksDB backend for servant-auth-token server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-auth-wordpress" = callPackage @@ -233651,8 +219474,6 @@ self: { ]; description = "Authenticate Routes Using Wordpress Cookies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-avro" = callPackage @@ -233670,8 +219491,6 @@ self: { ]; description = "Avro content type for Servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-benchmark" = callPackage @@ -233693,8 +219512,6 @@ self: { ]; description = "Generate benchmark files from a Servant API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-blaze" = callPackage @@ -233728,8 +219545,6 @@ self: { ]; description = "Servant CSV content-type for cassava"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-checked-exceptions" = callPackage @@ -233754,8 +219569,6 @@ self: { ]; description = "Checked exceptions for Servant APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-checked-exceptions-core" = callPackage @@ -233777,8 +219590,6 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "Checked exceptions for Servant APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-cli" = callPackage @@ -233806,8 +219617,6 @@ self: { ]; description = "Command line interface for Servant API clients"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-client" = callPackage @@ -233880,8 +219689,6 @@ self: { ]; description = "A servant client for frontend JavaScript"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-client-namedargs" = callPackage @@ -233903,8 +219710,6 @@ self: { ]; description = "Automatically derive API client functions with named and optional parameters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-conduit" = callPackage @@ -233944,8 +219749,6 @@ self: { ]; description = "Generate servant client library for C#"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-db" = callPackage @@ -233957,8 +219760,6 @@ self: { libraryHaskellDepends = [ base servant ]; description = "Servant types for defining API with relational DBs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-db-postgresql" = callPackage @@ -233984,8 +219785,6 @@ self: { ]; description = "Derive a postgres client to database API specified by servant-db"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-dhall" = callPackage @@ -234007,8 +219806,6 @@ self: { ]; description = "Servant Dhall content-type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-docs" = callPackage @@ -234059,8 +219856,6 @@ self: { ]; description = "Generate endpoints overview for Servant API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-ede" = callPackage @@ -234084,8 +219879,6 @@ self: { ]; description = "Combinators for rendering EDE templates in servant web applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-ekg" = callPackage @@ -234112,8 +219905,6 @@ self: { ]; description = "Helpers for using ekg with servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-elm" = callPackage @@ -234136,8 +219927,6 @@ self: { ]; description = "Automatically derive Elm functions to query servant webservices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-errors" = callPackage @@ -234181,8 +219970,6 @@ self: { testHaskellDepends = [ base ]; description = "Servant support for Server-Sent events"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-examples" = callPackage @@ -234205,8 +219992,6 @@ self: { ]; description = "Example programs for servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-exceptions" = callPackage @@ -234250,8 +220035,6 @@ self: { ]; description = "Fiat content types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-flatten" = callPackage @@ -234293,8 +220076,6 @@ self: { libraryHaskellDepends = [ base servant servant-server ]; description = "Utilities for generating mock server implementations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-generic" = callPackage @@ -234311,8 +220092,6 @@ self: { ]; description = "Specify Servant APIs with records"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-github" = callPackage @@ -234336,8 +220115,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Bindings to GitHub API using servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-github-webhook" = callPackage @@ -234387,8 +220164,6 @@ self: { ]; description = "automatical derivation of querying functions for servant webservices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-hmac-auth" = callPackage @@ -234415,8 +220190,6 @@ self: { testHaskellDepends = [ base ]; description = "Servant authentication with HMAC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-http-streams" = callPackage @@ -234450,8 +220223,6 @@ self: { testToolDepends = [ hspec-discover markdown-unlit ]; description = "Automatic derivation of querying functions for servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-http2-client" = callPackage @@ -234476,8 +220247,6 @@ self: { ]; description = "Generate HTTP2 clients from Servant API descriptions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-iCalendar" = callPackage @@ -234494,8 +220263,6 @@ self: { ]; description = "Servant support for iCalendar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-jquery" = callPackage @@ -234514,8 +220281,6 @@ self: { ]; description = "Automatically derive (jquery) javascript functions to query servant webservices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-js" = callPackage @@ -234539,8 +220304,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Automatically derive javascript functions to query servant webservices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-jsonrpc" = callPackage @@ -234607,8 +220370,6 @@ self: { ]; description = "Automatically derive Kotlin class to query servant webservices"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-lucid" = callPackage @@ -234677,8 +220438,6 @@ self: { ]; description = "Matrix parameter combinator for servant"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-mock" = callPackage @@ -234707,8 +220466,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Derive a mock server for free from your servant API types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-multipart" = callPackage @@ -234741,8 +220498,6 @@ self: { ]; description = "multipart/form-data (e.g file upload) support for servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-named" = callPackage @@ -234773,8 +220528,6 @@ self: { testHaskellDepends = [ base hspec named QuickCheck servant ]; description = "Combinators for servant providing named parameters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-nix" = callPackage @@ -234796,8 +220549,6 @@ self: { ]; description = "Servant Nix content-type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-openapi3" = callPackage @@ -234859,8 +220610,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck servant-server text ]; description = "Type-safe pagination for Servant APIs"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-pandoc" = callPackage @@ -234878,8 +220627,6 @@ self: { ]; description = "Use Pandoc to render servant API documentation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-pipes" = callPackage @@ -234926,8 +220673,6 @@ self: { ]; description = "Utilities for using servant in a polysemy stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-pool" = callPackage @@ -234941,8 +220686,6 @@ self: { libraryHaskellDepends = [ base resource-pool servant time ]; description = "Utility functions for creating servant 'Context's with \"context/connection pooling\" support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-postgresql" = callPackage @@ -234959,8 +220702,6 @@ self: { ]; description = "Useful functions and instances for using servant with a PostgreSQL context"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-proto-lens" = callPackage @@ -234983,8 +220724,6 @@ self: { ]; description = "Servant Content-Type for proto-lens protobuf modules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-purescript" = callPackage @@ -235008,8 +220747,6 @@ self: { ]; description = "Generate PureScript accessor functions for you servant API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-pushbullet-client" = callPackage @@ -235029,8 +220766,6 @@ self: { ]; description = "Bindings to the Pushbullet API using servant-client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-py" = callPackage @@ -235052,8 +220787,6 @@ self: { ]; description = "Automatically derive python functions to query servant webservices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-quickcheck" = callPackage @@ -235082,8 +220815,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "QuickCheck entire APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-rawm" = callPackage @@ -235106,8 +220837,6 @@ self: { libraryHaskellDepends = [ base servant-client-core servant-rawm ]; description = "The client implementation of servant-rawm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-rawm-docs" = callPackage @@ -235123,8 +220852,6 @@ self: { ]; description = "Documentation generator for 'RawM' endpoints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-rawm-server" = callPackage @@ -235161,8 +220888,6 @@ self: { ]; description = "Derive Reason types to interact with a Haskell backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-reflex" = callPackage @@ -235185,8 +220910,6 @@ self: { ]; description = "servant API generator for reflex apps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-response" = callPackage @@ -235219,8 +220942,6 @@ self: { ]; description = "Servant router for non-server applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-ruby" = callPackage @@ -235253,8 +220974,6 @@ self: { ]; description = "Generate a web service for servant 'Resource's using scotty and JSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-seo" = callPackage @@ -235277,8 +220996,6 @@ self: { ]; description = "Generate Robots.txt and Sitemap.xml specification for your servant API."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-serf" = callPackage @@ -235298,8 +221015,6 @@ self: { doHaddock = false; description = "Generates a servant API module"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-server" = callPackage @@ -235352,8 +221067,6 @@ self: { ]; description = "Automatically derive API server functions with named and optional parameters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-smsc-ru" = callPackage @@ -235376,8 +221089,6 @@ self: { ]; description = "Servant client for smsc.ru service for sending SMS to cell phones"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-snap" = callPackage @@ -235415,8 +221126,6 @@ self: { ]; description = "A family of combinators for defining webservices APIs and serving them"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-stache" = callPackage @@ -235465,8 +221174,6 @@ self: { ]; description = "Embed a directory of static files in your Servant server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-streaming" = callPackage @@ -235481,8 +221188,6 @@ self: { testHaskellDepends = [ base hspec http-types QuickCheck servant ]; description = "Servant combinators for the 'streaming' package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-streaming-client" = callPackage @@ -235508,8 +221213,6 @@ self: { ]; description = "Client instances for the 'servant-streaming' package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-streaming-docs" = callPackage @@ -235527,8 +221230,6 @@ self: { ]; description = "Client instances for the 'servant-docs' package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-streaming-server" = callPackage @@ -235555,8 +221256,6 @@ self: { ]; description = "Server instances for the 'servant-streaming' package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-subscriber" = callPackage @@ -235627,8 +221326,6 @@ self: { ]; description = "Swagger Tags for Servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-swagger-ui" = callPackage @@ -235719,8 +221416,6 @@ self: { ]; description = "Automatically generate Elm clients for Servant APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-tracing" = callPackage @@ -235791,8 +221486,6 @@ self: { ]; description = "Servant Integration for Waargonaut JSON Package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-wasm" = callPackage @@ -235869,8 +221562,6 @@ self: { ]; description = "Servant support for yaml"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-zeppelin" = callPackage @@ -235882,8 +221573,6 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Types and definitions of servant-zeppelin combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-zeppelin-client" = callPackage @@ -235907,8 +221596,6 @@ self: { ]; description = "Client library for servant-zeppelin combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-zeppelin-server" = callPackage @@ -235932,8 +221619,6 @@ self: { ]; description = "Server library for servant-zeppelin combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "servant-zeppelin-swagger" = callPackage @@ -235955,8 +221640,6 @@ self: { ]; description = "Swagger instances for servant-zeppelin combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "server-generic" = callPackage @@ -235972,8 +221655,6 @@ self: { ]; description = "Auto-generate a server for your datatype"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serverless-haskell" = callPackage @@ -236025,8 +221706,6 @@ self: { ]; description = "Secure, modular server-side sessions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serversession-backend-acid-state" = callPackage @@ -236047,8 +221726,6 @@ self: { ]; description = "Storage backend for serversession using acid-state"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serversession-backend-persistent" = callPackage @@ -236075,8 +221752,6 @@ self: { ]; description = "Storage backend for serversession using persistent and an RDBMS"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serversession-backend-redis" = callPackage @@ -236098,8 +221773,6 @@ self: { ]; description = "Storage backend for serversession using Redis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serversession-frontend-snap" = callPackage @@ -236117,8 +221790,6 @@ self: { ]; description = "Snap bindings for serversession"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serversession-frontend-wai" = callPackage @@ -236136,8 +221807,6 @@ self: { ]; description = "wai-session bindings for serversession"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serversession-frontend-yesod" = callPackage @@ -236156,8 +221825,6 @@ self: { ]; description = "Yesod bindings for serversession"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "services" = callPackage @@ -236175,8 +221842,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Tools for building services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "serviette" = callPackage @@ -236242,8 +221907,6 @@ self: { ]; description = "Snaplet for the ses-html package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sessions" = callPackage @@ -236258,8 +221921,6 @@ self: { ]; description = "Session Types for Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sessiontypes" = callPackage @@ -236281,8 +221942,6 @@ self: { testHaskellDepends = [ base directory exceptions hspec ]; description = "Session types library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sessiontypes-distributed" = callPackage @@ -236305,8 +221964,6 @@ self: { ]; description = "Session types distributed"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "set-cover" = callPackage @@ -236368,8 +222025,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Sets of fixed size, with typelits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "set-with" = callPackage @@ -236387,8 +222042,6 @@ self: { ]; description = "Set of elements sorted by a different data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "setdown" = callPackage @@ -236408,8 +222061,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Treating files as sets to perform rapid set manipulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "setenv" = callPackage @@ -236439,8 +222090,6 @@ self: { executableHaskellDepends = [ base ]; description = "A console interface to the game of Set"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "setlocale" = callPackage @@ -236470,8 +222119,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A Haskell implementation of setoid"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "setop" = callPackage @@ -236549,8 +222196,6 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Small (TH) library to declare setters for typical `record' data type fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "settings" = callPackage @@ -236586,8 +222231,6 @@ self: { ]; description = "S-Expression parsing/printing made fun and easy"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sexp-grammar" = callPackage @@ -236617,8 +222260,6 @@ self: { ]; description = "Invertible grammar combinators for S-expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sexp-show" = callPackage @@ -236666,8 +222307,6 @@ self: { testHaskellDepends = [ base data-default hspec megaparsec ]; description = "Simple s-expression parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sexpresso" = callPackage @@ -236707,8 +222346,6 @@ self: { ]; description = "Lists, Texts, ByteStrings and Vectors with type-encoded length"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sfml-audio" = callPackage @@ -236733,8 +222370,6 @@ self: { libraryHaskellDepends = [ base bytestring entropy primitive ]; description = "SIMD-oriented Fast Mersenne Twister(SFMT) binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sfnt2woff" = callPackage @@ -236755,8 +222390,6 @@ self: { testHaskellDepends = [ base ]; description = "A command line tool to convert TrueType/OpenType fonts to WOFF format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zlib;}; "sgd" = callPackage @@ -236781,8 +222414,6 @@ self: { ]; description = "Stochastic gradient descent library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sgf" = callPackage @@ -236799,8 +222430,6 @@ self: { ]; description = "SGF (Smart Game Format) parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sgrep" = callPackage @@ -236814,8 +222443,6 @@ self: { executableHaskellDepends = [ base bio regex-compat ]; description = "Sgrep - grep Fasta files for sequences matching a regular expression"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sh2md" = callPackage @@ -236842,8 +222469,6 @@ self: { ]; description = "Record your shell session and print in the markdown format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sha-streams" = callPackage @@ -236858,8 +222483,6 @@ self: { executableHaskellDepends = [ base io-streams SHA ]; description = "SHA hashes for io-streams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sha1" = callPackage @@ -236876,8 +222499,6 @@ self: { ]; description = "SHA-1 Hash"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shade" = callPackage @@ -236891,8 +222512,6 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "A control structure used to combine heterogenous types with delayed effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shadower" = callPackage @@ -236915,8 +222534,6 @@ self: { ]; description = "An automated way to run doctests in files that are changing"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shadowsocks" = callPackage @@ -237064,8 +222681,6 @@ self: { ]; description = "Rules for binary distributions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-c" = callPackage @@ -237108,8 +222723,6 @@ self: { ]; description = "Utility for building Shake build systems using Cabal sandboxes"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-ccjs" = callPackage @@ -237137,8 +222750,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Dhall dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-elm" = callPackage @@ -237176,8 +222787,6 @@ self: { ]; description = "Extra utilities for shake build systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-futhark" = callPackage @@ -237246,8 +222855,6 @@ self: { ]; description = "Shake Minify Rules"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-minify-css" = callPackage @@ -237261,8 +222868,6 @@ self: { ]; description = "Shake rules for CSS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-pack" = callPackage @@ -237274,8 +222879,6 @@ self: { libraryHaskellDepends = [ base bytestring bzlib shake tar ]; description = "Shake File Pack Rule"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-path" = callPackage @@ -237287,8 +222890,6 @@ self: { libraryHaskellDepends = [ base path path-io shake ]; description = "path alternatives to shake functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-persist" = callPackage @@ -237306,8 +222907,6 @@ self: { executableHaskellDepends = [ base shake ]; description = "Shake build system on-disk caching"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shake-plus" = callPackage @@ -237383,8 +222982,6 @@ self: { ]; description = "Shake-based technical documentation generator; HTML & PDF"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shaker" = callPackage @@ -237413,8 +223010,6 @@ self: { ]; description = "simple and interactive command-line build tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shakers" = callPackage @@ -237470,8 +223065,6 @@ self: { ]; description = "compile es2015"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shakespeare-css" = callPackage @@ -237523,8 +223116,6 @@ self: { ]; description = "SASS support for Shakespeare and Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shakespeare-text" = callPackage @@ -237581,8 +223172,6 @@ self: { ]; description = "Parser and related tools for ESRI shapefile format"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shapely-data" = callPackage @@ -237601,8 +223190,6 @@ self: { ]; description = "Generics using @(,)@ and @Either@, with algebraic operations and typed conversions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shapes" = callPackage @@ -237700,8 +223287,6 @@ self: { ]; description = "A circular buffer built on shared memory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shared-fields" = callPackage @@ -237715,8 +223300,6 @@ self: { testHaskellDepends = [ base Cabal hspec lens text ]; description = "a tiny library for using shared lens fields"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shared-memory" = callPackage @@ -237756,8 +223339,6 @@ self: { executableHaskellDepends = [ base filepath mtl ]; description = "A Haskell preprocessor adding miscellaneous features"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shelduck" = callPackage @@ -237788,8 +223369,6 @@ self: { ]; description = "Test webhooks locally"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shell-conduit" = callPackage @@ -237852,8 +223431,6 @@ self: { executableHaskellDepends = [ base ]; description = "Pipe streams through external shell commands"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shell-utility" = callPackage @@ -237881,8 +223458,6 @@ self: { ]; description = "shell-/perl- like (systems) programming in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shellmate" = callPackage @@ -237899,8 +223474,6 @@ self: { ]; description = "Simple interface for shell scripting in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shellmate-extras" = callPackage @@ -237917,8 +223490,6 @@ self: { ]; description = "Extra functionality for shellmate"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shellmet" = callPackage @@ -238148,8 +223719,6 @@ self: { ]; description = "The Reflective Lambda Machine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shine" = callPackage @@ -238179,8 +223748,6 @@ self: { isExecutable = true; description = "Examples for the shine package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shine-varying" = callPackage @@ -238211,8 +223778,6 @@ self: { ]; description = "Implementation of Shivers' Control-Flow Analysis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shoap" = callPackage @@ -238224,8 +223789,6 @@ self: { libraryHaskellDepends = [ base curl ]; description = "A very basic SOAP package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shopify" = callPackage @@ -238246,8 +223809,6 @@ self: { ]; description = "A haskell API binding for shopify.com"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shortcircuit" = callPackage @@ -238283,8 +223844,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Link shortcuts for use in text markup"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shorten-strings" = callPackage @@ -238296,8 +223855,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "Shorten a variety of string-like types adding ellipsis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "should-not-typecheck" = callPackage @@ -238372,8 +223929,6 @@ self: { ]; description = "Robust prettyprinter for output of auto-generated Show instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "show-type" = callPackage @@ -238399,8 +223954,6 @@ self: { executableHaskellDepends = [ base glade gtk random ]; description = "A simple gtk based Russian Roulette game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shower" = callPackage @@ -238442,8 +223995,6 @@ self: { ]; description = "Web automation library in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shplit" = callPackage @@ -238493,8 +224044,6 @@ self: { executableHaskellDepends = [ base ]; description = "Shuffle tool for UHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "shunya-library" = callPackage @@ -238535,8 +224084,6 @@ self: { ]; description = "Generate swift types from haskell types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "si-clock" = callPackage @@ -238550,8 +224097,6 @@ self: { ]; description = "An interface to the Silicon Labs Si5351 clock chip"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sibe" = callPackage @@ -238577,8 +224122,6 @@ self: { ]; description = "Machine Learning algorithms"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sieve" = callPackage @@ -238613,8 +224156,6 @@ self: { ]; description = "Simple, visual, functional language for learning about recursion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sifflet-lib" = callPackage @@ -238633,8 +224174,6 @@ self: { librarySystemDepends = [ gdk_x11 gtk_x11 ]; description = "Library of modules shared by sifflet and its tests and its exporters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {gdk_x11 = null; gtk_x11 = null;}; "siggy-chardust" = callPackage @@ -238675,8 +224214,6 @@ self: { ]; description = "Thom polynomials of second order Thom-Boardman singularities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sign" = callPackage @@ -238699,8 +224236,6 @@ self: { ]; description = "Arithmetic over signs and sets of signs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "signable" = callPackage @@ -238729,8 +224264,6 @@ self: { ]; description = "Deterministic serialisation and signatures with proto-lens support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "signable-haskell-protoc" = callPackage @@ -238780,8 +224313,6 @@ self: { ]; description = "Synchronous signal processing for DSLs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "signature" = callPackage @@ -238799,8 +224330,6 @@ self: { ]; description = "Hmac sha256 signature json and http payload"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "signed-multiset" = callPackage @@ -238812,8 +224341,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Multisets with negative membership"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "signify-hs" = callPackage @@ -238837,8 +224364,6 @@ self: { ]; description = "A Haskell clone of OpenBSD signify"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "silently" = callPackage @@ -238862,8 +224387,6 @@ self: { libraryHaskellDepends = [ base prettyprinter ]; description = "Prettyprinting transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "silvi" = callPackage @@ -238881,8 +224404,6 @@ self: { testHaskellDepends = [ base quantification savage text ]; description = "A generator for different kinds of data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simd" = callPackage @@ -238894,8 +224415,6 @@ self: { libraryHaskellDepends = [ base ghc-prim primitive vector ]; description = "simple interface to GHC's SIMD instructions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simgi" = callPackage @@ -238913,8 +224432,6 @@ self: { ]; description = "stochastic simulation engine"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple" = callPackage @@ -238963,8 +224480,6 @@ self: { ]; description = "A library for more structured concurrent programming, based on the Actor Model"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-affine-space" = callPackage @@ -238993,8 +224508,6 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "Atom (or symbol) datatype for fast comparision and sorting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-bluetooth" = callPackage @@ -239007,8 +224520,6 @@ self: { librarySystemDepends = [ bluetooth ]; description = "Simple Bluetooth API for Windows and Linux (bluez)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {bluetooth = null;}; "simple-c-value" = callPackage @@ -239031,8 +224542,6 @@ self: { ]; description = "A simple C value type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-cabal" = callPackage @@ -239101,8 +224610,6 @@ self: { ]; description = "A simple streaming I/O library based on monadic folds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-config" = callPackage @@ -239120,8 +224627,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Simple config file parser generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-css" = callPackage @@ -239137,8 +224642,6 @@ self: { ]; description = "simple binding of css and html"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-download" = callPackage @@ -239154,8 +224657,6 @@ self: { ]; description = "A simple wrapper of http-conduit for file download"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-effects" = callPackage @@ -239203,8 +224704,6 @@ self: { executableHaskellDepends = [ base text ]; description = "Evaluate a Text to an Integer: \"1 + 1\" -> 2"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-firewire" = callPackage @@ -239216,8 +224715,6 @@ self: { libraryHaskellDepends = [ base bindings-dc1394 CV ]; description = "Simplified interface for firewire cameras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-form" = callPackage @@ -239249,8 +224746,6 @@ self: { executableHaskellDepends = [ base deepseq parallel random ]; description = "Simple parallel genetic algorithm implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-genetic-algorithm-mr" = callPackage @@ -239297,8 +224792,6 @@ self: { ]; description = "Allows simple indexation on any data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-log" = callPackage @@ -239330,8 +224823,6 @@ self: { libraryHaskellDepends = [ base hsyslog simple-log text ]; description = "Syslog backend for simple-log"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-logger" = callPackage @@ -239365,8 +224856,6 @@ self: { ]; description = "Logging effect to plug into the simple-effects framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-ltl" = callPackage @@ -239391,8 +224880,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple library to handle and interexchange money"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-neural-networks" = callPackage @@ -239412,8 +224899,6 @@ self: { ]; description = "Simple parallel neural networks implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-nix" = callPackage @@ -239435,8 +224920,6 @@ self: { ]; description = "Simple parsing/pretty printing for Nix expressions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-observer" = callPackage @@ -239486,8 +224969,6 @@ self: { ]; description = "Simplified Pascal language to SSVM compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-pipe" = callPackage @@ -239506,8 +224987,6 @@ self: { ]; description = "simple pipeline library like conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-postgresql-orm" = callPackage @@ -239547,8 +225026,6 @@ self: { libraryHaskellDepends = [ base bytestring QuickCheck ]; description = "Memory-efficient strings with concatenation and splitting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-sendfile" = callPackage @@ -239582,8 +225059,6 @@ self: { ]; description = "Simple Server interface"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-session" = callPackage @@ -239637,8 +225112,6 @@ self: { testHaskellDepends = [ base mtl parsec pretty tasty tasty-hunit ]; description = "A parser for SQL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-src-utils" = callPackage @@ -239671,8 +225144,6 @@ self: { ]; description = "Simple stacked virtual machine: assembler, disassembler, bytecode interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-tabular" = callPackage @@ -239684,8 +225155,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Simple tabular-text formatter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-tar" = callPackage @@ -239701,8 +225170,6 @@ self: { ]; description = "Simple, pure, file-system-free reading of tar files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-templates" = callPackage @@ -239754,8 +225221,6 @@ self: { ]; description = "UI library for terminal"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-units" = callPackage @@ -239768,8 +225233,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Simple arithmetic with SI units using type-checked dimensional analysis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-vec3" = callPackage @@ -239787,8 +225250,6 @@ self: { benchmarkHaskellDepends = [ base criterion vector ]; description = "Three-dimensional vectors of doubles with basic operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simple-zipper" = callPackage @@ -239801,8 +225262,6 @@ self: { testHaskellDepends = [ base hspec lens ]; description = "Zippers made slightly easier"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simpleargs" = callPackage @@ -239815,8 +225274,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Provides a more flexible getArgs function with better error reporting"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simpleconfig" = callPackage @@ -239833,8 +225290,6 @@ self: { ]; description = "Short description of your package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simpleirc" = callPackage @@ -239851,8 +225306,6 @@ self: { testHaskellDepends = [ base bytestring hspec HUnit knob ]; description = "Simple IRC Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simpleirc-lens" = callPackage @@ -239864,8 +225317,6 @@ self: { libraryHaskellDepends = [ base bytestring simpleirc ]; description = "Lenses for simpleirc types"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simplelru" = callPackage @@ -239907,8 +225358,6 @@ self: { ]; description = "Haskell interface for the simplenote API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simpleprelude" = callPackage @@ -239927,8 +225376,6 @@ self: { ]; description = "A simplified Haskell prelude for teaching"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simplesmtpclient" = callPackage @@ -239942,8 +225389,6 @@ self: { libraryHaskellDepends = [ array base directory network old-time ]; description = "Very simple SMTP Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simplessh" = callPackage @@ -239972,8 +225417,6 @@ self: { librarySystemDepends = [ sqlite ]; description = "Simplest SQLite3 binding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) sqlite;}; "simplex" = callPackage @@ -240041,8 +225484,6 @@ self: { executableHaskellDepends = [ base bio bytestring random ]; description = "Simulate sequencing with different models for priming and errors"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "simtreelo" = callPackage @@ -240155,8 +225596,6 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Typelevel balanced search trees via a singletonized Data.Map"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "singleton-nats" = callPackage @@ -240191,8 +225630,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Singletons and induction over GHC TypeLits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "singletons" = callPackage @@ -240253,8 +225690,6 @@ self: { ]; description = "A promoted and singled version of the base library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "singletons-presburger" = callPackage @@ -240288,8 +225723,6 @@ self: { ]; description = "A framework for generating singleton types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "singnal" = callPackage @@ -240301,8 +225734,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Singnal"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "singular-factory" = callPackage @@ -240323,8 +225754,6 @@ self: { ]; description = "Multivariate polynomial factorization via bindings to Singular-factory"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {singular-factory = null;}; "sink" = callPackage @@ -240336,8 +225765,6 @@ self: { libraryHaskellDepends = [ base ]; description = "An alternative to lazy I/O that doesn't conflate execution with evaluation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "siphash" = callPackage @@ -240384,8 +225811,6 @@ self: { ]; description = "Encode and decode CSV files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "siren-json" = callPackage @@ -240410,8 +225835,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Siren Tools for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sirkel" = callPackage @@ -240428,8 +225851,6 @@ self: { ]; description = "Sirkel, a Chord DHT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sitemap" = callPackage @@ -240477,8 +225898,6 @@ self: { ]; description = "A simple to understand static site generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sixel" = callPackage @@ -240514,8 +225933,6 @@ self: { ]; description = "A six figure group of time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sixty-five-oh-two" = callPackage @@ -240595,8 +226012,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Multidimensional grids with sized specified at compile time"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sized-types" = callPackage @@ -240615,8 +226030,6 @@ self: { ]; description = "Sized types in Haskell using the GHC Nat kind"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sized-vector" = callPackage @@ -240633,8 +226046,6 @@ self: { ]; description = "Size-parameterized vector types and functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sizes" = callPackage @@ -240654,8 +226065,6 @@ self: { ]; description = "Recursively show space (size and i-nodes) used in subdirectories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sjsp" = callPackage @@ -240677,8 +226086,6 @@ self: { executableToolDepends = [ alex happy ]; description = "Simple JavaScript Profiler"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skein" = callPackage @@ -240715,8 +226122,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Skeletal set - a set with equivalence relation different from equality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skeleton" = callPackage @@ -240735,8 +226140,6 @@ self: { ]; description = "a tool to access the OSX keychain"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skeletons" = callPackage @@ -240755,8 +226158,6 @@ self: { ]; description = "Manage project skeletons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skell" = callPackage @@ -240772,8 +226173,6 @@ self: { ]; description = "An overly complex Haskell web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skemmtun" = callPackage @@ -240792,8 +226191,6 @@ self: { ]; description = "A MyAnimeList.net client."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skews" = callPackage @@ -240810,8 +226207,6 @@ self: { ]; description = "A very quick-and-dirty WebSocket server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skip-list" = callPackage @@ -240850,8 +226245,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Eclectic collection of utility functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skylark-client" = callPackage @@ -240874,8 +226267,6 @@ self: { ]; description = "Skylark client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skylighting" = callPackage @@ -240956,8 +226347,6 @@ self: { ]; description = "Lucid support for Skylighting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skylighting-modding" = callPackage @@ -240986,8 +226375,6 @@ self: { ]; description = "Skype Desktop API binding for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "skypelogexport" = callPackage @@ -241025,8 +226412,6 @@ self: { ]; description = "Haskell API for interacting with Slack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slack-api" = callPackage @@ -241069,8 +226454,6 @@ self: { executableHaskellDepends = [ base ]; description = "Slack notifier for Haskell project"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slack-progressbar" = callPackage @@ -241114,8 +226497,6 @@ self: { ]; description = "Slack API Request Verification HMAC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slack-web" = callPackage @@ -241142,8 +226523,6 @@ self: { ]; description = "Bindings for the Slack web API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slate" = callPackage @@ -241191,8 +226570,6 @@ self: { ]; description = "A fundamental solution to ghost threads and silent exceptions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sleep" = callPackage @@ -241249,8 +226626,6 @@ self: { ]; description = "Python-ish slicing traversals for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slick" = callPackage @@ -241285,8 +226660,6 @@ self: { ]; description = "ws convert markdown to reveal-js"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slim" = callPackage @@ -241302,8 +226675,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Functional reactive user interface programming"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slip32" = callPackage @@ -241324,8 +226695,6 @@ self: { ]; description = "SLIP-0032: Extended serialization format for BIP-32 wallets"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slist" = callPackage @@ -241363,8 +226732,6 @@ self: { ]; description = "A command line interface to Sloane's OEIS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slope-field" = callPackage @@ -241399,8 +226766,6 @@ self: { ]; description = "Write lambdas without naming the parameters"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sloth" = callPackage @@ -241412,8 +226777,6 @@ self: { libraryHaskellDepends = [ base mtl process ]; description = "Testing for minimal strictness"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slotmap" = callPackage @@ -241447,8 +226810,6 @@ self: { ]; description = "Type-safe slugs for Yesod ecosystem"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slugify" = callPackage @@ -241464,8 +226825,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Convert text into slugs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "slynx" = callPackage @@ -241488,8 +226847,6 @@ self: { executableHaskellDepends = [ base ]; description = "Handle molecular sequences"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "small-bytearray-builder" = callPackage @@ -241502,8 +226859,6 @@ self: { doHaddock = false; description = "Serialize to bytes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smallarray" = callPackage @@ -241515,8 +226870,6 @@ self: { libraryHaskellDepends = [ base bytestring deepseq hashable ]; description = "low-level unboxed arrays, with minimal features"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smallcaps" = callPackage @@ -241567,8 +226920,6 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "See README for more info"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smallcheck-laws" = callPackage @@ -241580,8 +226931,6 @@ self: { libraryHaskellDepends = [ base smallcheck smallcheck-series ]; description = "SmallCheck properties for common laws"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smallcheck-lens" = callPackage @@ -241597,8 +226946,6 @@ self: { ]; description = "SmallCheck properties for lens"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smallcheck-series" = callPackage @@ -241631,8 +226978,6 @@ self: { executableHaskellDepends = [ base vector ]; description = "A Haskell port of the smallpt path tracer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smallstring" = callPackage @@ -241648,8 +226993,6 @@ self: { ]; description = "A Unicode text type, optimized for low memory overhead"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smaoin" = callPackage @@ -241696,8 +227039,6 @@ self: { ]; description = "A command line tool for working with sets and maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smartGroup" = callPackage @@ -241711,8 +227052,6 @@ self: { ]; description = "group strings or bytestrings by words in common"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smartcheck" = callPackage @@ -241733,8 +227072,6 @@ self: { ]; description = "A smarter QuickCheck"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smartconstructor" = callPackage @@ -241746,8 +227083,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "A package exposing a helper function for generating smart constructors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smarties" = callPackage @@ -241789,8 +227124,6 @@ self: { ]; description = "Web based flash card for Word Smart I and II vocabularies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smash" = callPackage @@ -241897,8 +227230,6 @@ self: { benchmarkHaskellDepends = [ base criterion time ]; description = "Symbolic Model Checking for Dynamic Epistemic Logic"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sme" = callPackage @@ -241910,8 +227241,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for Secure Multi-Execution in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smerdyakov" = callPackage @@ -241930,8 +227259,6 @@ self: { transformers yaml ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smiles" = callPackage @@ -241943,8 +227270,6 @@ self: { libraryHaskellDepends = [ base megaparsec text ]; testHaskellDepends = [ base hspec megaparsec QuickCheck text ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smith" = callPackage @@ -241956,8 +227281,6 @@ self: { libraryHaskellDepends = [ base bytesmith primitive ]; description = "Parse arrays of tokens"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smith-cli" = callPackage @@ -241981,8 +227304,6 @@ self: { ]; description = "Command line tool for ."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smith-client" = callPackage @@ -242006,8 +227327,6 @@ self: { ]; description = "API client for ."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smoothie" = callPackage @@ -242036,8 +227355,6 @@ self: { ]; description = "SMSAero API and HTTP client based on servant library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smt" = callPackage @@ -242064,8 +227381,6 @@ self: { libraryHaskellDepends = [ array base directory polyparse ]; description = "Parsing and printing SMT-LIB"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smt2-parser" = callPackage @@ -242078,8 +227393,6 @@ self: { testHaskellDepends = [ base HUnit parsec text ]; description = "A Haskell parser for SMT-LIB version 2.6"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smtLib" = callPackage @@ -242107,8 +227420,6 @@ self: { ]; description = "A type-safe interface to communicate with an SMT solver"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smtlib2-debug" = callPackage @@ -242125,8 +227436,6 @@ self: { ]; description = "Dump the communication with an SMT solver for debugging purposes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smtlib2-pipe" = callPackage @@ -242148,8 +227457,6 @@ self: { ]; description = "A type-safe interface to communicate with an SMT solver"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smtlib2-quickcheck" = callPackage @@ -242165,8 +227472,6 @@ self: { ]; description = "Helper functions to create SMTLib expressions in QuickCheck"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smtlib2-timing" = callPackage @@ -242178,8 +227483,6 @@ self: { libraryHaskellDepends = [ base dependent-sum mtl smtlib2 time ]; description = "Get timing informations for SMT queries"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smtp-mail" = callPackage @@ -242218,8 +227521,6 @@ self: { ]; description = "An SMTP client EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smtp2mta" = callPackage @@ -242252,8 +227553,6 @@ self: { ]; description = "Gmail SMTP Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smuggler" = callPackage @@ -242276,8 +227575,6 @@ self: { testHaskellDepends = [ base directory filepath ]; description = "GHC Source Plugin that helps to manage imports"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "smuggler2" = callPackage @@ -242299,8 +227596,6 @@ self: { ]; description = "GHC Source Plugin that helps to minimise imports and generate explicit exports"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snake" = callPackage @@ -242314,8 +227609,6 @@ self: { executableHaskellDepends = [ base random split terminal-size ]; description = "A basic console snake game"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snake-game" = callPackage @@ -242327,8 +227620,6 @@ self: { libraryHaskellDepends = [ base GLUT OpenGL random ]; description = "Snake Game Using OpenGL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap" = callPackage @@ -242379,8 +227670,6 @@ self: { ]; description = "Accept header branching for the Snap web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-app" = callPackage @@ -242412,8 +227701,6 @@ self: { ]; description = "Command-line tool to manage Snap AuthManager database"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-blaze" = callPackage @@ -242436,8 +227723,6 @@ self: { libraryHaskellDepends = [ base blaze-html clay snap-core ]; description = "blaze-html-clay integration for Snap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-configuration-utilities" = callPackage @@ -242451,8 +227736,6 @@ self: { ]; description = "Methods to manipulate Configurator objects for Snap & Snaplets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-core" = callPackage @@ -242518,7 +227801,6 @@ self: { description = "Serve Elm files through the Snap web framework"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-error-collector" = callPackage @@ -242535,8 +227817,6 @@ self: { ]; description = "Collect errors in batches and dispatch them"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-extras" = callPackage @@ -242568,8 +227848,6 @@ self: { ]; description = "A collection of useful helpers and utilities for Snap web applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-language" = callPackage @@ -242655,8 +227933,6 @@ self: { ]; description = "Typesafe URLs for Snap applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-server" = callPackage @@ -242714,8 +227990,6 @@ self: { ]; description = "Streaming Snap handlers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-templates" = callPackage @@ -242760,8 +228034,6 @@ self: { ]; description = "A library for BDD-style testing with the Snap Web Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-utils" = callPackage @@ -242779,8 +228051,6 @@ self: { ]; description = "Snap Framework utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snap-web-routes" = callPackage @@ -242796,8 +228066,6 @@ self: { ]; description = "Type safe URLs for Snap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-acid-state" = callPackage @@ -242811,8 +228079,6 @@ self: { ]; description = "acid-state snaplet for Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-actionlog" = callPackage @@ -242837,8 +228103,6 @@ self: { ]; description = "Generic action log snaplet for the Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-amqp" = callPackage @@ -242856,8 +228120,6 @@ self: { ]; description = "Snap framework snaplet for the AMQP library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-auth-acid" = callPackage @@ -242878,8 +228140,6 @@ self: { ]; description = "Provides an Acid-State backend for the Auth Snaplet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-coffee" = callPackage @@ -242897,8 +228157,6 @@ self: { ]; description = "CoffeeScript for Snap, auto-compilation and pre-compilation"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-css-min" = callPackage @@ -242915,8 +228173,6 @@ self: { ]; description = "A Snaplet for CSS minification"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-customauth" = callPackage @@ -242940,8 +228196,6 @@ self: { ]; description = "Alternate authentication snaplet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-environments" = callPackage @@ -242958,8 +228212,6 @@ self: { ]; description = "DEPRECATED! You should use standard Snap >= 0.9 \"environments\" functionality. It provided ability to easly read configuration based on given app environment given at command line, envs are defined in app configuration file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-fay" = callPackage @@ -242979,8 +228231,6 @@ self: { ]; description = "Fay integration for Snap with request- and pre-compilation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-ghcjs" = callPackage @@ -243014,8 +228264,6 @@ self: { ]; description = "A Hasql snaplet"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-haxl" = callPackage @@ -243031,8 +228279,6 @@ self: { ]; description = "Snaplet for Facebook's Haxl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-hdbc" = callPackage @@ -243053,8 +228299,6 @@ self: { ]; description = "HDBC snaplet for Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-hslogger" = callPackage @@ -243071,8 +228315,6 @@ self: { ]; description = "Snap framework snaplet for the Logger API library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-i18n" = callPackage @@ -243114,8 +228356,6 @@ self: { ]; description = "Snap framework snaplet for the InfluxDB library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-lss" = callPackage @@ -243133,7 +228373,6 @@ self: { description = "Lexical Style Sheets - Snap Web Framework adaptor"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-mandrill" = callPackage @@ -243150,8 +228389,6 @@ self: { ]; description = "Snap framework snaplet for the Mandrill API library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-mongoDB" = callPackage @@ -243171,8 +228408,6 @@ self: { ]; description = "Snap Framework MongoDB support as Snaplet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-mongodb-minimalistic" = callPackage @@ -243187,8 +228422,6 @@ self: { ]; description = "Minimalistic MongoDB Snaplet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-mysql-simple" = callPackage @@ -243209,8 +228442,6 @@ self: { ]; description = "mysql-simple snaplet for the Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-oauth" = callPackage @@ -243236,8 +228467,6 @@ self: { ]; description = "snaplet-oauth"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-persistent" = callPackage @@ -243260,8 +228489,6 @@ self: { ]; description = "persistent snaplet for the Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-postgresql-simple" = callPackage @@ -243286,8 +228513,6 @@ self: { ]; description = "postgresql-simple snaplet for the Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-postmark" = callPackage @@ -243304,8 +228529,6 @@ self: { ]; description = "Postmark snaplet for the Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-purescript" = callPackage @@ -243322,8 +228545,6 @@ self: { ]; description = "Automatic (re)compilation of purescript projects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-recaptcha" = callPackage @@ -243341,8 +228562,6 @@ self: { ]; description = "A ReCAPTCHA verification snaplet with Heist integration and connection sharing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-redis" = callPackage @@ -243362,8 +228581,6 @@ self: { ]; description = "Redis support for Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-redson" = callPackage @@ -243383,8 +228600,6 @@ self: { ]; description = "CRUD for JSON data with Redis storage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-rest" = callPackage @@ -243402,8 +228617,6 @@ self: { ]; description = "REST resources for the Snap web framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-riak" = callPackage @@ -243421,8 +228634,6 @@ self: { ]; description = "A Snaplet for the Riak database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-sass" = callPackage @@ -243440,8 +228651,6 @@ self: { ]; description = "Sass integration for Snap with request- and pre-compilation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-scoped-session" = callPackage @@ -243458,8 +228667,6 @@ self: { ]; description = "Modularised session state for Snaplets, in a Snaplet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-sedna" = callPackage @@ -243476,8 +228683,6 @@ self: { ]; description = "Snaplet for Sedna Bindings. Essentailly a rip of snaplet-hdbc."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-ses-html" = callPackage @@ -243494,8 +228699,6 @@ self: { ]; description = "Snaplet for the ses-html package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-sqlite-simple" = callPackage @@ -243526,8 +228729,6 @@ self: { ]; description = "sqlite-simple snaplet for the Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-sqlite-simple-jwt-auth" = callPackage @@ -243547,8 +228748,6 @@ self: { ]; description = "Snaplet for JWT authentication with snaplet-sqlite-simple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-stripe" = callPackage @@ -243567,8 +228766,6 @@ self: { ]; description = "Stripe snaplet for the Snap Framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-tasks" = callPackage @@ -243585,8 +228782,6 @@ self: { ]; description = "Snaplet for Snap Framework enabling developers to administrative tasks akin to Rake tasks from Ruby On Rails framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-typed-sessions" = callPackage @@ -243604,8 +228799,6 @@ self: { ]; description = "Typed session snaplets and continuation-based programming for the Snap web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snaplet-wordpress" = callPackage @@ -243632,8 +228825,6 @@ self: { ]; description = "A snaplet that communicates with wordpress over its api"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snappy" = callPackage @@ -243663,8 +228854,6 @@ self: { libraryHaskellDepends = [ base bytestring conduit snappy ]; description = "Conduit bindings for Snappy (see snappy package)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snappy-framing" = callPackage @@ -243687,8 +228876,6 @@ self: { libraryHaskellDepends = [ base bytestring iteratee snappy ]; description = "An enumeratee that uses Google's snappy compression library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snappy-lazy" = callPackage @@ -243721,8 +228908,6 @@ self: { ]; description = "Audio file reading/writing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sneakyterm" = callPackage @@ -243738,8 +228923,6 @@ self: { ]; description = "Tiny, declarative wrapper around ncurses"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sneathlane-haste" = callPackage @@ -243763,8 +228946,6 @@ self: { libraryHaskellDepends = [ base containers pandoc process text ]; description = "Markdown tester"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snippet-extractor" = callPackage @@ -243799,8 +228980,6 @@ self: { ]; description = "The Simple Nice-Looking Manual Generator"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snmp" = callPackage @@ -243819,8 +228998,6 @@ self: { ]; description = "SNMP protocol library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snorkels" = callPackage @@ -243843,8 +229020,6 @@ self: { ]; description = "Strategic board game of medium complexity"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snow-white" = callPackage @@ -243857,8 +229032,6 @@ self: { libraryHaskellDepends = [ base binary bytestring mps ]; description = "encode any binary instance to white space"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snowball" = callPackage @@ -243906,8 +229079,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "twitter's snowflake"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snowflake-server" = callPackage @@ -243926,8 +229097,6 @@ self: { ]; description = "snowflake http server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "snowglobe" = callPackage @@ -243961,8 +229130,6 @@ self: { ]; description = "snowtify send your result of `stack build` (`stack test`) to notify-daemon :dog2:"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "soap" = callPackage @@ -244082,8 +229249,6 @@ self: { libraryHaskellDepends = [ base network transformers unix ]; description = "systemd socket activation library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "socket-icmp" = callPackage @@ -244110,8 +229275,6 @@ self: { transformers unordered-containers vector ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "socket-sctp" = callPackage @@ -244125,8 +229288,6 @@ self: { testHaskellDepends = [ base bytestring socket ]; description = "STCP socket extensions library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) lksctp-tools;}; "socket-unix" = callPackage @@ -244143,8 +229304,6 @@ self: { ]; description = "Unix domain sockets"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "socketed" = callPackage @@ -244171,8 +229330,6 @@ self: { ]; description = "simpe tool to serve piped data over http and websocket"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "socketio" = callPackage @@ -244201,8 +229358,6 @@ self: { ]; description = "Socket.IO server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sockets" = callPackage @@ -244233,8 +229388,6 @@ self: { doHaddock = false; description = "High-level network sockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sockets-and-pipes" = callPackage @@ -244251,8 +229404,6 @@ self: { ]; description = "Support for the Sockets and Pipes book"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "socketson" = callPackage @@ -244278,8 +229429,6 @@ self: { ]; description = "A small websocket backend provider"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "socks" = callPackage @@ -244304,8 +229453,6 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Sodium Reactive Programming (FRP) System"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "soegtk" = callPackage @@ -244318,8 +229465,6 @@ self: { libraryHaskellDepends = [ base cairo gtk old-time stm ]; description = "GUI functions as used in the book \"The Haskell School of Expression\""; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "softfloat-hs" = callPackage @@ -244332,8 +229477,6 @@ self: { librarySystemDepends = [ softfloat ]; description = "Haskell bindings for SoftFloat"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {softfloat = null;}; "solar" = callPackage @@ -244370,8 +229513,6 @@ self: { ]; description = "Simple typesafe web routing"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "solga-swagger" = callPackage @@ -244389,8 +229530,6 @@ self: { ]; description = "Swagger generation for Solga"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "solr" = callPackage @@ -244415,8 +229554,6 @@ self: { ]; description = "A minimal Solr client library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "solve" = callPackage @@ -244464,8 +229601,6 @@ self: { ]; description = "Sonic Visualiser"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sop-core" = callPackage @@ -244536,8 +229671,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Efficient, type-safe sorted sequences"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sorted-list" = callPackage @@ -244573,8 +229706,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Utils for sorting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sorty" = callPackage @@ -244588,8 +229719,6 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Sort lines per file size"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "souffle-dsl" = callPackage @@ -244613,8 +229742,6 @@ self: { ]; description = "Haskell EDSL for Souffle"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "souffle-haskell" = callPackage @@ -244645,8 +229772,6 @@ self: { ]; description = "Souffle Datalog bindings for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sound-collage" = callPackage @@ -244669,8 +229794,6 @@ self: { ]; description = "Approximate a song from other pieces of sound"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sounddelay" = callPackage @@ -244684,8 +229807,6 @@ self: { executableHaskellDepends = [ base containers parseargs WAVE ]; description = "Audio delay line"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "soundgen" = callPackage @@ -244699,8 +229820,6 @@ self: { executableHaskellDepends = [ base split WAVE ]; description = "sound generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "source-code-server" = callPackage @@ -244724,8 +229843,6 @@ self: { ]; description = "The server backend for the source code iPhone app"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "source-constraints" = callPackage @@ -244784,8 +229901,6 @@ self: { ]; description = "Source/Sink/Transform: An alternative to lazy IO and iteratees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sox" = callPackage @@ -244841,8 +229956,6 @@ self: { ]; description = "DCPU-16 architecture utilities for Notch's 0x10c game"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "space" = callPackage @@ -244916,8 +230029,6 @@ self: { libraryHaskellDepends = [ base vector-space ]; description = "Space partition data structures. Currently only a QuadTree."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spaceprobe" = callPackage @@ -244962,8 +230073,6 @@ self: { ]; description = "Implementation of the SPAKE2 Password-Authenticated Key Exchange algorithm"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spanout" = callPackage @@ -244981,8 +230090,6 @@ self: { ]; description = "A breakout clone written in netwire and gloss"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sparkle" = callPackage @@ -245010,8 +230117,6 @@ self: { ]; description = "Distributed Apache Spark applications in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sparql-protocol" = callPackage @@ -245057,8 +230162,6 @@ self: { ]; description = "Unified streaming data-dependency framework for web apps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spars" = callPackage @@ -245070,8 +230173,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A sparse set-based parsing library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sparse" = callPackage @@ -245099,8 +230200,6 @@ self: { benchmarkHaskellDepends = [ array base criterion deepseq vector ]; description = "A playground of sparse linear algebra primitives using Morton ordering"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sparse-lin-alg" = callPackage @@ -245118,8 +230217,6 @@ self: { ]; description = "Effective linear algebra on sparse matrices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sparse-linear-algebra" = callPackage @@ -245175,8 +230272,6 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "Sparse bitmaps for pattern match coverage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sparsecheck" = callPackage @@ -245188,8 +230283,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A Logic Programming Library for Test-Data Generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sparser" = callPackage @@ -245205,8 +230298,6 @@ self: { ]; description = "Lightweight parsing library based on partial functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spartacon" = callPackage @@ -245237,8 +230328,6 @@ self: { libraryHaskellDepends = [ base dlist mps mtl ]; description = "brainless form validation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spatial-math" = callPackage @@ -245349,8 +230438,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Control.Applicative, Data.Foldable, Data.Traversable (compatibility package)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "special-keys" = callPackage @@ -245368,8 +230455,6 @@ self: { ]; description = "Simple data types that help me here and there"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "special-values" = callPackage @@ -245409,8 +230494,6 @@ self: { ]; description = "Create specialized types from polymorphic ones using TH"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "species" = callPackage @@ -245429,8 +230512,6 @@ self: { ]; description = "Computational combinatorial species"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spectral-clustering" = callPackage @@ -245448,8 +230529,6 @@ self: { ]; description = "Library for spectral clustering"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "speculate" = callPackage @@ -245476,8 +230555,6 @@ self: { libraryHaskellDepends = [ base ghc-prim stm transformers ]; description = "A framework for safe, programmable, speculative parallelism"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "speculation-transformers" = callPackage @@ -245490,8 +230567,6 @@ self: { doHaddock = false; description = "Merged into 'speculation'. Use that instead."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "speechmatics" = callPackage @@ -245522,8 +230597,6 @@ self: { ]; description = "Speechmatics api client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "speedy-slice" = callPackage @@ -245562,8 +230635,6 @@ self: { ]; description = "Spelling suggestion tool with library and command-line interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spherical" = callPackage @@ -245590,8 +230661,6 @@ self: { ]; description = "Orbotix Sphero client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sphinx" = callPackage @@ -245608,8 +230677,6 @@ self: { ]; description = "Haskell bindings to the Sphinx full-text searching daemon"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sphinx-cli" = callPackage @@ -245623,8 +230690,6 @@ self: { executableHaskellDepends = [ base sphinx ]; description = "Sphinx CLI and demo of Haskell Sphinx library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sphinxesc" = callPackage @@ -245643,8 +230708,6 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Transform queries for sphinx input"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spice" = callPackage @@ -245661,8 +230724,6 @@ self: { ]; description = "An FRP-based game engine written in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spike" = callPackage @@ -245706,8 +230767,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Some utilities for reading and writing SPIR-V files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spiros" = callPackage @@ -245734,8 +230793,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Spiros Boosalis's Custom Prelude"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "splay" = callPackage @@ -245747,8 +230804,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Generic splay-based sequence representation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "splaytree" = callPackage @@ -245766,8 +230821,6 @@ self: { ]; description = "Provides an annotated splay tree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "splice" = callPackage @@ -245802,8 +230855,6 @@ self: { ]; description = "A parallel implementation of the Sorokina/Zeilfelder spline scheme"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "splines" = callPackage @@ -245825,8 +230876,6 @@ self: { benchmarkHaskellDepends = [ base criterion polynomial vector ]; description = "B-Splines, other splines, and NURBS"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "splint" = callPackage @@ -245838,8 +230887,6 @@ self: { libraryHaskellDepends = [ base containers ghc hlint stm ]; description = "HLint as a GHC source plugin"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "split" = callPackage @@ -245877,8 +230924,6 @@ self: { testHaskellDepends = [ base invariant lens QuickCheck ]; description = "Split Epimorphisms and Monomorphisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "split-record" = callPackage @@ -245962,8 +231007,6 @@ self: { ]; description = "Use numerical ranges to split out certain lines from a file"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "splot" = callPackage @@ -246024,8 +231067,6 @@ self: { ]; description = "Spoon's utilities. Simple testing and nice looking error reporting."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spork" = callPackage @@ -246053,8 +231094,6 @@ self: { ]; description = "Spotify web API wrapper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spreadsheet" = callPackage @@ -246114,8 +231153,6 @@ self: { ]; description = "JSON API to HTML website wrapper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spritz" = callPackage @@ -246127,8 +231164,6 @@ self: { libraryHaskellDepends = [ base lens mtl vector ]; description = "An implementation of the Spritz RC4-like stream cipher in Haskell"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sproxy" = callPackage @@ -246153,8 +231188,6 @@ self: { ]; description = "HTTP proxy for authenticating users via OAuth2"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sproxy-web" = callPackage @@ -246180,8 +231213,6 @@ self: { ]; description = "Web interface to sproxy database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sproxy2" = callPackage @@ -246207,8 +231238,6 @@ self: { ]; description = "Secure HTTP proxy for authenticating users via OAuth2"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spsa" = callPackage @@ -246228,8 +231257,6 @@ self: { benchmarkHaskellDepends = [ base criterion hmatrix random ]; description = "Simultaneous Perturbation Stochastic Approximation Optimization Algorithm"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "spy" = callPackage @@ -246255,8 +231282,6 @@ self: { ]; description = "A compact file system watcher for Mac OS X, Linux and Windows"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sql-simple" = callPackage @@ -246273,8 +231298,6 @@ self: { ]; description = "common middle-level sql client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sql-simple-mysql" = callPackage @@ -246290,8 +231313,6 @@ self: { ]; description = "mysql backend for sql-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sql-simple-pool" = callPackage @@ -246308,8 +231329,6 @@ self: { ]; description = "conection pool for sql-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sql-simple-postgresql" = callPackage @@ -246325,8 +231344,6 @@ self: { ]; description = "postgresql backend for sql-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sql-simple-sqlite" = callPackage @@ -246338,8 +231355,6 @@ self: { libraryHaskellDepends = [ base sql-simple sqlite-simple ]; description = "sqlite backend for sql-simple"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sql-words" = callPackage @@ -246370,8 +231385,6 @@ self: { testHaskellDepends = [ base filepath hspec temporary ]; description = "Haskell binding to sqlcipher"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "sqlcli" = callPackage @@ -246412,8 +231425,6 @@ self: { testHaskellDepends = [ base ]; description = "Haskell binding to sqlite3"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) sqlite;}; "sqlite-simple" = callPackage @@ -246447,8 +231458,6 @@ self: { testHaskellDepends = [ base mtl sqlite-simple text ]; description = "Wrapper around errors from sqlite-simple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sqlite-simple-typed" = callPackage @@ -246465,8 +231474,6 @@ self: { ]; description = "Typed extension to sqlite simple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sqlvalue-list" = callPackage @@ -246478,8 +231485,6 @@ self: { libraryHaskellDepends = [ base convertible HDBC template-haskell ]; description = "Class and instances for conversion to list of SqlValue"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sqsd-local" = callPackage @@ -246501,8 +231506,6 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "squares" = callPackage @@ -246558,8 +231561,6 @@ self: { ]; description = "Squeal PostgreSQL Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "squeather" = callPackage @@ -246618,8 +231619,6 @@ self: { ]; description = "A file-packing application"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sr-extra" = callPackage @@ -246647,8 +231646,6 @@ self: { ]; description = "Module limbo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "srcinst" = callPackage @@ -246667,8 +231664,6 @@ self: { ]; description = "Build and install Debian packages completely from source"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "srcloc" = callPackage @@ -246709,8 +231704,6 @@ self: { ]; description = "text UI for scanning with SANE"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sscgi" = callPackage @@ -246728,8 +231721,6 @@ self: { ]; description = "Simple SCGI Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sscript" = callPackage @@ -246773,8 +231764,6 @@ self: { doCheck = false; description = "A pure-Haskell SSH server library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ssh-known-hosts" = callPackage @@ -246814,8 +231803,6 @@ self: { ]; description = "Proxy http-client via ssh tunnel"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sshd-lint" = callPackage @@ -246836,8 +231823,6 @@ self: { ]; description = "Check sshd configuration for adherence to best practices"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sshtun" = callPackage @@ -246885,8 +231870,6 @@ self: { ]; description = "HTTP proxy for S3"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sstable" = callPackage @@ -246905,8 +231888,6 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "SSTables in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ssv" = callPackage @@ -246932,8 +231913,6 @@ self: { libraryHaskellDepends = [ base gdp ghc-prim primitive ]; description = "shared heap regions between local mutable state threads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stable-heap" = callPackage @@ -246950,8 +231929,6 @@ self: { ]; description = "Purely functional stable heaps (fair priority queues)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stable-maps" = callPackage @@ -246963,8 +231940,6 @@ self: { libraryHaskellDepends = [ base containers ghc-prim ]; description = "Heterogeneous maps keyed by StableNames"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stable-marriage" = callPackage @@ -246977,8 +231952,6 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "algorithms around stable marriage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stable-memo" = callPackage @@ -246992,8 +231965,6 @@ self: { libraryHaskellDepends = [ base ghc-prim hashtables ]; description = "Memoization based on argument identity"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stable-tree" = callPackage @@ -247018,8 +231989,6 @@ self: { ]; description = "Trees whose branches are resistant to change"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stache" = callPackage @@ -247189,8 +232158,6 @@ self: { ]; description = "Dead simple version bumping for hpack packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-clean-old" = callPackage @@ -247221,8 +232188,6 @@ self: { executableHaskellDepends = [ base options text turtle ]; description = "Console program used to fix Stack build errors automatically"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-hpc-coveralls" = callPackage @@ -247249,8 +232214,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-lib" = callPackage @@ -247266,8 +232229,6 @@ self: { ]; description = "Wrapper to use stack as a library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-network" = callPackage @@ -247309,8 +232270,6 @@ self: { ]; description = "A program for extending Stack to add distributed capabilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-prism" = callPackage @@ -247329,8 +232288,6 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Stack prisms"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-run" = callPackage @@ -247350,8 +232307,6 @@ self: { ]; description = "An equivalent to cabal run for stack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-run-auto" = callPackage @@ -247379,8 +232334,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-tag" = callPackage @@ -247426,8 +232379,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "The basic stack type"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-wrapper" = callPackage @@ -247444,8 +232395,6 @@ self: { executableHaskellDepends = [ base filepath process ]; description = "Call ghc within stack by calling ghc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack-yaml" = callPackage @@ -247490,8 +232439,6 @@ self: { ]; description = "Convert stack projects to cabal.project + cabal.project.freeze"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stack2nix" = callPackage @@ -247518,8 +232465,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Convert stack.yaml files into Nix build instructions."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage" = callPackage @@ -247538,8 +232483,6 @@ self: { ]; description = "Dummy package forcing installation of other Stackage packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-build-plan" = callPackage @@ -247564,8 +232507,6 @@ self: { ]; description = "Calculate and print (in different formats) Stackage build plans"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-cabal" = callPackage @@ -247586,8 +232527,6 @@ self: { ]; description = "A CLI executable for cabal-based stackage commands"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-cli" = callPackage @@ -247609,8 +232548,6 @@ self: { executableHaskellDepends = [ base text ]; description = "A CLI library for stackage commands"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-curator" = callPackage @@ -247655,8 +232592,6 @@ self: { ]; description = "Tools for curating Stackage bundles"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-install" = callPackage @@ -247705,8 +232640,6 @@ self: { ]; description = "DEPRECATED Grab current metadata for all packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-query" = callPackage @@ -247730,8 +232663,6 @@ self: { ]; description = "Tool for querying Stackage"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-sandbox" = callPackage @@ -247752,8 +232683,6 @@ self: { ]; description = "Work with shared stackage sandboxes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-setup" = callPackage @@ -247777,8 +232706,6 @@ self: { ]; description = "An executable for downloading a Haskell setup"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-to-hackage" = callPackage @@ -247804,8 +232731,6 @@ self: { ]; description = "Convert stack.yaml to cabal.project + cabal.project.freeze"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-types" = callPackage @@ -247825,8 +232750,6 @@ self: { ]; description = "Shared data types between various Stackage packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage-update" = callPackage @@ -247863,8 +232786,6 @@ self: { ]; description = "A more secure version of cabal upload which uses HTTPS"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackage2nix" = callPackage @@ -247895,8 +232816,6 @@ self: { ]; description = "Convert Stack files into Nix build instructions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stackcollapse-ghc" = callPackage @@ -247920,8 +232839,6 @@ self: { ]; description = "Program to fold GHC prof files into flamegraph input"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stacked-dag" = callPackage @@ -247969,8 +232886,6 @@ self: { ]; description = "GHC.Generics style staged generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stagen" = callPackage @@ -248036,8 +232951,6 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "This package will derive class instance along the data type declaration tree. (Deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "standalone-haddock" = callPackage @@ -248055,8 +232968,6 @@ self: { ]; description = "Generate standalone haddock documentation for a set of packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "star" = callPackage @@ -248105,8 +233016,6 @@ self: { ]; description = "A memcached client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "starrover2" = callPackage @@ -248153,8 +233062,6 @@ self: { ]; description = "To be written"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "state" = callPackage @@ -248166,8 +233073,6 @@ self: { libraryHaskellDepends = [ arrows base mtl ]; description = "Data.State"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "state-bag" = callPackage @@ -248184,8 +233089,6 @@ self: { testHaskellDepends = [ base hspec transformers ]; description = "Monad transformers for holding bags of state"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "state-codes" = callPackage @@ -248211,8 +233114,6 @@ self: { testHaskellDepends = [ base checkers mtl QuickCheck ]; description = "MonadPlus for StateT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "state-record" = callPackage @@ -248224,8 +233125,6 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Better records for State monad states"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stateWriter" = callPackage @@ -248268,8 +233167,6 @@ self: { libraryHaskellDepends = [ base MaybeT mtl ]; description = "Typeclass instances for monad transformer stacks with an ST thread at the bottom"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stateref" = callPackage @@ -248357,8 +233254,6 @@ self: { libraryHaskellDepends = [ base double-conversion free mtl text ]; description = "DSL to generate HTML5 Canvas javascript"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "static-closure" = callPackage @@ -248375,8 +233270,6 @@ self: { ]; description = "Serialisable static pointers to functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "static-hash" = callPackage @@ -248432,8 +233325,6 @@ self: { ]; description = "Tensors of statically known size"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "static-text" = callPackage @@ -248455,8 +233346,6 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Lists, Texts, ByteStrings and Vectors of statically known length"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "staticanalysis" = callPackage @@ -248509,8 +233398,6 @@ self: { ]; description = "Functions for working with Dirichlet densities and mixtures on vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "statistics-fusion" = callPackage @@ -248522,8 +233409,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "An implementation of high performance, minimal statistics functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "statistics-hypergeometric-genvar" = callPackage @@ -248539,8 +233424,6 @@ self: { ]; description = "Random variate generation from hypergeometric distributions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "statistics-linreg" = callPackage @@ -248594,8 +233477,6 @@ self: { executableHaskellDepends = [ base statistics text vector ]; description = "command line statistics"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "statsd" = callPackage @@ -248611,8 +233492,6 @@ self: { ]; description = "StatsD API"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "statsd-client" = callPackage @@ -248630,8 +233509,6 @@ self: { ]; description = "Statsd UDP client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "statsd-datadog" = callPackage @@ -248670,8 +233547,6 @@ self: { ]; description = "A lovely [Dog]StatsD implementation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "status-notifier-item" = callPackage @@ -248706,8 +233581,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Get unix filesystem statistics with statfs, statvfs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "staversion" = callPackage @@ -248761,7 +233634,6 @@ self: { description = "Image loading and writing microlibrary"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stb-image-redux" = callPackage @@ -248774,8 +233646,6 @@ self: { testHaskellDepends = [ base hspec vector ]; description = "Image loading and writing microlibrary"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stb-truetype" = callPackage @@ -248820,8 +233690,6 @@ self: { ]; description = "A library for implicit, monadic dataflow parallelism"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "std" = callPackage @@ -248844,8 +233712,6 @@ self: { libraryHaskellDepends = [ base parsec syb template-haskell ]; description = "Structure Data Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stdf" = callPackage @@ -248868,8 +233734,6 @@ self: { ]; description = "Parse Structured Test Data Format (STDF)"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stdio" = callPackage @@ -248895,8 +233759,6 @@ self: { ]; description = "A simple and high performance IO toolkit for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libuv;}; "steambrowser" = callPackage @@ -248910,8 +233772,6 @@ self: { executableHaskellDepends = [ base directory parsec transformers ]; description = "List and launch steam games from the cli"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "steeloverseer" = callPackage @@ -248955,8 +233815,6 @@ self: { testHaskellDepends = [ base random uuid ]; description = "Generator and verifier for steganographic numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stemmer" = callPackage @@ -248968,8 +233826,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell bindings to the Snowball stemming library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stemmer-german" = callPackage @@ -248983,8 +233839,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "Extract the stem of a German inflected word form"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "step-function" = callPackage @@ -249013,8 +233867,6 @@ self: { sha256 = "059k8g3wb4hkxk42vm83vv6kh3igrpf7fc97xvn3qai5rx3jmgqf"; libraryHaskellDepends = [ base containers mtl ]; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stern-brocot" = callPackage @@ -249032,8 +233884,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Positive rational numbers represented as paths in the Stern-Brocot tree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stgi" = callPackage @@ -249062,8 +233912,6 @@ self: { ]; description = "Educational implementation of the STG (Spineless Tagless G-machine)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stickyKeysHotKey" = callPackage @@ -249159,8 +234007,6 @@ self: { testHaskellDepends = [ async base HUnit stm tasty tasty-hunit ]; description = "Chunked Communication Queues"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stm-conduit" = callPackage @@ -249248,8 +234094,6 @@ self: { testHaskellDepends = [ base hspec HUnit stm ]; description = "Conduits and STM operations for fire hoses"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stm-hamt" = callPackage @@ -249344,8 +234188,6 @@ self: { testHaskellDepends = [ base QuickCheck stm ]; description = "Simple STM Promises for IO computations and external processes"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stm-queue" = callPackage @@ -249408,8 +234250,6 @@ self: { ]; description = "retry statistics for STM transactions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stm-supply" = callPackage @@ -249447,8 +234287,6 @@ self: { libraryHaskellDepends = [ base haskell98 mtl stm ]; description = "Control communication among retrying transactions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stochastic" = callPackage @@ -249464,8 +234302,6 @@ self: { ]; description = "Monadic composition of probabilistic functions and sampling"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stocks" = callPackage @@ -249483,8 +234319,6 @@ self: { testHaskellDepends = [ base bytestring HUnit ]; description = "Library for the IEX Trading API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stomp-conduit" = callPackage @@ -249570,8 +234404,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Storable type class for variable-sized data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "storable-complex" = callPackage @@ -249633,8 +234465,6 @@ self: { libraryHaskellDepends = [ array base tagged vector ]; description = "Statically-sized array wrappers with Storable instances for FFI marshaling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "storable-tuple" = callPackage @@ -249697,8 +234527,6 @@ self: { ]; description = "Conversion between storablevector and stream-fusion lists with fusion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "store" = callPackage @@ -249798,8 +234626,6 @@ self: { executableHaskellDepends = [ base regex-compat ]; description = "Simple Theorem Prover"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "str" = callPackage @@ -249816,8 +234642,6 @@ self: { ]; description = "A type class to abstract between many different string types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stratosphere" = callPackage @@ -249862,8 +234686,6 @@ self: { ]; description = "Client for Stratum protocol"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stratux" = callPackage @@ -249879,8 +234701,6 @@ self: { ]; description = "A library for stratux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stratux-demo" = callPackage @@ -249903,8 +234723,6 @@ self: { ]; description = "A demonstration of the stratux library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stratux-http" = callPackage @@ -249920,8 +234738,6 @@ self: { ]; description = "A library for using HTTP with stratux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stratux-types" = callPackage @@ -249937,8 +234753,6 @@ self: { ]; description = "A library for reading JSON output from stratux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stratux-websockets" = callPackage @@ -249955,8 +234769,6 @@ self: { ]; description = "A library for using websockets with stratux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stream" = callPackage @@ -249976,8 +234788,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stream-fusion" = callPackage @@ -249991,8 +234801,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Faster Haskell lists using stream fusion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stream-monad" = callPackage @@ -250006,8 +234814,6 @@ self: { libraryHaskellDepends = [ base logict ]; description = "Simple, Fair and Terminating Backtracking Monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streamdeck" = callPackage @@ -250019,8 +234825,6 @@ self: { libraryHaskellDepends = [ base bytestring hidapi mtl split ]; description = "Control library for the Elgato Stream Deck"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streamed" = callPackage @@ -250039,8 +234843,6 @@ self: { ]; description = "Programmatically edit MIDI event streams via ALSA"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming" = callPackage @@ -250096,8 +234898,6 @@ self: { ]; description = "Streaming conversion from/to base64"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-benchmarks" = callPackage @@ -250123,8 +234923,6 @@ self: { ]; description = "Benchmarks to compare streaming packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-binary" = callPackage @@ -250180,8 +234978,6 @@ self: { ]; description = "Streaming interface for Brotli (RFC7932) compression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-bytestring" = callPackage @@ -250224,8 +235020,6 @@ self: { ]; description = "Cassava support for the streaming ecosystem"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-commons" = callPackage @@ -250272,8 +235066,6 @@ self: { ]; description = "Concurrency support for the streaming ecosystem"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-conduit" = callPackage @@ -250290,8 +235082,6 @@ self: { testHaskellDepends = [ base conduit hspec streaming ]; description = "Bidirectional support between the streaming and conduit libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-events" = callPackage @@ -250308,8 +235098,6 @@ self: { ]; description = "Client-side consumption of a ServerEvent"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-eversion" = callPackage @@ -250345,8 +235133,6 @@ self: { ]; description = "online streaming fft"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-histogram" = callPackage @@ -250383,8 +235169,6 @@ self: { ]; description = "Streaming interface for LZMA/XZ compression"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-nonempty" = callPackage @@ -250419,8 +235203,6 @@ self: { ]; description = "A hand-written streaming byte parser for OpenStreetMap Protobuf data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-pcap" = callPackage @@ -250442,8 +235224,6 @@ self: { ]; description = "Stream packets via libpcap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-png" = callPackage @@ -250464,8 +235244,6 @@ self: { ]; description = "Perfectly streaming PNG image decoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-postgresql-simple" = callPackage @@ -250507,8 +235285,6 @@ self: { ]; description = "Streaming support for running system process"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-sort" = callPackage @@ -250530,8 +235306,6 @@ self: { ]; description = "Sorting streams"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-utils" = callPackage @@ -250553,8 +235327,6 @@ self: { ]; description = "http, attoparsec, pipes and other utilities for the streaming libraries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streaming-wai" = callPackage @@ -250588,8 +235360,6 @@ self: { ]; description = "with/bracket-style idioms for use with streaming"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streamly" = callPackage @@ -250717,8 +235487,6 @@ self: { ]; description = "Folder watching as a Streamly stream"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streamly-lmdb" = callPackage @@ -250772,8 +235540,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Stream Processer Arrow"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "streams" = callPackage @@ -250810,8 +235576,6 @@ self: { ]; description = "A simple, flexible and composable web-router"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strelka-core" = callPackage @@ -250888,8 +235652,6 @@ self: { ]; description = "Strict variants of the types provided in base"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strict-concurrency" = callPackage @@ -250979,8 +235741,6 @@ self: { ]; description = "A collection of commonly used strict data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strict-ghc-plugin" = callPackage @@ -250992,8 +235752,6 @@ self: { libraryHaskellDepends = [ base ghc syb ]; description = "Compiler plugin for making Haskell strict"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strict-identity" = callPackage @@ -251084,8 +235842,6 @@ self: { libraryHaskellDepends = [ base lens strict-tuple ]; description = "Optics for the `strict-tuple` library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strict-tuple-lens_0_2" = callPackage @@ -251098,7 +235854,6 @@ self: { description = "Optics for the `strict-tuple` library"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strict-types" = callPackage @@ -251153,8 +235908,6 @@ self: { libraryHaskellDepends = [ base deepseq ]; description = "Combinators for strictifying functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "string" = callPackage @@ -251286,8 +236039,6 @@ self: { ]; description = "Tools for working with isomorphisms of strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "string-like" = callPackage @@ -251323,8 +236074,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "QuasiQuoter for non-interpolated strings, texts and bytestrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "string-random" = callPackage @@ -251394,8 +236143,6 @@ self: { ]; description = "Type-level Chars and Strings, with decidable equality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stringable" = callPackage @@ -251436,8 +236183,6 @@ self: { ]; description = "Transformations to several string-like types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stringprep" = callPackage @@ -251490,8 +236235,6 @@ self: { libraryHaskellDepends = [ base binary bytestring containers syb ]; description = "Memoize Strings as Atoms for fast comparison and sorting, with maps and sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strio" = callPackage @@ -251537,8 +236280,6 @@ self: { ]; description = "A Haskell implementation of the Stripe API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stripe-concepts" = callPackage @@ -251602,8 +236343,6 @@ self: { ]; description = "Unofficial Stripe client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stripe-http-client" = callPackage @@ -251643,8 +236382,6 @@ self: { doCheck = false; description = "Stripe API for Haskell - http-streams backend"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stripe-scotty" = callPackage @@ -251661,8 +236398,6 @@ self: { ]; description = "Listen for Stripe webhook events with Scotty"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stripe-servant" = callPackage @@ -251696,8 +236431,6 @@ self: { testHaskellDepends = [ base bytestring text ]; description = "Verification of Stripe webhook signatures"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stripe-tests" = callPackage @@ -251731,8 +236464,6 @@ self: { ]; description = "Use the Stripe API via Wreq"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stripeapi" = callPackage @@ -251812,8 +236543,6 @@ self: { ]; description = "Interface library for strongSwan SQL backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "strptime" = callPackage @@ -251864,8 +236593,6 @@ self: { ]; description = "Instantiate structural induction schemas for algebraic data types"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "structural-traversal" = callPackage @@ -251878,8 +236605,6 @@ self: { testHaskellDepends = [ base HUnit mtl ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "structured" = callPackage @@ -251956,8 +236681,6 @@ self: { ]; description = "Structured MongoDB interface"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "structures" = callPackage @@ -251988,8 +236711,6 @@ self: { ]; description = "\"Advanced\" Data Structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stt" = callPackage @@ -252006,8 +236727,6 @@ self: { ]; description = "A monad transformer version of the ST monad"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stunclient" = callPackage @@ -252031,8 +236750,6 @@ self: { ]; description = "RFC 5389: Session Traversal Utilities for NAT (STUN) client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stunts" = callPackage @@ -252053,8 +236770,6 @@ self: { ]; description = "A revival of the classic game Stunts (LambdaCube tech demo)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stutter" = callPackage @@ -252082,8 +236797,6 @@ self: { ]; description = "(Stutter Text|String)-Utterer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stylish-cabal" = callPackage @@ -252110,8 +236823,6 @@ self: { doHaddock = false; description = "Format Cabal files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stylish-haskell" = callPackage @@ -252165,8 +236876,6 @@ self: { ]; description = "Apply CSS styles to a document tree"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "stylized" = callPackage @@ -252178,8 +236887,6 @@ self: { libraryHaskellDepends = [ ansi-terminal base ]; description = "Ways to output stylized text on ANSI consoles"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "styx" = callPackage @@ -252219,8 +236926,6 @@ self: { ]; description = "An applicative functor that seamlessly talks to HTML inputs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sub-state" = callPackage @@ -252238,8 +236943,6 @@ self: { ]; description = "Get the total, put a single element"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "subG" = callPackage @@ -252317,8 +237020,6 @@ self: { benchmarkHaskellDepends = [ base criterion MonadRandom ]; description = "Type safe interface for programming in subcategories of Hask"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "subleq-toolchain" = callPackage @@ -252340,8 +237041,6 @@ self: { ]; description = "Toolchain of subleq computer"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sublists" = callPackage @@ -252374,8 +237073,6 @@ self: { ]; description = "Extract a part from CommonMark/Markdown docs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "subnet" = callPackage @@ -252405,8 +237102,6 @@ self: { ]; description = "Subsample data"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "substring-parser" = callPackage @@ -252425,8 +237120,6 @@ self: { ]; description = "Match / replace substrings with a parser combinators"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "subtitleParser" = callPackage @@ -252463,8 +237156,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Subword graph implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "subzero" = callPackage @@ -252503,8 +237194,6 @@ self: { libraryHaskellDepends = [ base ]; description = "An applicative functor to manage successors"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "suffix-array" = callPackage @@ -252525,8 +237214,6 @@ self: { benchmarkHaskellDepends = [ base criterion random ]; description = "Simple and moderately efficient suffix array implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "suffixarray" = callPackage @@ -252541,8 +237228,6 @@ self: { executableHaskellDepends = [ base HUnit ]; description = "n log n implementation of suffix array"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "suffixtree" = callPackage @@ -252567,8 +237252,6 @@ self: { executableHaskellDepends = [ base process ]; description = "Library-based syntactic extensibility for Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "suitable" = callPackage @@ -252580,8 +237263,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Abstract over the constraints on the parameters to type constructors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sum-type-boilerplate" = callPackage @@ -252633,8 +237314,6 @@ self: { ]; description = "Tool for scaffolding fully configured batteries-included production-level Haskell projects"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "summoner-tui" = callPackage @@ -252654,8 +237333,6 @@ self: { executableHaskellDepends = [ base relude ]; description = "Tool for scaffolding fully configured batteries-included production-level Haskell projects using TUI"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sump" = callPackage @@ -252673,8 +237350,6 @@ self: { ]; description = "A Haskell interface to SUMP-compatible logic analyzers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sundown" = callPackage @@ -252702,8 +237377,6 @@ self: { ]; description = "Test Cabalized package against multiple dependency versions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sunroof-compiler" = callPackage @@ -252721,8 +237394,6 @@ self: { ]; description = "Monadic Javascript Compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sunroof-examples" = callPackage @@ -252744,8 +237415,6 @@ self: { ]; description = "Tests for Sunroof"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sunroof-server" = callPackage @@ -252767,8 +237436,6 @@ self: { ]; description = "Monadic Javascript Compiler - Server Utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "super-user-spark" = callPackage @@ -252798,8 +237465,6 @@ self: { ]; description = "Configure your dotfile deployment with a DSL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "superbubbles" = callPackage @@ -252814,8 +237479,6 @@ self: { testHaskellDepends = [ base containers hspec ]; description = "Find \"superbubbles\", as described in https://arxiv.org/abs/1307.7925"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "superbuffer" = callPackage @@ -252850,8 +237513,6 @@ self: { ]; description = "Haskell SuperCollider utilities"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "supercollider-midi" = callPackage @@ -252874,8 +237535,6 @@ self: { ]; description = "Demonstrate how to control SuperCollider via ALSA-MIDI"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "superconstraints" = callPackage @@ -252892,8 +237551,6 @@ self: { ]; description = "Access an instance's constraints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "superdoc" = callPackage @@ -252933,8 +237590,6 @@ self: { ]; description = "A simple opinionated event store implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "supermonad" = callPackage @@ -252951,8 +237606,6 @@ self: { testHaskellDepends = [ base containers ghc QuickCheck ]; description = "Plugin and base library to support supermonads in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "supernova" = callPackage @@ -252973,8 +237626,6 @@ self: { testHaskellDepends = [ aeson async base bytestring streamly text ]; description = "Apache Pulsar client for Haskell"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "supero" = callPackage @@ -252993,8 +237644,6 @@ self: { ]; description = "A Supercompiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "superrecord" = callPackage @@ -253027,8 +237676,6 @@ self: { ]; description = "Control an internal monad execution for trace generation, backtrakcking, testing and other purposes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "supervisors" = callPackage @@ -253063,8 +237710,6 @@ self: { ]; description = "Early termination for monads"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "surjective" = callPackage @@ -253076,8 +237721,6 @@ self: { libraryHaskellDepends = [ base lens mtl template-haskell ]; description = "An output coverage checker"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "suspend" = callPackage @@ -253117,8 +237760,6 @@ self: { ]; description = "Encode and decode separated values (CSV, PSV, ...)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sv-cassava" = callPackage @@ -253140,8 +237781,6 @@ self: { ]; description = "Integration to use sv with cassava's parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sv-core" = callPackage @@ -253169,8 +237808,6 @@ self: { ]; description = "Encode and decode separated values (CSV, PSV, ...)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sv-svfactor" = callPackage @@ -253188,8 +237825,6 @@ self: { ]; description = "sv-core + svfactor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svfactor" = callPackage @@ -253215,8 +237850,6 @@ self: { ]; description = "Syntax-preserving CSV manipulation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svg-builder" = callPackage @@ -253249,8 +237882,6 @@ self: { ]; description = "DSL for building SVG"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svg-tree" = callPackage @@ -253287,8 +237918,6 @@ self: { ]; description = "Code generation tool for Quartz code from a SVG"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svgcairo" = callPackage @@ -253305,8 +237934,6 @@ self: { libraryPkgconfigDepends = [ librsvg ]; description = "Binding to the libsvg-cairo library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) librsvg;}; "svgone" = callPackage @@ -253330,8 +237957,6 @@ self: { ]; description = "Optimise SVGs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svgutils" = callPackage @@ -253346,8 +237971,6 @@ self: { executableHaskellDepends = [ base filepath xml ]; description = "Helper functions for dealing with SVG files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svm" = callPackage @@ -253372,8 +237995,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring containers ]; description = "Parsers and formatters for the SVMlight input file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svm-simple" = callPackage @@ -253390,8 +238011,6 @@ self: { ]; description = "Medium level, simplified, bindings to libsvm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "svndump" = callPackage @@ -253410,8 +238029,6 @@ self: { ]; description = "Library for reading Subversion dump files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "swagger" = callPackage @@ -253456,8 +238073,6 @@ self: { ]; description = "Auto-generated openapi-petstore API Client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "swagger-test" = callPackage @@ -253487,8 +238102,6 @@ self: { ]; description = "Testing of Swagger APIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "swagger2" = callPackage @@ -253540,8 +238153,6 @@ self: { librarySystemDepends = [ tokyocabinet ]; description = "Transparently swapping data from in-memory structures to disk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) tokyocabinet;}; "swearjure" = callPackage @@ -253561,8 +238172,6 @@ self: { ]; description = "Clojure without alphanumerics"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sweet-egison" = callPackage @@ -253585,8 +238194,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Shallow embedding implementation of non-linear pattern matching"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "swf" = callPackage @@ -253598,8 +238205,6 @@ self: { libraryHaskellDepends = [ base mtl pretty ]; description = "A library for creating Shockwave Flash (SWF) files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "swift-lda" = callPackage @@ -253615,8 +238220,6 @@ self: { ]; description = "Online sampler for Latent Dirichlet Allocation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "swish" = callPackage @@ -253656,8 +238259,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell bindings for the Swiss Ephemeris C library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "swisstable" = callPackage @@ -253697,8 +238298,6 @@ self: { ]; description = "Nintendo Switch Controller Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sws" = callPackage @@ -253722,8 +238321,6 @@ self: { ]; description = "A simple web server for serving directories"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sxml" = callPackage @@ -253762,8 +238359,6 @@ self: { libraryHaskellDepends = [ base eq prelude-extras ]; description = "Higher order versions of the Scrap Your Boilerplate classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syb-with-class" = callPackage @@ -253791,8 +238386,6 @@ self: { libraryHaskellDepends = [ base syb-with-class text ]; description = "Scrap Your Boilerplate With Class Text instance"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sydtest" = callPackage @@ -253946,8 +238539,6 @@ self: { ]; description = "Synthesis Format Conversion Tool / Library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sylvia" = callPackage @@ -253973,8 +238564,6 @@ self: { ]; description = "Lambda calculus visualization"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sym" = callPackage @@ -253987,8 +238576,6 @@ self: { testHaskellDepends = [ base hashable QuickCheck ]; description = "Permutations, patterns, and statistics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sym-plot" = callPackage @@ -254000,8 +238587,6 @@ self: { libraryHaskellDepends = [ base diagrams-cairo diagrams-lib sym ]; description = "Plot permutations; an addition to the sym package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic" = callPackage @@ -254018,8 +238603,6 @@ self: { ]; description = "Library for Typed Tagless-Final Higher-Order Composable DSL"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-atom" = callPackage @@ -254041,8 +238624,6 @@ self: { ]; description = "Library for reading and writing Atom"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-base" = callPackage @@ -254070,8 +238651,6 @@ self: { ]; description = "Symantics for parsing and documenting a CLI"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-document" = callPackage @@ -254120,8 +238699,6 @@ self: { ]; description = "Symantic combinators for deriving clients or a server from an HTTP API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-http-client" = callPackage @@ -254140,8 +238717,6 @@ self: { ]; description = "symantic-http applied to the derivation of HTTP clients"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-http-demo" = callPackage @@ -254168,8 +238743,6 @@ self: { ]; description = "Demo for symantic-http and its companion libraries"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-http-pipes" = callPackage @@ -254191,8 +238764,6 @@ self: { ]; description = "Streaming support through pipes for symantic-http"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-http-server" = callPackage @@ -254211,8 +238782,6 @@ self: { ]; description = "symantic-http applied to the derivation of HTTP servers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-http-test" = callPackage @@ -254240,8 +238809,6 @@ self: { ]; description = "Test symantic-http and its companion libraries"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-lib" = callPackage @@ -254264,8 +238831,6 @@ self: { ]; description = "Symantics for common types"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-parser" = callPackage @@ -254289,8 +238854,6 @@ self: { ]; description = "Parser combinators statically optimized and staged via typed meta-programming"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symantic-xml" = callPackage @@ -254314,8 +238877,6 @@ self: { ]; description = "Library for reading, validating and writing XML"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symbiote" = callPackage @@ -254347,8 +238908,6 @@ self: { ]; description = "Data serialization, communication, and operation verification implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symbol" = callPackage @@ -254374,8 +238933,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit unix ]; description = "Symlink functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symbols" = callPackage @@ -254402,8 +238959,6 @@ self: { testSystemDepends = [ gmp gmpxx symengine ]; description = "SymEngine symbolic mathematics engine for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gmp; inherit (pkgs) gmpxx; inherit (pkgs) symengine;}; @@ -254422,8 +238977,6 @@ self: { testSystemDepends = [ gmp gmpxx symengine ]; description = "SymEngine symbolic mathematics engine for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) gmp; inherit (pkgs) gmpxx; inherit (pkgs) symengine;}; @@ -254453,8 +239006,6 @@ self: { ]; description = "Derivation of symbols and coordinate triplets Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "symon" = callPackage @@ -254481,8 +239032,6 @@ self: { libraryHaskellDepends = [ base stm ]; description = "A fast implementation of synchronous channels with a CML-like API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sync-mht" = callPackage @@ -254520,8 +239069,6 @@ self: { ]; description = "Fast incremental file transfer using Merkle-Hash-Trees"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "synchronous-channels" = callPackage @@ -254560,8 +239107,6 @@ self: { ]; description = "Haskell bindings for the Syncthing REST API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "synt" = callPackage @@ -254610,8 +239155,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Generic representation and manipulation of abstract syntax"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntactical" = callPackage @@ -254640,8 +239183,6 @@ self: { ]; description = "Reversible parsing and pretty-printing"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntax-attoparsec" = callPackage @@ -254657,8 +239198,6 @@ self: { ]; description = "Syntax instances for Attoparsec"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntax-example" = callPackage @@ -254677,8 +239216,6 @@ self: { ]; description = "Example application using syntax, a library for abstract syntax descriptions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntax-example-json" = callPackage @@ -254697,8 +239234,6 @@ self: { ]; description = "Example JSON parser/pretty-printer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntax-pretty" = callPackage @@ -254713,8 +239248,6 @@ self: { ]; description = "Syntax instance for pretty, the pretty printing library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntax-printer" = callPackage @@ -254731,8 +239264,6 @@ self: { ]; description = "Text and ByteString printers for 'syntax'"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntax-trees" = callPackage @@ -254748,8 +239279,6 @@ self: { ]; description = "Convert between different Haskell syntax trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntax-trees-fork-bairyn" = callPackage @@ -254765,8 +239294,6 @@ self: { ]; description = "Convert between different Haskell syntax trees. Bairyn's fork."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syntaxnet-haskell" = callPackage @@ -254785,8 +239312,6 @@ self: { testHaskellDepends = [ aeson base cassava haskell-conll hspec ]; description = "Working with Google's SyntaxNet output files - CoNLL, Tree"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "synthesizer" = callPackage @@ -254808,8 +239333,6 @@ self: { ]; description = "Audio signal processing coded in Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "synthesizer-alsa" = callPackage @@ -254951,8 +239474,6 @@ self: { doHaddock = false; description = "Efficient signal processing using runtime compilation"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "synthesizer-midi" = callPackage @@ -255012,8 +239533,6 @@ self: { ]; description = "A replacement for System.Exit and System.Process."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sysinfo" = callPackage @@ -255053,8 +239572,6 @@ self: { testHaskellDepends = [ base basic-prelude chell system-filepath ]; description = "Abstract data type for canonical paths with some utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-command" = callPackage @@ -255073,8 +239590,6 @@ self: { ]; description = "A replacement for System.Exit and System.Process"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-error" = callPackage @@ -255100,8 +239615,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "A bunch of system utilities used by other projects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-fileio" = callPackage @@ -255173,8 +239686,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Binding to Linux's inotify interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-lifted" = callPackage @@ -255197,8 +239708,6 @@ self: { ]; description = "Lifted versions of System functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-linux-proc" = callPackage @@ -255215,8 +239724,6 @@ self: { testHaskellDepends = [ base directory hedgehog pretty-show ]; description = "A library for accessing the /proc filesystem in Linux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-locale" = callPackage @@ -255233,8 +239740,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Get system locales"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-posix-redirect" = callPackage @@ -255272,8 +239777,6 @@ self: { ]; description = "Random number generation for extensible effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "system-test" = callPackage @@ -255379,8 +239882,6 @@ self: { ]; description = "An application that regularly logs system stats for later analysis"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "syz" = callPackage @@ -255409,8 +239910,6 @@ self: { ]; description = "Matchers and grammars using tree regular expressions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "t3-client" = callPackage @@ -255422,8 +239921,6 @@ self: { libraryHaskellDepends = [ base t3-game t3-server ]; description = "tic-tac-toe Rexports for client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "t3-game" = callPackage @@ -255459,8 +239956,6 @@ self: { ]; description = "tic-tac-toe server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ta" = callPackage @@ -255476,8 +239971,6 @@ self: { ]; description = "Transito Abierto: convenience library when using Takusen and Oracle"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tabl" = callPackage @@ -255507,8 +240000,6 @@ self: { ]; description = "Simple tool to generate tables from DSV input"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "table-layout" = callPackage @@ -255533,8 +240024,6 @@ self: { ]; description = "Format tabular data as grid or table"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "table-tennis" = callPackage @@ -255546,8 +240035,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A table tennis game tracking engine"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tableaux" = callPackage @@ -255565,8 +240052,6 @@ self: { ]; description = "An interactive theorem prover based on semantic tableaux"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tables" = callPackage @@ -255590,8 +240075,6 @@ self: { ]; description = "In-memory storage with multiple keys using lenses and traversals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tablestorage" = callPackage @@ -255612,8 +240095,6 @@ self: { ]; description = "Azure Table Storage REST API Wrapper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tablize" = callPackage @@ -255650,8 +240131,6 @@ self: { ]; description = "View the output of shell commands in a table"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tabs" = callPackage @@ -255666,8 +240145,6 @@ self: { executableHaskellDepends = [ base filepath monadlist mtl tagged ]; description = "Indents source files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tabular" = callPackage @@ -255737,8 +240214,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Provides access to the dynamic pointer tagging bits used by GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tag-stream" = callPackage @@ -255754,8 +240229,6 @@ self: { ]; description = "streamlined html tag parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagchup" = callPackage @@ -255822,8 +240295,6 @@ self: { ]; description = "Reflect exceptions using phantom types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagged-identity" = callPackage @@ -255854,8 +240325,6 @@ self: { ]; description = "Lists tagged with a type-level natural number representing their length"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagged-th" = callPackage @@ -255869,8 +240338,6 @@ self: { ]; description = "QuasiQuoter and Template Haskell splices for creating proxies at higher-kinds"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagged-timers" = callPackage @@ -255884,8 +240351,6 @@ self: { ]; description = "Simple wrappers for timing IO actions (single-threaded)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagged-transformer" = callPackage @@ -255988,8 +240453,6 @@ self: { libraryPkgconfigDepends = [ taglib ]; description = "An FFI layer over TagLib's C bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) taglib;}; "tagset-positional" = callPackage @@ -256055,8 +240518,6 @@ self: { ]; description = "alternative parser for the tagsoup package"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagsoup-megaparsec" = callPackage @@ -256073,8 +240534,6 @@ self: { ]; description = "A Tag token parser and Tag specific parsing combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagsoup-navigate" = callPackage @@ -256092,8 +240551,6 @@ self: { ]; description = "Tagsoup Navigate"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagsoup-parsec" = callPackage @@ -256105,8 +240562,6 @@ self: { libraryHaskellDepends = [ base parsec tagsoup ]; description = "Tokenizes Tag, so [ Tag ] can be used as parser input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagsoup-selection" = callPackage @@ -256118,8 +240573,6 @@ self: { libraryHaskellDepends = [ base containers parsec tagsoup ]; description = "Selecting subtrees from TagSoup's TagTrees using CSS selectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagstew" = callPackage @@ -256140,8 +240593,6 @@ self: { ]; description = "Black magic tagsoup"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tagstream-conduit" = callPackage @@ -256179,8 +240630,6 @@ self: { ]; description = "Support library to enable TAI usage on systems with time kept in UTC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tai64" = callPackage @@ -256199,8 +240648,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Tai64 Labels for Haskell"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tailfile-hinotify" = callPackage @@ -256273,8 +240720,6 @@ self: { libraryHaskellDepends = [ base lens monad-skeleton mtl ]; description = "create slide for presentation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "takusen-oracle" = callPackage @@ -256289,8 +240734,6 @@ self: { librarySystemDepends = [ clntsh ]; description = "Database library with left-fold interface for Oracle"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {clntsh = null;}; "tal" = callPackage @@ -256306,8 +240749,6 @@ self: { ]; description = "An implementation of Typed Assembly Language (Morrisett, Walker, Crary, Glew)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tamarin-prover" = callPackage @@ -256337,8 +240778,6 @@ self: { ]; description = "The Tamarin prover for security protocol analysis"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tamarin-prover-term" = callPackage @@ -256357,8 +240796,6 @@ self: { ]; description = "Term manipulation library for the tamarin prover"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tamarin-prover-theory" = callPackage @@ -256380,8 +240817,6 @@ self: { ]; description = "Term manipulation library for the tamarin prover"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tamarin-prover-utils" = callPackage @@ -256399,8 +240834,6 @@ self: { ]; description = "Utility library for the tamarin prover"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tamper" = callPackage @@ -256462,8 +240895,6 @@ self: { testHaskellDepends = [ base hspec vector ]; description = "A tasty enhancement to cassava for easy csv exporting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tar" = callPackage @@ -256594,8 +241025,6 @@ self: { ]; description = "Generate test-suites from refinement types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) z3;}; "tart" = callPackage @@ -256637,8 +241066,6 @@ self: { ]; description = "A command line tool for keeping track of tasks you worked on"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "task-distribution" = callPackage @@ -256675,8 +241102,6 @@ self: { ]; description = "Distributed processing of changing tasks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "taskell" = callPackage @@ -256803,8 +241228,6 @@ self: { ]; description = "Auto discovery for Tasty with support for ingredients and test tree generation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-bdd" = callPackage @@ -256830,8 +241253,6 @@ self: { ]; description = "BDD tests language and tasty provider"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-bench" = callPackage @@ -256864,8 +241285,6 @@ self: { ]; description = "Check multiple items during a tasty test"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-dejafu" = callPackage @@ -256935,8 +241354,6 @@ self: { ]; description = "Adds the ability to fail a tasty test suite on first test failure"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-focus" = callPackage @@ -256995,8 +241412,6 @@ self: { testHaskellDepends = [ aeson base tasty tasty-hunit ]; description = "Grade your tasty-testsuite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-groundhog-converters" = callPackage @@ -257015,8 +241430,6 @@ self: { ]; description = "Tasty Tests for groundhog converters"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-hedgehog" = callPackage @@ -257074,8 +241487,6 @@ self: { ]; description = "Coverage tracking for Hedgehog Property-Based Testing via Tasty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-hspec" = callPackage @@ -257112,8 +241523,6 @@ self: { ]; description = "Render tasty output to HTML"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-hunit" = callPackage @@ -257192,8 +241601,6 @@ self: { ]; description = "automated integration of QuickCheck properties into tasty suites"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-jenkins-xml" = callPackage @@ -257213,8 +241620,6 @@ self: { ]; description = "Render tasty output to both console and XML for Jenkins"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-json" = callPackage @@ -257263,8 +241668,6 @@ self: { testHaskellDepends = [ base smallcheck smallcheck-laws tasty ]; description = "Test common laws"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-leancheck" = callPackage @@ -257293,8 +241696,6 @@ self: { testHaskellDepends = [ base lens tasty ]; description = "Tasty TestTrees for Lens validation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-lua" = callPackage @@ -257338,8 +241739,6 @@ self: { ]; description = "Golden testing provider for tasty with muti-line diff output"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-program" = callPackage @@ -257426,8 +241825,6 @@ self: { ]; description = "A fancy test runner, including support for golden tests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-smallcheck" = callPackage @@ -257460,8 +241857,6 @@ self: { ]; description = "Collect statistics of your Tasty testsuite"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-sugar" = callPackage @@ -257532,8 +241927,6 @@ self: { libraryHaskellDepends = [ base tasty ]; description = "Test vector support for tasty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tasty-th" = callPackage @@ -257613,8 +242006,6 @@ self: { ]; description = "Meta tic-tac-toe ncurses game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tau" = callPackage @@ -257656,8 +242047,6 @@ self: { ]; description = "Transactional variables and data structures with IO hooks"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tcache-AWS" = callPackage @@ -257673,8 +242062,6 @@ self: { ]; description = "tcache using Amazon Web Services as default persistence mechanism"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tccli" = callPackage @@ -257692,8 +242079,6 @@ self: { ]; description = "TokyoCabinet CLI interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tce-conf" = callPackage @@ -257727,8 +242112,6 @@ self: { libraryPkgconfigDepends = [ libtcod ]; description = "Bindings to libtcod roguelike engine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libtcod;}; "tconfig" = callPackage @@ -257751,8 +242134,6 @@ self: { libraryHaskellDepends = [ base containers old-time ]; description = "A purely functional TCP implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tcp-streams" = callPackage @@ -257796,8 +242177,6 @@ self: { ]; description = "Tcp streams using openssl for tls support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tdd-util" = callPackage @@ -257825,8 +242204,6 @@ self: { ]; description = "Test framework wrapper"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tdigest" = callPackage @@ -257869,8 +242246,6 @@ self: { ]; description = "Chart generation from tdigest"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tdlib" = callPackage @@ -257898,8 +242273,6 @@ self: { testSystemDepends = [ tdlib ]; description = "complete binding to the Telegram Database Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) tdlib;}; "tdlib-gen" = callPackage @@ -257928,8 +242301,6 @@ self: { ]; description = "Codegen for TDLib"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tdlib-types" = callPackage @@ -257950,8 +242321,6 @@ self: { ]; description = "Types and Functions generated from tdlib api spec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tdoc" = callPackage @@ -257988,8 +242357,6 @@ self: { executableHaskellDepends = [ base ]; description = "Pure Haskell TDS protocol implementation. Mainly for beam-mssql and beam-sybase"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "teams" = callPackage @@ -258001,8 +242368,6 @@ self: { libraryHaskellDepends = [ base containers fgl graphviz ]; description = "Graphical modeling tools for sequential teams"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "teardown" = callPackage @@ -258045,8 +242410,6 @@ self: { ]; description = "Bleeding edge prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "technique" = callPackage @@ -258089,8 +242452,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Dental data types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tehepero" = callPackage @@ -258121,8 +242482,6 @@ self: { ]; description = "Telegram API client"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "telegram-api" = callPackage @@ -258150,8 +242509,6 @@ self: { ]; description = "Telegram Bot API bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "telegram-bot" = callPackage @@ -258172,8 +242529,6 @@ self: { testHaskellDepends = [ base ]; description = "Telegram Bot microframework for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "telegram-bot-simple" = callPackage @@ -258205,8 +242560,6 @@ self: { ]; description = "Easy to use library for building Telegram bots"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "telegram-raw-api" = callPackage @@ -258231,8 +242584,6 @@ self: { ]; description = "Servant bindings to the Telegram bot API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "telegram-types" = callPackage @@ -258254,8 +242605,6 @@ self: { ]; description = "Types used in Telegram bot API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "telegraph" = callPackage @@ -258296,8 +242645,6 @@ self: { testHaskellDepends = [ base ]; description = "A tool to quickly switch between directories"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "teleshell" = callPackage @@ -258320,8 +242667,6 @@ self: { ]; description = "Telnet client and other things"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tellbot" = callPackage @@ -258341,8 +242686,6 @@ self: { ]; description = "IRC tellbot"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tempered" = callPackage @@ -258375,8 +242718,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "For representing musical tempi"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "template" = callPackage @@ -258399,8 +242740,6 @@ self: { libraryHaskellDepends = [ base data-default template-haskell ]; description = "declaring Default instances just got even easier"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "template-haskell_2_17_0_0" = callPackage @@ -258450,8 +242789,6 @@ self: { ]; description = "Some utilities for template Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "template-hsml" = callPackage @@ -258472,8 +242809,6 @@ self: { ]; description = "Haskell's Simple Markup Language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "template-toolkit" = callPackage @@ -258504,8 +242839,6 @@ self: { libraryHaskellDepends = [ base bytestring text ]; description = "Process template file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "templateify" = callPackage @@ -258519,8 +242852,6 @@ self: { executableHaskellDepends = [ base mtl tagsoup uniplate ]; description = "Make template from website"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "templatepg" = callPackage @@ -258538,8 +242869,6 @@ self: { ]; description = "A PostgreSQL access library with compile-time SQL type inference"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "templater" = callPackage @@ -258594,8 +242923,6 @@ self: { ]; description = "A small Haskell wrapper around the TempoDB api"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "temporal-csound" = callPackage @@ -258613,8 +242940,6 @@ self: { ]; description = "library to make electronic music, brings together temporal-music-notation and csound-expression packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "temporal-media" = callPackage @@ -258736,8 +243061,6 @@ self: { executableToolDepends = [ happy ]; description = "Interpreter for the FRP language Tempus"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tempus-fugit" = callPackage @@ -258765,8 +243088,6 @@ self: { testHaskellDepends = [ base QuickCheck random ]; description = "A completely type-safe library for linear algebra"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tensor-safe" = callPackage @@ -258790,8 +243111,6 @@ self: { ]; description = "Create valid deep neural network architectures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tensorflow" = callPackage @@ -258820,8 +243139,6 @@ self: { ]; description = "TensorFlow bindings"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {libtensorflow = null;}; "tensorflow-core-ops" = callPackage @@ -258842,8 +243159,6 @@ self: { ]; description = "Haskell wrappers for Core Tensorflow Ops"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tensorflow-logging" = callPackage @@ -258872,8 +243187,6 @@ self: { ]; description = "TensorBoard related functionality"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tensorflow-mnist" = callPackage @@ -258926,8 +243239,6 @@ self: { ]; description = "Code generation for TensorFlow operations"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tensorflow-ops" = callPackage @@ -258957,8 +243268,6 @@ self: { ]; description = "Friendly layer around TensorFlow bindings"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tensorflow-proto" = callPackage @@ -259053,8 +243362,6 @@ self: { testHaskellDepends = [ base containers HUnit QuickCheck ]; description = "Term Rewriting Library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "termbox" = callPackage @@ -259081,8 +243388,6 @@ self: { libraryHaskellDepends = [ base reactive-banana termbox ]; description = "reactive-banana + termbox"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "termbox-bindings" = callPackage @@ -259098,8 +243403,6 @@ self: { executableHaskellDepends = [ base ]; description = "Bindings to the Termbox library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "termcolor" = callPackage @@ -259195,8 +243498,6 @@ self: { ]; description = "Text data type for styled terminal output, including all standard ANSI effects (bold, italic, blinking) and ANSI / 256 / truecolor colors support for Unix and Windows (whenever possible)"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "termination-combinators" = callPackage @@ -259208,8 +243509,6 @@ self: { libraryHaskellDepends = [ base containers contravariant ]; description = "Termination combinators for forcing non-terminating algorithms to terminate"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "terminfo_0_4_1_4" = callPackage @@ -259296,8 +243595,6 @@ self: { ]; description = "Plot time series in your terminal using commands stdout"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "terntup" = callPackage @@ -259315,8 +243612,6 @@ self: { ]; description = "a ternary library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "terraform-http-backend-pass" = callPackage @@ -259337,8 +243632,6 @@ self: { executableHaskellDepends = [ base ]; description = "HTTP backend to store terraform state using pass and git"; license = "AGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "terrahs" = callPackage @@ -259351,8 +243644,6 @@ self: { librarySystemDepends = [ terralib4c translib ]; description = "A Haskell GIS Programming Environment"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {terralib4c = null; translib = null;}; "tersmu" = callPackage @@ -259373,8 +243664,6 @@ self: { ]; description = "A semantic parser for lojban"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tesla" = callPackage @@ -259403,8 +243692,6 @@ self: { ]; description = "Tesla API client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-fixture" = callPackage @@ -259426,8 +243713,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Test monadic side-effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-framework" = callPackage @@ -259468,8 +243753,6 @@ self: { testHaskellDepends = [ base test-framework ]; description = "Test.Framework wrapper for DocTest"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-framework-golden" = callPackage @@ -259539,8 +243822,6 @@ self: { ]; description = "QuickCheck support for the test-framework package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-framework-quickcheck2" = callPackage @@ -259578,8 +243859,6 @@ self: { ]; description = "test-sandbox support for the test-framework package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-framework-skip" = callPackage @@ -259599,8 +243878,6 @@ self: { ]; description = "Functions for conveniently marking some of the tests in a suite as being skipped"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-framework-smallcheck" = callPackage @@ -259626,8 +243903,6 @@ self: { testHaskellDepends = [ base test-framework testing-feat ]; description = "A test framework provider for testing-feat"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-framework-th" = callPackage @@ -259659,8 +243934,6 @@ self: { ]; description = "Template Haskell for test framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-fun" = callPackage @@ -259712,8 +243985,6 @@ self: { ]; description = "Testing framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-lib" = callPackage @@ -259764,8 +244035,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Just tests Hackage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-sandbox" = callPackage @@ -259793,8 +244062,6 @@ self: { ]; description = "Sandbox for system tests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-sandbox-compose" = callPackage @@ -259826,8 +244093,6 @@ self: { ]; description = "Lightweight development enviroments using test-sandbox"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-sandbox-hunit" = callPackage @@ -259839,8 +244104,6 @@ self: { libraryHaskellDepends = [ base HUnit lifted-base test-sandbox ]; description = "HUnit convenience functions for use with test-sandbox"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-sandbox-quickcheck" = callPackage @@ -259856,8 +244119,6 @@ self: { ]; description = "QuickCheck convenience functions for use with test-sandbox"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-shouldbe" = callPackage @@ -259871,8 +244132,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Catchy combinators for HUnit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "test-simple" = callPackage @@ -259891,8 +244150,6 @@ self: { ]; description = "Simple Perl inspired testing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "testCom" = callPackage @@ -259910,8 +244167,6 @@ self: { ]; description = "Write your tests in comments"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "testPkg" = callPackage @@ -259947,8 +244202,6 @@ self: { ]; description = "Create tests and benchmarks together"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "testcontainers" = callPackage @@ -259971,8 +244224,6 @@ self: { testToolDepends = [ hspec-discover tasty-discover ]; description = "Docker containers for your integration tests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "testing-feat" = callPackage @@ -260017,8 +244268,6 @@ self: { ]; description = "Quick feedback loop for test suites"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "testpack" = callPackage @@ -260035,8 +244284,6 @@ self: { ]; description = "Test Utililty Pack for HUnit and QuickCheck (unmaintained)"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "testpattern" = callPackage @@ -260051,8 +244298,6 @@ self: { executableHaskellDepends = [ base filepath gtk ]; description = "Display a monitor test pattern"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "testrunner" = callPackage @@ -260067,8 +244312,6 @@ self: { ]; description = "Easy unit test driver framework"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tetris" = callPackage @@ -260117,8 +244360,6 @@ self: { executableHaskellDepends = [ base containers deepseq parsec ]; description = "LaTeX to plain-text conversion"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "texbuilder" = callPackage @@ -260139,8 +244380,6 @@ self: { ]; description = "View your latex output while editing"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "texmath" = callPackage @@ -260185,8 +244424,6 @@ self: { ]; description = "Functions for running Tex from Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text_1_2_4_1" = callPackage @@ -260219,8 +244456,6 @@ self: { ]; description = "Everything Data.Text related in one package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-and-plots" = callPackage @@ -260237,8 +244472,6 @@ self: { ]; description = "EDSL to create HTML documents with plots based on the C3.js library."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-ansi" = callPackage @@ -260271,8 +244504,6 @@ self: { ]; description = "ASCII string and character processing"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-binary" = callPackage @@ -260327,8 +244558,6 @@ self: { ]; description = "Memory-efficient string-indexed container types"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-conversions" = callPackage @@ -260398,8 +244627,6 @@ self: { testHaskellDepends = [ base hspec time ]; description = "Full-weight string formatting library, analog of Python's string.format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-format-simple" = callPackage @@ -260435,8 +244662,6 @@ self: { ]; description = "A generic, derivable, haskell pretty printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-icu" = callPackage @@ -260480,8 +244705,6 @@ self: { ]; description = "Dealing with Strict Text in NFC normalization"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-icu-translit" = callPackage @@ -260565,8 +244788,6 @@ self: { testHaskellDepends = [ base hspec lens ]; description = "Lenses for operating over text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-lips" = callPackage @@ -260582,8 +244803,6 @@ self: { ]; description = "Monadic parsing combinator library with attention to locations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-loc" = callPackage @@ -260636,8 +244855,6 @@ self: { ]; description = "A data structure for mapping metadata to text subsequences"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-metrics" = callPackage @@ -260671,8 +244888,6 @@ self: { ]; description = "Unicode-normalized text"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-offset" = callPackage @@ -260691,8 +244906,6 @@ self: { ]; description = "Library for converting between line/column and byte offset"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-plus" = callPackage @@ -260709,8 +244922,6 @@ self: { testHaskellDepends = [ base doctest HTF text ]; description = "Utils for text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-position" = callPackage @@ -260725,8 +244936,6 @@ self: { testHaskellDepends = [ base QuickCheck regex-applicative ]; description = "Handling positions in text and position-tagging it"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-postgresql" = callPackage @@ -260806,8 +245015,6 @@ self: { libraryHaskellDepends = [ base containers mtl vector ]; description = "A Haskell implementation of the 1# Text Register Machine"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-render" = callPackage @@ -260836,8 +245043,6 @@ self: { testHaskellDepends = [ base hedgehog neat-interpolation text ]; description = "Simple text replacements from a list of search/replace pairs"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-short" = callPackage @@ -260976,8 +245181,6 @@ self: { ]; description = "An efficient finite map from Text to values, based on bytestring-trie"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-utf7" = callPackage @@ -261019,8 +245222,6 @@ self: { ]; description = "An efficient packed UTF-8 backed Unicode text type"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-utils" = callPackage @@ -261033,8 +245234,6 @@ self: { testHaskellDepends = [ base HTF text ]; description = "Various text utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-xml-generic" = callPackage @@ -261063,8 +245262,6 @@ self: { libraryHaskellDepends = [ base parsec template-haskell xml ]; description = "Quasiquoter for xml. XML DSL in Haskell."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text-zipper" = callPackage @@ -261090,8 +245287,6 @@ self: { testHaskellDepends = [ base hspec text-zipper ]; description = "Monadic interface to the text-zipper package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "text1" = callPackage @@ -261108,8 +245303,6 @@ self: { ]; description = "Non-empty values of `Data.Text`."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "textPlot" = callPackage @@ -261150,8 +245343,6 @@ self: { executableHaskellDepends = [ base haskell98 process ]; description = "A simple Haskell program to provide tags for Haskell code completion in TextMate"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "textocat-api" = callPackage @@ -261172,8 +245363,6 @@ self: { ]; description = "Unofficial Haskell SDK for Textocat API -- http://textocat.com"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "texts" = callPackage @@ -261196,8 +245385,6 @@ self: { libraryHaskellDepends = [ base bytestring text utf8-string ]; description = "Textual type class for data that represent text"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tf-random" = callPackage @@ -261232,8 +245419,6 @@ self: { libraryHaskellDepends = [ base template-haskell tfp ]; description = "Template-Haskell code for tfp"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tftp" = callPackage @@ -261258,8 +245443,6 @@ self: { ]; description = "A library for building tftp servers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tga" = callPackage @@ -261271,8 +245454,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Reading and writing of tga image files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-abstraction" = callPackage @@ -261308,8 +245489,6 @@ self: { ]; description = "Alpha equivalence for TH Exp"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-bang-compat" = callPackage @@ -261332,8 +245511,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "More convenient construction of TH ASTs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-cas" = callPackage @@ -261397,8 +245574,6 @@ self: { ]; description = "Test instance context"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-data-compat" = callPackage @@ -261466,8 +245641,6 @@ self: { libraryHaskellDepends = [ base constraints template-haskell ]; description = "Automatically discover available dictionaries at compile time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-env" = callPackage @@ -261519,8 +245692,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "TH fold generator"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-format" = callPackage @@ -261537,8 +245708,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit text ]; description = "Template Haskell based support for format strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-inline-io-action" = callPackage @@ -261570,8 +245739,6 @@ self: { ]; description = "Fixed versions of instances reification functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-instances" = callPackage @@ -261595,8 +245762,6 @@ self: { ]; description = "A place to collect orphan instances for Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-kinds" = callPackage @@ -261612,8 +245777,6 @@ self: { ]; description = "Automated kind inference in Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-kinds-fork" = callPackage @@ -261629,8 +245792,6 @@ self: { ]; description = "Automated kind inference in Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-lego" = callPackage @@ -261651,8 +245812,6 @@ self: { ]; description = "Template Haskell construction utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-lift" = callPackage @@ -261734,8 +245893,6 @@ self: { libraryHaskellDepends = [ base lens pretty template-haskell ]; description = "Simplify and render Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-printf" = callPackage @@ -261794,8 +245951,6 @@ self: { libraryHaskellDepends = [ base containers template-haskell ]; description = "Binding group analysis in Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-strict-compat" = callPackage @@ -261822,8 +245977,6 @@ self: { ]; description = "Typechecking in Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-test-utils" = callPackage @@ -261857,8 +246010,6 @@ self: { testHaskellDepends = [ base hspec template-haskell ]; description = "Provides a way to persist data from compile-time to runtime"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-traced" = callPackage @@ -261870,8 +246021,6 @@ self: { libraryHaskellDepends = [ base containers mtl template-haskell ]; description = "Tracing Q monad computation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-typegraph" = callPackage @@ -261899,8 +246048,6 @@ self: { ]; description = "Graph of the subtype relation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "th-utilities" = callPackage @@ -261944,8 +246091,6 @@ self: { ]; description = "Give your dependencies stars on GitHub!"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "theatre" = callPackage @@ -261961,8 +246106,6 @@ self: { ]; description = "Minimalistic actor library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "themoviedb" = callPackage @@ -262035,8 +246178,6 @@ self: { ]; description = "All-in-one session handling for servant-based frontends"; license = "AGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "theoremquest" = callPackage @@ -262048,8 +246189,6 @@ self: { libraryHaskellDepends = [ base HTTP json utf8-string ]; description = "A common library for TheoremQuest, a theorem proving game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "theoremquest-client" = callPackage @@ -262063,8 +246202,6 @@ self: { executableHaskellDepends = [ base HTTP network theoremquest ]; description = "A simple client for the TheoremQuest theorem proving game"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "these" = callPackage @@ -262149,8 +246286,6 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "Typing Haskell In Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thimk" = callPackage @@ -262169,8 +246304,6 @@ self: { ]; description = "Command-line spelling word suggestion tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thock" = callPackage @@ -262198,8 +246331,6 @@ self: { ]; description = "A modern TUI typing game featuring online racing against friends"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thorn" = callPackage @@ -262218,8 +246349,6 @@ self: { ]; description = "Datatype Manipulation with Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thread-hierarchy" = callPackage @@ -262309,8 +246438,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "(deprecated in favor of 'threads') Simple thread management"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "threads" = callPackage @@ -262429,8 +246556,6 @@ self: { ]; description = "Composable algebraic editors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "threepenny-gui" = callPackage @@ -262471,8 +246596,6 @@ self: { executableHaskellDepends = [ base threepenny-gui ]; description = "Write simple nested context menus for threepenny-gui"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "threepenny-gui-flexbox" = callPackage @@ -262487,8 +246610,6 @@ self: { executableHaskellDepends = [ base threepenny-gui ]; description = "Flexbox layouts for Threepenny-gui"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thrift" = callPackage @@ -262511,8 +246632,6 @@ self: { ]; description = "Haskell bindings for the Apache Thrift RPC system"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thrist" = callPackage @@ -262575,8 +246694,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Loop over an action but throttle it to a certain rate"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "through-text" = callPackage @@ -262642,8 +246759,6 @@ self: { ]; description = "Generate thumbnails easily and safely"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thumbnail-polish" = callPackage @@ -262660,8 +246775,6 @@ self: { ]; description = "Image thumbnail creation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "thyme" = callPackage @@ -262762,8 +246875,6 @@ self: { executableHaskellDepends = [ base glade gtk haskell98 ]; description = "Useful if reading \"Why FP matters\" by John Hughes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ticker" = callPackage @@ -262800,8 +246911,6 @@ self: { ]; description = "A port of @Data.Binary@"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tictactoe3d" = callPackage @@ -262813,8 +246922,6 @@ self: { libraryHaskellDepends = [ base tuples-homogenous-h98 vector ]; description = "3D Tic-Tac-Toe game"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tidal" = callPackage @@ -262854,8 +246961,6 @@ self: { ]; description = "MIDI support for tidal"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tidal-serial" = callPackage @@ -262869,8 +246974,6 @@ self: { ]; description = "Serial support for tidal"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tidal-vis" = callPackage @@ -262891,8 +246994,6 @@ self: { executableHaskellDepends = [ base ]; description = "Visual rendering for Tidal patterns and osc messages"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tie-knot" = callPackage @@ -262904,8 +247005,6 @@ self: { libraryHaskellDepends = [ base containers mtl recursion-schemes ]; description = "\"Ties the knot\" on a given set of structures that reference each other by keys"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tiempo" = callPackage @@ -262917,8 +247016,6 @@ self: { libraryHaskellDepends = [ base deepseq time ]; description = "Specify time intervals in different units (secs, mins, hours, etc.)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tiger" = callPackage @@ -262935,8 +247032,6 @@ self: { ]; description = "Tiger Compiler of Universiteit Utrecht"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tight-apply" = callPackage @@ -262964,8 +247059,6 @@ self: { ]; description = "Nice API for a Slackbot"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tighttp" = callPackage @@ -262984,8 +247077,6 @@ self: { ]; description = "Tiny and Incrementally-Growing HTTP library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tikzsd" = callPackage @@ -263048,8 +247139,6 @@ self: { executableToolDepends = [ happy ]; description = "The Timber Compiler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time_1_11_1_2" = callPackage @@ -263113,8 +247202,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "Data instances for the time package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-exts" = callPackage @@ -263136,8 +247223,6 @@ self: { ]; description = "Yet another time library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-http" = callPackage @@ -263161,8 +247246,6 @@ self: { ]; description = "Parse and format HTTP/1.1 Date and Time strings"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-interval" = callPackage @@ -263185,8 +247268,6 @@ self: { libraryHaskellDepends = [ base base-io-access time ]; description = "IO Access for time"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-lens" = callPackage @@ -263232,8 +247313,6 @@ self: { testHaskellDepends = [ base hspec HUnit mtl time tz ]; description = "A library to mock the current time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-manager" = callPackage @@ -263308,8 +247387,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Quasi-quoter for UTCTime times"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-quote" = callPackage @@ -263326,8 +247403,6 @@ self: { ]; description = "Quasi-quoters for dates and times"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-recurrence" = callPackage @@ -263345,8 +247420,6 @@ self: { ]; description = "Generate recurring dates"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-series" = callPackage @@ -263361,8 +247434,6 @@ self: { executableHaskellDepends = [ base ]; description = "Time series analysis"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-series-lib" = callPackage @@ -263376,8 +247447,6 @@ self: { doHaddock = false; description = "Library for Time Series processing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-units" = callPackage @@ -263402,8 +247471,6 @@ self: { libraryHaskellDepends = [ base convertible parsec time ]; description = "Parse, format and convert W3C Date and Time"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "time-warp" = callPackage @@ -263441,8 +247508,6 @@ self: { ]; description = "Distributed systems execution emulation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timecalc" = callPackage @@ -263455,8 +247520,6 @@ self: { isExecutable = true; executableHaskellDepends = [ base haskeline uu-parsinglib ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timeconsole" = callPackage @@ -263579,8 +247642,6 @@ self: { time unordered-containers ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timeout" = callPackage @@ -263597,8 +247658,6 @@ self: { ]; description = "Generalized sleep and timeout functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timeout-control" = callPackage @@ -263625,8 +247684,6 @@ self: { libraryHaskellDepends = [ base deepseq mtl parallel ]; description = "Runs a time-limited computation alowing it to return intermediate results"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timeparsers" = callPackage @@ -263642,8 +247699,6 @@ self: { ]; description = "Attoparsec parsers for various Date/Time formats"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timeplot" = callPackage @@ -263675,8 +247730,6 @@ self: { libraryHaskellDepends = [ base datetime ]; description = "Prints timestamps after each line evaluated"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timer-wheel" = callPackage @@ -263766,8 +247819,6 @@ self: { ]; description = "Library for Time Series processing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timespan" = callPackage @@ -263839,8 +247890,6 @@ self: { testHaskellDepends = [ base hspec microlens time ]; description = "Time utilities"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timezone-detect" = callPackage @@ -263860,8 +247909,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell bindings for the zone-detect C library; plus tz-aware utils"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timezone-olson" = callPackage @@ -263892,8 +247939,6 @@ self: { ]; description = "Load TimeZoneSeries from an Olson file at compile time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timezone-series" = callPackage @@ -263925,8 +247970,6 @@ self: { timezone-series ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "timing-convenience" = callPackage @@ -263950,8 +247993,6 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Tiny INI file and configuration library with a minimal dependency footprint"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tintin" = callPackage @@ -263977,8 +248018,6 @@ self: { testHaskellDepends = [ base require ]; description = "A softer alternative to Haddock"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tiny-scheduler" = callPackage @@ -263990,8 +248029,6 @@ self: { libraryHaskellDepends = [ async base time ]; description = "tiny no-brainer job scheduler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tinyMesh" = callPackage @@ -264007,8 +248044,6 @@ self: { ]; description = "TinyMesh - communicating with auto-meshing sensor network"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tinyXml" = callPackage @@ -264033,8 +248068,6 @@ self: { ]; description = "A fast DOM parser for a subset of XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tinyfiledialogs" = callPackage @@ -264076,8 +248109,6 @@ self: { testHaskellDepends = [ base QuickCheck text ]; description = "A tiny text templating library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tip-haskell-frontend" = callPackage @@ -264102,8 +248133,6 @@ self: { ]; description = "Convert from Haskell to Tip"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tip-lib" = callPackage @@ -264127,8 +248156,6 @@ self: { ]; description = "tons of inductive problems - support library and tools"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tiphys" = callPackage @@ -264173,8 +248200,6 @@ self: { ]; description = "Testing Infrastructure for Temporal AbstractioNs - GUI to debug temporal programs"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "titan-debug-yampa" = callPackage @@ -264192,8 +248217,6 @@ self: { ]; description = "Testing Infrastructure for Temporal AbstractioNs - Interactive Yampa debugging layer"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "titan-record-yampa" = callPackage @@ -264205,8 +248228,6 @@ self: { libraryHaskellDepends = [ base Yampa ]; description = "Testing Infrastructure for Temporal AbstractioNs - Yampa record-and-replay layer"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "titlecase" = callPackage @@ -264241,8 +248262,6 @@ self: { testHaskellDepends = [ HUnit test-framework test-framework-hunit ]; description = "Simple Presentation Utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tkyprof" = callPackage @@ -264269,8 +248288,6 @@ self: { ]; description = "A web-based visualizer for GHC Profiling Reports"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tld" = callPackage @@ -264479,8 +248496,6 @@ self: { ]; description = "TLS extra default values and helpers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tls-session-manager" = callPackage @@ -264518,8 +248533,6 @@ self: { executableHaskellDepends = [ base ]; description = "Handle phylogenetic trees"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tmapchan" = callPackage @@ -264590,8 +248603,6 @@ self: { ]; description = "Start and stop a temporary postgres"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tmpl" = callPackage @@ -264629,8 +248640,6 @@ self: { ]; description = "A simple daily journal program"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tnet" = callPackage @@ -264676,8 +248685,6 @@ self: { ]; description = "A type class and some utilities for generating Haskell code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "to-string-class" = callPackage @@ -264691,8 +248698,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Converting string-like types to Strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "to-string-instances" = callPackage @@ -264704,8 +248709,6 @@ self: { libraryHaskellDepends = [ bytestring pretty text to-string-class ]; description = "Instances for the ToString class"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toboggan" = callPackage @@ -264724,8 +248727,6 @@ self: { executableHaskellDepends = [ base ]; description = "Twitter bot generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "todo" = callPackage @@ -264737,8 +248738,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A todo bottom"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "todos" = callPackage @@ -264764,8 +248763,6 @@ self: { ]; description = "Easy-to-use TODOs manager"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tofromxml" = callPackage @@ -264784,8 +248781,6 @@ self: { ]; description = "Reading and writing Haskell data from and to XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toilet" = callPackage @@ -264803,8 +248798,6 @@ self: { ]; description = "Manage the toilet queue at the IMO"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "token-bucket" = callPackage @@ -264840,8 +248833,6 @@ self: { ]; description = "Fast rate limiting using the token bucket algorithm (BSD)"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "token-search" = callPackage @@ -264867,8 +248858,6 @@ self: { text unordered-containers ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tokenify" = callPackage @@ -264880,8 +248869,6 @@ self: { libraryHaskellDepends = [ base containers text ]; description = "A regex lexer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tokenize" = callPackage @@ -264925,8 +248912,6 @@ self: { ]; description = "A variant of tokenizer-monad that supports streaming"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tokstyle" = callPackage @@ -264951,8 +248936,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "TokTok C code style checker"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toktok" = callPackage @@ -264967,8 +248950,6 @@ self: { libraryHaskellDepends = [ base containers haskell98 ]; executableHaskellDepends = [ base bytestring gf iconv ]; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tokyocabinet-haskell" = callPackage @@ -264987,8 +248968,6 @@ self: { testSystemDepends = [ tokyocabinet ]; description = "Haskell binding of Tokyo Cabinet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) tokyocabinet;}; "tokyotyrant-haskell" = callPackage @@ -265005,8 +248984,6 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) tokyocabinet; inherit (pkgs) tokyotyrant;}; "tomato-rubato-openal" = callPackage @@ -265018,8 +248995,6 @@ self: { libraryHaskellDepends = [ base OpenAL stm vector ]; description = "Easy to use library for audio programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toml" = callPackage @@ -265036,8 +249011,6 @@ self: { attoparsec base bytestring containers old-locale time ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toml-parser" = callPackage @@ -265191,8 +249164,6 @@ self: { ]; description = "tonatona plugin for google-server-api"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tonatona-logger" = callPackage @@ -265225,8 +249196,6 @@ self: { ]; description = "tonatona plugin for accessing PostgreSQL database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tonatona-persistent-sqlite" = callPackage @@ -265247,8 +249216,6 @@ self: { ]; description = "tonatona plugin for accessing Sqlite database"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tonatona-servant" = callPackage @@ -265272,8 +249239,6 @@ self: { ]; description = "tonatona plugin for servant"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "too-many-cells" = callPackage @@ -265317,8 +249282,6 @@ self: { executableHaskellDepends = [ base optparse-generic ]; description = "Cluster single cells and analyze cell clade relationships"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toodles" = callPackage @@ -265354,8 +249317,6 @@ self: { ]; description = "Manage the TODO entries in your code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toolshed" = callPackage @@ -265397,8 +249358,6 @@ self: { ]; description = "Top (typed oriented protocol) API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "topkata" = callPackage @@ -265417,8 +249376,6 @@ self: { ]; description = "OpenGL Arcade Game"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "topograph" = callPackage @@ -265447,8 +249404,6 @@ self: { libraryHaskellDepends = [ base mtl parallel QuickCheck ]; description = "Simple unit test library (or framework)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "torrent" = callPackage @@ -265519,8 +249474,6 @@ self: { libraryHaskellDepends = [ base containers semiring-num ]; description = "Finitely represented total maps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "total-maps" = callPackage @@ -265551,8 +249504,6 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "Library (and cli) to execute a procedure on file change"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tower" = callPackage @@ -265599,8 +249550,6 @@ self: { ]; description = "A Tox protocol implementation in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toxcore-c" = callPackage @@ -265626,8 +249575,6 @@ self: { ]; description = "Haskell bindings to the C reference implementation of Tox"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {toxcore = null;}; "toxiproxy-haskell" = callPackage @@ -265647,8 +249594,6 @@ self: { ]; description = "Client library for Toxiproxy: a TCP failure testing proxy"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toysolver" = callPackage @@ -265704,8 +249649,6 @@ self: { ]; description = "Assorted decision procedures for SAT, SMT, Max-SAT, PB, MIP, etc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tpar" = callPackage @@ -265742,8 +249685,6 @@ self: { ]; description = "simple, parallel job scheduling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tpb" = callPackage @@ -265769,8 +249710,6 @@ self: { ]; description = "Applications for interacting with the Pushbullet API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tpdb" = callPackage @@ -265812,8 +249751,6 @@ self: { ]; description = "Parser and pretty printer for the TPTP language"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trace" = callPackage @@ -265830,8 +249767,6 @@ self: { ]; description = "A monad transformer for tracing provenience of errors"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trace-call" = callPackage @@ -265843,8 +249778,6 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "functions for logging the arguments and results of function calls"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trace-function-call" = callPackage @@ -265856,8 +249789,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Easy lightweight tracing of function arguments and results for ad hoc debugging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "traced" = callPackage @@ -265869,8 +249800,6 @@ self: { libraryHaskellDepends = [ base containers mtl pretty ]; description = "Simple evaluation trace"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tracer" = callPackage @@ -265900,8 +249829,6 @@ self: { ]; description = "Visualize Haskell data structures as edge-labeled trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tracing" = callPackage @@ -265922,8 +249849,6 @@ self: { ]; description = "Distributed tracing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tracing-control" = callPackage @@ -265947,8 +249872,6 @@ self: { ]; description = "Distributed tracing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tracked-files" = callPackage @@ -265964,8 +249887,6 @@ self: { testHaskellDepends = [ base directory hspec process ]; description = "Package to list all tracked and untracked existing files via Git"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tracker" = callPackage @@ -265977,8 +249898,6 @@ self: { libraryHaskellDepends = [ base containers glib ]; description = "Client library for Tracker metadata database, indexer and search tool"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trackit" = callPackage @@ -265999,8 +249918,6 @@ self: { ]; description = "A command-line tool for live monitoring"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "traction" = callPackage @@ -266022,8 +249939,6 @@ self: { ]; description = "Tools for postgresql-simple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tracy" = callPackage @@ -266035,8 +249950,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Convenience wrappers for non-intrusive debug tracing"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trade-journal" = callPackage @@ -266092,8 +250005,6 @@ self: { ]; description = "TrailDB bindings for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {Judy = null; traildb = null;}; "trajectory" = callPackage @@ -266116,8 +250027,6 @@ self: { ]; description = "Tools and a library for working with Trajectory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trans-fx-core" = callPackage @@ -266181,8 +250090,6 @@ self: { libraryHaskellDepends = [ base ListZipper MonadPrompt stm ]; description = "Transactional events, based on Concurrent ML semantics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transf" = callPackage @@ -266201,8 +250108,6 @@ self: { ]; description = "Text transformer and interpreter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transfer-db" = callPackage @@ -266231,8 +250136,6 @@ self: { ]; description = "ODBC database transfer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transformations" = callPackage @@ -266253,8 +250156,6 @@ self: { ]; description = "Generic representation of tree transformations"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transformers_0_5_6_2" = callPackage @@ -266333,8 +250234,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Arrow-like / category-like composition for transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transformers-continue" = callPackage @@ -266364,8 +250263,6 @@ self: { ]; description = "Sensible conversions between some of the monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transformers-eff" = callPackage @@ -266447,8 +250344,6 @@ self: { ]; description = "Ad-hoc type classes for lifting"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transformers-runnable" = callPackage @@ -266460,8 +250355,6 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A unified interface for the run operation of monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transformers-supply" = callPackage @@ -266528,8 +250421,6 @@ self: { ]; description = "fully composable remote execution for the creation of distributed systems"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "transient-universe-tls" = callPackage @@ -266546,8 +250437,6 @@ self: { ]; description = "transient with secure communications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "translatable-intset" = callPackage @@ -266561,8 +250450,6 @@ self: { libraryHaskellDepends = [ base fingertree ]; description = "Integer sets with a constant time translate operation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "translate" = callPackage @@ -266575,8 +250462,6 @@ self: { libraryHaskellDepends = [ base curl json network utf8-string ]; description = "Haskell binding to Google's AJAX Language API for Translation and Detection"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "translate-cli" = callPackage @@ -266594,8 +250479,6 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Translation cli tool"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trasa" = callPackage @@ -266614,8 +250497,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Type Safe Web Routing"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trasa-client" = callPackage @@ -266632,8 +250513,6 @@ self: { ]; description = "Type safe http requests"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trasa-extra" = callPackage @@ -266651,8 +250530,6 @@ self: { ]; description = "Extra functions for trasa"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trasa-form" = callPackage @@ -266671,8 +250548,6 @@ self: { ]; description = "generate forms using lucid, ditto and trasa"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trasa-reflex" = callPackage @@ -266706,8 +250581,6 @@ self: { ]; description = "Type safe web server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trasa-th" = callPackage @@ -266724,8 +250597,6 @@ self: { testHaskellDepends = [ base trasa ]; description = "Template Haskell to generate trasa routes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "traversal-template" = callPackage @@ -266741,8 +250612,6 @@ self: { benchmarkHaskellDepends = [ base gauge template-haskell util ]; description = "See README for more info"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "traverse-with-class" = callPackage @@ -266774,8 +250643,6 @@ self: { ]; description = "A simple client implementation using Travis CI API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "travis-meta-yaml" = callPackage @@ -266805,8 +250672,6 @@ self: { ]; description = ".travis.yml preprocessor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "travis-pogodi" = callPackage @@ -266839,8 +250704,6 @@ self: { ]; description = "A tool for finding haddocks"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "traypoweroff" = callPackage @@ -266855,8 +250718,6 @@ self: { executableHaskellDepends = [ base gtk process ]; description = "Tray Icon application to PowerOff / Reboot computer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "treap" = callPackage @@ -266871,8 +250732,6 @@ self: { testHaskellDepends = [ base doctest Glob hspec hspec-core ]; description = "Efficient implementation of the implicit treap data structure"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tree-diff" = callPackage @@ -266933,8 +250792,6 @@ self: { libraryHaskellDepends = [ base boxes containers mtl ]; description = "Configurable text rendering of trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tree-sitter" = callPackage @@ -267097,8 +250954,6 @@ self: { testHaskellDepends = [ base containers doctest mtl ]; description = "Functions and newtype wrappers for traversing Trees"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tree-view" = callPackage @@ -267145,8 +251000,6 @@ self: { ]; description = "A tree of Data.Map."; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "treemap-html" = callPackage @@ -267162,8 +251015,6 @@ self: { ]; description = "Generates HTML for Data.Tree as TreeMap"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "treemap-html-tools" = callPackage @@ -267183,8 +251034,6 @@ self: { doHaddock = false; description = "Treemap related commands for producing foldable TreeMap HTML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "treersec" = callPackage @@ -267265,8 +251114,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A PostgreSQL Database Migrator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trek-db" = callPackage @@ -267290,8 +251137,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A PostgreSQL Database Migrator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trek-lens" = callPackage @@ -267318,8 +251163,6 @@ self: { ]; description = "Library for polling Tremulous servers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trhsx" = callPackage @@ -267330,8 +251173,6 @@ self: { sha256 = "11jx2jf6vi7368ys39mz0ziy6xknbi0z87926n2y16am6k2h25k3"; description = "Deprecated"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trial" = callPackage @@ -267385,8 +251226,6 @@ self: { ]; description = "triangulation of polygons"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trie-simple" = callPackage @@ -267435,8 +251274,6 @@ self: { ]; description = "Various trie implementations in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trifecta" = callPackage @@ -267482,8 +251319,6 @@ self: { testHaskellDepends = [ base hspec protolude ]; description = "Trigger is a cross platform file system watcher for super fast build-and-restart workflows"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trim" = callPackage @@ -267499,8 +251334,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A command-line tool for trimming whitespace"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trimpolya" = callPackage @@ -267514,8 +251347,6 @@ self: { executableHaskellDepends = [ base bio bytestring simpleargs ]; description = "Search for, annotate and trim poly-A tail"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tripLL" = callPackage @@ -267531,8 +251362,6 @@ self: { ]; description = "A very simple triple store"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "triplesec" = callPackage @@ -267563,8 +251392,6 @@ self: { libraryHaskellDepends = [ base comonad distributive ]; description = "The trivial monad and comonad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trivial-constraint" = callPackage @@ -267576,8 +251403,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Constraints that any type, resp. no type fulfills"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tropical" = callPackage @@ -267589,8 +251414,6 @@ self: { libraryHaskellDepends = [ base semiring-simple ]; description = "A library for tropical mathematics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tropical-geometry" = callPackage @@ -267615,8 +251438,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A Tropical Geometry package for Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "true-name" = callPackage @@ -267631,8 +251452,6 @@ self: { testHaskellDepends = [ base containers template-haskell time ]; description = "Template Haskell hack to violate module abstractions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "truelevel" = callPackage @@ -267646,8 +251465,6 @@ self: { executableHaskellDepends = [ base containers parseargs WAVE ]; description = "Audio file compressor-limiter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "trurl" = callPackage @@ -267670,8 +251487,6 @@ self: { testHaskellDepends = [ base hastache tasty tasty-hunit ]; description = "Haskell template code generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "truthful" = callPackage @@ -267696,8 +251511,6 @@ self: { libraryHaskellDepends = [ base containers mtl time transformers ]; description = "A Transaction Framework for Web Applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tsession-happstack" = callPackage @@ -267711,8 +251524,6 @@ self: { ]; description = "A Transaction Framework for Happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tsetchan" = callPackage @@ -267803,8 +251614,6 @@ self: { executableHaskellDepends = [ base gloss stm vector ]; description = "Real time TSP tour visualization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tsparse" = callPackage @@ -267822,8 +251631,6 @@ self: { ]; description = "Parses U.S. federal Thrift Savings Plan PDF quarterly statements"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tst" = callPackage @@ -267855,8 +251662,6 @@ self: { ]; description = "Interacts with tesseract to ease reading of RAW Japanese manga"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tsv2csv" = callPackage @@ -267889,8 +251694,6 @@ self: { ]; description = "Template tsv into SQL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tsweb" = callPackage @@ -267919,8 +251722,6 @@ self: { ]; description = "An API binding Web.Spock to Database.Beam"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ttask" = callPackage @@ -267943,8 +251744,6 @@ self: { testHaskellDepends = [ base ]; description = "This is task management tool for yourself, that inspired by scrum"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ttc" = callPackage @@ -268075,8 +251874,6 @@ self: { ]; description = "Working with files for the Tiptoi® pen"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tubes" = callPackage @@ -268093,8 +251890,6 @@ self: { ]; description = "Write stream processing computations with side effects in a series of tubes"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuntap" = callPackage @@ -268106,8 +251901,6 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "Interface to TUN/TAP drivers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuntap-simple" = callPackage @@ -268121,8 +251914,6 @@ self: { libraryHaskellDepends = [ base ioctl ]; description = "A simple tun/tap library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tup-functor" = callPackage @@ -268137,8 +251928,6 @@ self: { executableHaskellDepends = [ base haskell-src-exts parsec2 ]; description = "Homogeneous tuples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuple" = callPackage @@ -268161,8 +251950,6 @@ self: { libraryHaskellDepends = [ base combinat ]; description = "Enum instances for tuples where the digits increase with the same speed"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuple-generic" = callPackage @@ -268197,8 +251984,6 @@ self: { libraryHaskellDepends = [ base lens template-haskell ]; description = "Stock FieldN combos and generators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuple-morph" = callPackage @@ -268212,8 +251997,6 @@ self: { libraryHaskellDepends = [ base HList template-haskell ]; description = "Morph between tuples, or convert them from and to HLists"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuple-ops" = callPackage @@ -268225,8 +252008,6 @@ self: { libraryHaskellDepends = [ base type-combinators ]; description = "various operations on n-ary tuples via GHC.Generics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuple-sop" = callPackage @@ -268261,8 +252042,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Functor, Applicative and Monad for n-ary tuples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tuples" = callPackage @@ -268313,8 +252092,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple simulator for Turing machines"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "turing-music" = callPackage @@ -268328,8 +252105,6 @@ self: { executableHaskellDepends = [ ALUT base ]; description = "Plays music generated by Turing machines with 5 states and 2 symbols"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "turingMachine" = callPackage @@ -268346,8 +252121,6 @@ self: { ]; description = "An implementation of Turing Machine and Automaton"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "turkish-deasciifier" = callPackage @@ -268426,8 +252199,6 @@ self: { testHaskellDepends = [ base HUnit parsec ]; description = "Collection of command line options and parsers for these options"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tw" = callPackage @@ -268452,8 +252223,6 @@ self: { libraryHaskellDepends = [ base containers lens stm transformers ]; description = "A library for incremental computing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twee" = callPackage @@ -268471,8 +252240,6 @@ self: { ]; description = "An equational theorem prover"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twee-lib" = callPackage @@ -268516,8 +252283,6 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion megaparsec ]; description = "Command-line tool for twitter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twentefp" = callPackage @@ -268546,8 +252311,6 @@ self: { ]; description = "Used as Lab Assignments Environment at the University of Twente"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twentefp-eventloop-trees" = callPackage @@ -268559,8 +252322,6 @@ self: { libraryHaskellDepends = [ base eventloop ]; description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and RedBlackTree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twentefp-graphs" = callPackage @@ -268572,8 +252333,6 @@ self: { libraryHaskellDepends = [ base twentefp-eventloop-graphics ]; description = "Lab Assignments Environment at Univeriteit Twente"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twentefp-number" = callPackage @@ -268599,8 +252358,6 @@ self: { ]; description = "RoseTree type and show functions for lab assignment of University of Twente"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twentefp-trees" = callPackage @@ -268612,8 +252369,6 @@ self: { libraryHaskellDepends = [ base twentefp-eventloop-graphics ]; description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and ParseTree"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twentefp-websockets" = callPackage @@ -268632,8 +252387,6 @@ self: { ]; description = "A fork of the popular websockets package. It is used for the practical assignments of the University of Twente. A sensible and clean way to write WebSocket-capable servers in Haskell."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twentyseven" = callPackage @@ -268663,8 +252416,6 @@ self: { ]; description = "Rubik's cube solver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twfy-api-client" = callPackage @@ -268690,8 +252441,6 @@ self: { testHaskellDepends = [ base ]; description = "They Work For You API Client Library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twhs" = callPackage @@ -268722,8 +252471,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "CLI twitter client"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twidge" = callPackage @@ -268744,8 +252491,6 @@ self: { ]; description = "Unix Command-Line Twitter and Identica Client"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twilight-stm" = callPackage @@ -268757,8 +252502,6 @@ self: { libraryHaskellDepends = [ base containers haskell98 mtl ]; description = "STM library with safe irrevocable I/O and inconsistency repair"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twilio" = callPackage @@ -268785,8 +252528,6 @@ self: { doCheck = false; description = "Twilio REST API library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twill" = callPackage @@ -268805,8 +252546,6 @@ self: { ]; description = "Twilio API interaction"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twiml" = callPackage @@ -268839,8 +252578,6 @@ self: { ]; description = "very simple template language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twirp" = callPackage @@ -268862,8 +252599,6 @@ self: { ]; description = "Haskell twirp foundations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twisty" = callPackage @@ -268917,8 +252652,6 @@ self: { ]; description = "A Haskell-based CLI Twitter client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twitter-conduit" = callPackage @@ -268949,8 +252682,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Twitter API package with conduit interface and Streaming API support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twitter-enumerator" = callPackage @@ -268969,8 +252700,6 @@ self: { ]; description = "Twitter API package with enumerator interface and Streaming API support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twitter-feed" = callPackage @@ -268992,8 +252721,6 @@ self: { ]; description = "Client for fetching Twitter timeline via Oauth"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "twitter-types" = callPackage @@ -269045,8 +252772,6 @@ self: { ]; description = "Persistent transactions on top of STM"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "txt" = callPackage @@ -269065,8 +252790,6 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "txt-sushi" = callPackage @@ -269108,8 +252831,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Deprecated in favor of eros"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ty" = callPackage @@ -269134,8 +252855,6 @@ self: { libraryHaskellDepends = [ base containers template-haskell ]; description = "Provide proof witnesses for closed type family evaluation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typalyze" = callPackage @@ -269154,8 +252873,6 @@ self: { ]; description = "Analyzes Haskell source files for easy reference"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-aligned" = callPackage @@ -269180,8 +252897,6 @@ self: { testHaskellDepends = [ base hspec test-fixture ]; description = "Runtime type assertions for testing"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-booleans" = callPackage @@ -269208,8 +252923,6 @@ self: { ]; description = "Utilities for caching type families results. Sometimes complex type families take long time to compile, so it is proficient to cache them and use the final result without the need of re-computation."; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-cereal" = callPackage @@ -269226,8 +252939,6 @@ self: { ]; description = "Type-level serialization of type constructors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-combinators" = callPackage @@ -269241,8 +252952,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A collection of data types for type-level programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-combinators-quote" = callPackage @@ -269258,8 +252967,6 @@ self: { ]; description = "Quasiquoters for the 'type-combinators' package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-combinators-singletons" = callPackage @@ -269271,8 +252978,6 @@ self: { libraryHaskellDepends = [ base singletons type-combinators ]; description = "Interop between /type-combinators/ and /singletons/"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-digits" = callPackage @@ -269284,8 +252989,6 @@ self: { libraryHaskellDepends = [ base template-haskell type-spine ]; description = "Arbitrary-base type-level digits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-eq" = callPackage @@ -269300,8 +253003,6 @@ self: { libraryToolDepends = [ cpphs ]; description = "Type equality evidence you can carry around"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-equality" = callPackage @@ -269373,8 +253074,6 @@ self: { testHaskellDepends = [ base ]; description = "Collection of widely reimplemented type families"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-functions" = callPackage @@ -269419,8 +253118,6 @@ self: { ]; description = "Queues with verified and unverified versions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-int" = callPackage @@ -269432,8 +253129,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Type Level 2s- and 16s- Complement Integers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-interpreter" = callPackage @@ -269446,8 +253141,6 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Interpreter for Template Haskell types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-iso" = callPackage @@ -269486,8 +253179,6 @@ self: { libraryHaskellDepends = [ base ]; description = "type-level binary search trees in haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-level-integers" = callPackage @@ -269536,8 +253227,6 @@ self: { ]; description = "High-level combinators for performing inductive operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-level-natural-number-operations" = callPackage @@ -269549,8 +253238,6 @@ self: { libraryHaskellDepends = [ base type-level-natural-number ]; description = "Basic operations on type-level natural numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-level-numbers" = callPackage @@ -269598,8 +253285,6 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Operations on type-level lists and tuples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-map" = callPackage @@ -269675,8 +253360,6 @@ self: { testHaskellDepends = [ base type-of-html ]; description = "Optimize static parts of type-of-html"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-operators" = callPackage @@ -269701,8 +253384,6 @@ self: { ]; description = "Type-level comparison operator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-ord-spine-cereal" = callPackage @@ -269718,8 +253399,6 @@ self: { ]; description = "Generic type-level comparison of types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-prelude" = callPackage @@ -269731,8 +253410,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Partial port of prelude to the type level. Requires GHC 7.6.1."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-sets" = callPackage @@ -269745,8 +253422,6 @@ self: { testHaskellDepends = [ base cmptype ]; description = "Type-level sets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-settheory" = callPackage @@ -269762,8 +253437,6 @@ self: { ]; description = "Sets and functions-as-relations in the type system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-spec" = callPackage @@ -269787,8 +253460,6 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "A spine-view on types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-structure" = callPackage @@ -269815,8 +253486,6 @@ self: { ]; description = "Type structure analysis"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-sub-th" = callPackage @@ -269841,8 +253510,6 @@ self: { ]; description = "Substitute types for other types with Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-tree" = callPackage @@ -269860,8 +253527,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "Tree representations of datatypes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "type-unary" = callPackage @@ -269881,8 +253546,6 @@ self: { ]; description = "Type-level and typed unary natural numbers, inequality proofs, vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typeable-th" = callPackage @@ -269895,8 +253558,6 @@ self: { testHaskellDepends = [ base ]; description = "Automatic deriving of TypeableN instances with Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typecheck-plugin-nat-simple" = callPackage @@ -269989,8 +253650,6 @@ self: { ]; description = "Type safe string transformations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typed-encoding-encoding" = callPackage @@ -270010,8 +253669,6 @@ self: { ]; description = "Bridge between encoding and typed-encoding packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typed-process" = callPackage @@ -270050,8 +253707,6 @@ self: { executableHaskellDepends = [ base diagrams-lib text ]; description = "Typed and composable spreadsheets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typed-streams" = callPackage @@ -270073,8 +253728,6 @@ self: { ]; description = "A stream based replacement for lists"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typed-uuid" = callPackage @@ -270133,8 +253786,6 @@ self: { ]; description = "Language-independent type-safe communication"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typed-wire-utils" = callPackage @@ -270164,8 +253815,6 @@ self: { ]; description = "Typed frontend to TensorFlow and higher-order deep learning"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typedquery" = callPackage @@ -270182,8 +253831,6 @@ self: { ]; description = "Parser for SQL augmented with types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typehash" = callPackage @@ -270195,8 +253842,6 @@ self: { libraryHaskellDepends = [ base binary bytestring mtl pureMD5 syb ]; description = "Create a unique hash value for a type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typelevel" = callPackage @@ -270213,8 +253858,6 @@ self: { ]; description = "Useful type level operations (type families and related operators)"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typelevel-rewrite-rules" = callPackage @@ -270231,8 +253874,6 @@ self: { testHaskellDepends = [ base ghc-prim vinyl ]; description = "Solve type equalities using custom type-level rewrite rules"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typelevel-tensor" = callPackage @@ -270250,8 +253891,6 @@ self: { ]; description = "Tensors whose ranks and dimensions type-inferred and type-checked"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typelits-printf" = callPackage @@ -270287,8 +253926,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Type level numbers using existing Nat functionality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typeof" = callPackage @@ -270318,8 +253955,6 @@ self: { ]; description = "Lens-like interface for type level parameters; allows unboxed unboxed vectors and supercompilation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typerep-map" = callPackage @@ -270357,8 +253992,6 @@ self: { libraryHaskellDepends = [ base ]; description = "ghc-7.6/7.8 compatible GHC.TypeLits, Data.Typeable and Data.Proxy."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typesafe-endian" = callPackage @@ -270389,8 +254022,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Type-safe transformations and purifications of PreCures (Japanese Battle Heroine)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typescript-docs" = callPackage @@ -270410,8 +254041,6 @@ self: { ]; description = "A documentation generator for TypeScript Definition files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typical" = callPackage @@ -270449,8 +254078,6 @@ self: { ]; description = "Just let me draw nice text already"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typography-geometry" = callPackage @@ -270488,8 +254115,6 @@ self: { ]; description = "Typson Beam Integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typson-core" = callPackage @@ -270529,8 +254154,6 @@ self: { ]; description = "Typson Esqueleto Integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "typson-selda" = callPackage @@ -270553,8 +254176,6 @@ self: { ]; description = "Typson Selda Integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tyro" = callPackage @@ -270575,8 +254196,6 @@ self: { ]; description = "Type derived JSON parsing using Aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "tz" = callPackage @@ -270643,8 +254262,6 @@ self: { testHaskellDepends = [ base bytestring either-unwrap hspec text ]; description = "Haskell Universal Two Factor helper toolbox library thing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uAgda" = callPackage @@ -270722,8 +254339,6 @@ self: { testHaskellDepends = [ base hspec text ]; description = "Uber client for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uberlast" = callPackage @@ -270735,8 +254350,6 @@ self: { libraryHaskellDepends = [ base lens tagged template-haskell ]; description = "Generate overloaded lenses from plain data declaration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ucam-webauth" = callPackage @@ -270766,8 +254379,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "The Ucam-Webauth protocol, used by Raven"; license = "(BSD-3-Clause OR Apache-2.0)"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ucam-webauth-types" = callPackage @@ -270789,8 +254400,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Types for the Ucam-Webauth protocol, as used by Raven"; license = "(BSD-3-Clause OR Apache-2.0)"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ucd" = callPackage @@ -270809,8 +254418,6 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "Unicode Character Database — Predicates on characters specified by Unicode"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ucl" = callPackage @@ -270839,8 +254446,6 @@ self: { librarySystemDepends = [ icu ]; description = "String encoding conversion with ICU"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) icu;}; "udbus" = callPackage @@ -270918,8 +254523,6 @@ self: { ]; description = "Simple fire-and-forget conduit UDP wrappers"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "udp-streaming" = callPackage @@ -270933,8 +254536,6 @@ self: { ]; description = "Streaming to and from UDP socket"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uglymemo" = callPackage @@ -270973,8 +254574,6 @@ self: { ]; description = "Part of UHC packaged as cabal/hackage installable library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uhc-util" = callPackage @@ -270994,8 +254593,6 @@ self: { ]; description = "UHC utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uhexdump" = callPackage @@ -271009,8 +254606,6 @@ self: { executableHaskellDepends = [ base bytestring split ]; description = "hex dumper for UTF-8 text"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uhttpc" = callPackage @@ -271035,8 +254630,6 @@ self: { ]; description = "Minimal HTTP client library optimized for benchmarking"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ui-command" = callPackage @@ -271050,8 +254643,6 @@ self: { libraryHaskellDepends = [ base data-default mtl old-locale time ]; description = "A framework for friendly commandline programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uid" = callPackage @@ -271147,8 +254738,6 @@ self: { ]; description = "A fast, cache-efficient, concurrent bloom filter"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unagi-chan" = callPackage @@ -271203,8 +254792,6 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Functional concurrency with unamb using a custom scheduler"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unbeliever" = callPackage @@ -271247,8 +254834,6 @@ self: { ]; description = "Generic support for programming with names and binders"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unbound-generics" = callPackage @@ -271308,8 +254893,6 @@ self: { libraryHaskellDepends = [ base unbounded-delays units units-defs ]; description = "Thread delays and timeouts using proper time units"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unboxed" = callPackage @@ -271334,8 +254917,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Self-optimizing unboxed sets using view patterns and data families"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unboxed-ref" = callPackage @@ -271362,8 +254943,6 @@ self: { executableHaskellDepends = [ base vector ]; description = "A library for reference cells backed by unboxed-vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unboxing-vector" = callPackage @@ -271406,8 +254985,6 @@ self: { executableHaskellDepends = [ base bytestring cmdargs ]; description = "Secure and resilient remote file storage utility"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uncaught-exception" = callPackage @@ -271463,8 +255040,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Tiny package providing unescaping versions of show and print"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unexceptionalio" = callPackage @@ -271506,8 +255081,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Unfixing and recursion schemes for data types with binders"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unfoldable" = callPackage @@ -271561,8 +255134,6 @@ self: { libraryHaskellDepends = [ base containers uni-util ]; description = "Event handling for the uniform workbench"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uni-graphs" = callPackage @@ -271578,8 +255149,6 @@ self: { ]; description = "Graphs"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uni-htk" = callPackage @@ -271596,8 +255165,6 @@ self: { ]; description = "Graphical User Interface for Haskell Programs"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uni-posixutil" = callPackage @@ -271613,8 +255180,6 @@ self: { ]; description = "Posix utilities for the uniform workbench"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uni-reactor" = callPackage @@ -271629,8 +255194,6 @@ self: { ]; description = "Reactors for the uniform workbench"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uni-uDrawGraph" = callPackage @@ -271647,8 +255210,6 @@ self: { ]; description = "Graphs binding"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uni-util" = callPackage @@ -271665,8 +255226,6 @@ self: { ]; description = "Utilities for the uniform workbench"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unicode" = callPackage @@ -271751,8 +255310,6 @@ self: { librarySystemDepends = [ icu ]; description = "Unicode normalization using the ICU library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) icu;}; "unicode-prelude" = callPackage @@ -271764,8 +255321,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Unicode notation for some definitions in Prelude"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unicode-properties" = callPackage @@ -271789,8 +255344,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "print and show in unicode"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unicode-symbols" = callPackage @@ -271802,8 +255355,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Unicode alternatives for common functions and operators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unicode-transforms" = callPackage @@ -271843,8 +255394,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Functions to work with unicode blocks more convenient"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unicoder" = callPackage @@ -271956,8 +255505,6 @@ self: { testHaskellDepends = [ attoparsec base bytestring Cabal ]; description = "Uniform IO over files, network, anything"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) openssl;}; "uniform-pair" = callPackage @@ -272041,8 +255588,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq lens ]; description = "Extensible type-safe unions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "union-find" = callPackage @@ -272078,8 +255623,6 @@ self: { libraryHaskellDepends = [ base containers extensible ]; description = "Heterogeneous map by open unions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unipatterns" = callPackage @@ -272126,8 +255669,6 @@ self: { ]; description = "UniProt-KB format parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uniq-deep" = callPackage @@ -272201,8 +255742,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Splittable Unique Identifier Supply"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uniquely-represented-sets" = callPackage @@ -272219,8 +255758,6 @@ self: { ]; benchmarkHaskellDepends = [ base criterion random ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uniqueness-periods" = callPackage @@ -272296,8 +255833,6 @@ self: { ]; description = "Usage examples for the uniqueness-periods-vector series of packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uniqueness-periods-vector-filters" = callPackage @@ -272343,8 +255878,6 @@ self: { ]; description = "Metrices for the maximum element for the uniqueness-periods-vector packages family"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uniqueness-periods-vector-stats" = callPackage @@ -272416,8 +255949,6 @@ self: { ]; description = "Attoparsec parsers for the units package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "units-defs" = callPackage @@ -272458,8 +255989,6 @@ self: { testHaskellDepends = [ base ]; description = "An extendable library for type-safe computations including units"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unity-testresult-parser" = callPackage @@ -272519,8 +256048,6 @@ self: { libraryHaskellDepends = [ base unitym yesod ]; description = "Implementation of the unity monad for the Yesod framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "universal" = callPackage @@ -272552,8 +256079,6 @@ self: { libraryHaskellDepends = [ base binary bytestring ]; description = "Parser for OS X Universal Binary format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "universe" = callPackage @@ -272570,8 +256095,6 @@ self: { ]; description = "A class for finite and recursively enumerable types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "universe-base" = callPackage @@ -272609,8 +256132,6 @@ self: { libraryHaskellDepends = [ base universe-base ]; description = "Universe instances for types from the base package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "universe-instances-extended" = callPackage @@ -272628,8 +256149,6 @@ self: { ]; description = "Universe instances for types from selected extra packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "universe-instances-trans" = callPackage @@ -272643,8 +256162,6 @@ self: { libraryHaskellDepends = [ base universe-base ]; description = "Universe instances for types from the transformers and mtl packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "universe-reverse-instances" = callPackage @@ -272695,8 +256212,6 @@ self: { ]; description = "Construct a Dec's ancestor list"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "universum" = callPackage @@ -272771,8 +256286,6 @@ self: { libraryHaskellDepends = [ base foreign-var ]; description = "Comprehensive bindings to fcntl(2)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unix-handle" = callPackage @@ -272784,8 +256297,6 @@ self: { libraryHaskellDepends = [ base unix ]; description = "POSIX operations on Handles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unix-io-extra" = callPackage @@ -272835,8 +256346,6 @@ self: { ]; description = "Run processes on Unix systems, with a conduit interface (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unix-pty-light" = callPackage @@ -272865,8 +256374,6 @@ self: { benchmarkHaskellDepends = [ base criterion dir-traverse ]; description = "Fast and flexible primitives for recursive file system IO on Posix systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unix-simple" = callPackage @@ -272879,8 +256386,6 @@ self: { testHaskellDepends = [ base bytestring zenhack-prelude ]; description = "Straightforward bindings to the posix API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unix-time" = callPackage @@ -272975,8 +256480,6 @@ self: { libraryHaskellDepends = [ base ghc-prim semigroups ]; description = "GHC Haskell lists of non-thunks (things of kind TYPE 'UnliftedRep)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unliftio" = callPackage @@ -273073,8 +256576,6 @@ self: { ]; description = "Fast and robust message queues for concurrent processes"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unliftio-path" = callPackage @@ -273115,8 +256616,6 @@ self: { ]; description = "Generalization of io-streams to MonadUnliftIO"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unlit" = callPackage @@ -273146,8 +256645,6 @@ self: { ]; description = "A Library for the manipulation of images"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unmed2" = callPackage @@ -273201,8 +256698,6 @@ self: { ]; description = "Rematch support for unordered containers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unordered-graphs" = callPackage @@ -273218,8 +256713,6 @@ self: { ]; description = "Graph library using unordered-containers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unordered-intmap" = callPackage @@ -273236,8 +256729,6 @@ self: { ]; description = "A specialization of `HashMap Int v`"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unpack-funcs" = callPackage @@ -273253,8 +256744,6 @@ self: { ]; description = "Monad transformers that mirror worker-wrapper transformations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unpacked-containers" = callPackage @@ -273284,8 +256773,6 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked either data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unpacked-maybe" = callPackage @@ -273298,8 +256785,6 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked maybe data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unpacked-maybe-numeric" = callPackage @@ -273314,8 +256799,6 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "maybes of numeric values with fewer indirections"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unpacked-maybe-text" = callPackage @@ -273343,8 +256826,6 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked these data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unpacked-validation" = callPackage @@ -273361,8 +256842,6 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked validation data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unparse-attoparsec" = callPackage @@ -273383,8 +256862,6 @@ self: { ]; description = "An attoparsec roundtrip"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unroll-ghc-plugin" = callPackage @@ -273396,8 +256873,6 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Compiler plugin for loop unrolling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unsafe" = callPackage @@ -273434,8 +256909,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Flexible access control for unsafe operations and instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unsafeperformst" = callPackage @@ -273466,8 +256939,6 @@ self: { ]; description = "Solve Boggle-like word games"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unsequential" = callPackage @@ -273486,8 +256957,6 @@ self: { ]; description = "An extension removing the sequentiality from monads"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unusable-pkg" = callPackage @@ -273529,8 +256998,6 @@ self: { testHaskellDepends = [ base containers hspec text ]; description = "A command line tool to identify unused code"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "unwrapped-functors" = callPackage @@ -273560,8 +257027,6 @@ self: { testHaskellDepends = [ base hlint tasty tasty-hunit ]; description = "Units of measure as a GHC typechecker plugin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "up" = callPackage @@ -273579,8 +257044,6 @@ self: { ]; description = "Command-line tool to generate paths for moving upward in a file system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "up-grade" = callPackage @@ -273674,8 +257137,6 @@ self: { ]; description = "Haskell client for Uploadcare"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uploadtest" = callPackage @@ -273698,8 +257159,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Binding to upskirt"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urbit-airlock" = callPackage @@ -273716,8 +257175,6 @@ self: { ]; description = "Talk to Urbit from Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urbit-api" = callPackage @@ -273734,8 +257191,6 @@ self: { ]; description = "Talk to Urbit from Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urbit-hob" = callPackage @@ -273751,8 +257206,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Hoon-style atom manipulation and printing functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ureader" = callPackage @@ -273776,8 +257229,6 @@ self: { ]; description = "Minimalistic CLI RSS reader"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urembed" = callPackage @@ -273798,8 +257249,6 @@ self: { ]; description = "Ur/Web static content generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri" = callPackage @@ -273811,8 +257260,6 @@ self: { libraryHaskellDepends = [ base parsec safe utf8-string ]; description = "Library for working with URIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri-bytestring" = callPackage @@ -273871,8 +257318,6 @@ self: { ]; description = "Read and write URIs (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri-encode" = callPackage @@ -273910,8 +257355,6 @@ self: { ]; description = "A uri encoder to make your strings less readable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri-enumerator" = callPackage @@ -273928,8 +257371,6 @@ self: { ]; description = "Read and write URIs (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri-enumerator-file" = callPackage @@ -273948,8 +257389,6 @@ self: { ]; description = "uri-enumerator backend for the file scheme (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri-parse" = callPackage @@ -273966,8 +257405,6 @@ self: { testHaskellDepends = [ base data-default hspec lens ]; description = "A simple library for parsing and generating URIs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri-template" = callPackage @@ -273982,8 +257419,6 @@ self: { executableHaskellDepends = [ base ]; description = "URI template library for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uri-templater" = callPackage @@ -274007,8 +257442,6 @@ self: { ]; description = "Parsing & Quasiquoting for RFC 6570 URI Templates"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "url" = callPackage @@ -274043,8 +257476,6 @@ self: { ]; description = "Memory efficient url type and parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "url-decoders" = callPackage @@ -274067,8 +257498,6 @@ self: { benchmarkHaskellDepends = [ criterion http-types rerebase ]; description = "Decoders for URL-encoding (aka Percent-encoding)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "url-generic" = callPackage @@ -274082,8 +257511,6 @@ self: { libraryHaskellDepends = [ base mtl syb ]; description = "Parse/format generic key/value URLs from record data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urlcheck" = callPackage @@ -274101,8 +257528,6 @@ self: { ]; description = "Parallel link checker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urldecode" = callPackage @@ -274116,8 +257541,6 @@ self: { executableHaskellDepends = [ base network ]; description = "Decode percent-encoded strings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urldisp-happstack" = callPackage @@ -274129,8 +257552,6 @@ self: { libraryHaskellDepends = [ base bytestring happstack-server mtl ]; description = "Simple, declarative, expressive URL routing -- on happstack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urlencoded" = callPackage @@ -274146,8 +257567,6 @@ self: { testHaskellDepends = [ base network network-uri QuickCheck ]; description = "Generate or process x-www-urlencoded data"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urlpath" = callPackage @@ -274167,8 +257586,6 @@ self: { ]; description = "Painfully simple URL deployment"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urn" = callPackage @@ -274181,8 +257598,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Universal Resource Names"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urn-random" = callPackage @@ -274199,8 +257614,6 @@ self: { ]; description = "A package for updatable discrete distributions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "urxml" = callPackage @@ -274218,8 +257631,6 @@ self: { ]; description = "XML parser-printer supporting Ur/Web syntax extensions"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "usa-holidays" = callPackage @@ -274246,8 +257657,6 @@ self: { ]; description = "Communicate with USB devices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "usb-enumerator" = callPackage @@ -274264,8 +257673,6 @@ self: { ]; description = "Iteratee enumerators for the usb package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "usb-hid" = callPackage @@ -274279,8 +257686,6 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring usb ]; description = "Parser and request Library for USB HIDs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "usb-id-database" = callPackage @@ -274300,8 +257705,6 @@ self: { ]; description = "A database of USB identifiers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "usb-iteratee" = callPackage @@ -274318,8 +257721,6 @@ self: { ]; description = "Iteratee enumerators for the usb package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "usb-safe" = callPackage @@ -274336,8 +257737,6 @@ self: { ]; description = "Type-safe communication with USB devices"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "useragents" = callPackage @@ -274367,8 +257766,6 @@ self: { ]; description = "The UserId type and useful instances for web development"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "users" = callPackage @@ -274403,8 +257800,6 @@ self: { ]; description = "A mysql-haskell backend for the users library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "users-persistent" = callPackage @@ -274425,8 +257820,6 @@ self: { ]; description = "A persistent backend for the users package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "users-postgresql-simple" = callPackage @@ -274488,8 +257881,6 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "UTF-8"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "utf8-conversions" = callPackage @@ -274544,8 +257935,6 @@ self: { libraryHaskellDepends = [ base utf8-string ]; description = "Variants of Prelude and System.IO with UTF8 text I/O operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "utf8-string" = callPackage @@ -274575,8 +257964,6 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Constant-space UTF8 validator for ByteStrings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "util" = callPackage @@ -274603,8 +257990,6 @@ self: { libraryHaskellDepends = [ base basic control lifted-base-tf util ]; description = "Exceptional utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "util-logict" = callPackage @@ -274618,8 +258003,6 @@ self: { benchmarkHaskellDepends = [ base gauge logict ]; description = "See README for more info"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "util-plus" = callPackage @@ -274636,8 +258019,6 @@ self: { testHaskellDepends = [ base containers HTF QuickCheck ]; description = "A collection of commonly used utils"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "util-primitive" = callPackage @@ -274651,8 +258032,6 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "Primitive memory-related utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "util-primitive-control" = callPackage @@ -274669,8 +258048,6 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Utilities for stateful primitive types and types based on them"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "util-universe" = callPackage @@ -274689,8 +258066,6 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Utilities for universal types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "utility-ht" = callPackage @@ -274718,8 +258093,6 @@ self: { libraryHaskellDepends = [ ansi-terminal base ]; description = "Utilities for compiler construction: core functionality"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uu-cco-examples" = callPackage @@ -274733,8 +258106,6 @@ self: { executableHaskellDepends = [ base uu-cco uuagc uuagc-cabal ]; description = "Utilities for compiler construction: example programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uu-cco-hut-parsing" = callPackage @@ -274746,8 +258117,6 @@ self: { libraryHaskellDepends = [ base uu-cco uulib ]; description = "Utilities for compiler construction: Feedback wrapper around parser in uulib"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uu-cco-uu-parsinglib" = callPackage @@ -274759,8 +258128,6 @@ self: { libraryHaskellDepends = [ base ListLike uu-cco uu-parsinglib ]; description = "Utilities for compiler construction: Feedback wrapper around parser in uu-parsinglib"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uu-interleaved" = callPackage @@ -274858,8 +258225,6 @@ self: { ]; description = "Attribute Grammar System of Universiteit Utrecht"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uuagc-cabal" = callPackage @@ -274886,8 +258251,6 @@ self: { libraryHaskellDepends = [ base diagrams-lib SVGFonts ]; description = "Utility for drawing attribute grammar pictures with the diagrams package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uuagd" = callPackage @@ -274938,8 +258301,6 @@ self: { libraryHaskellDepends = [ aeson base text uuid ]; description = "Aeson types for UUID instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uuid-bytes" = callPackage @@ -274960,8 +258321,6 @@ self: { ]; description = "UUID parsing using byteverse packages"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uuid-crypto" = callPackage @@ -274980,8 +258339,6 @@ self: { ]; description = "Reversable and secure encoding of object ids as uuids"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uuid-le" = callPackage @@ -275085,8 +258442,6 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Fast unboxed arrays with a flexible interface"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uvector-algorithms" = callPackage @@ -275098,8 +258453,6 @@ self: { libraryHaskellDepends = [ base uvector ]; description = "Efficient algorithms for uvector unboxed arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uxadt" = callPackage @@ -275111,8 +258464,6 @@ self: { libraryHaskellDepends = [ base json MissingH mtl ]; description = "Cross-language extensible representation for algebraic data type instances"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "uzbl-with-source" = callPackage @@ -275140,8 +258491,6 @@ self: { ]; description = "interface to Video For Linux Two (V4L2)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "v4l2-examples" = callPackage @@ -275155,8 +258504,6 @@ self: { executableHaskellDepends = [ base GLUT v4l2 ]; description = "video for linux two examples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vabal" = callPackage @@ -275178,8 +258525,6 @@ self: { testHaskellDepends = [ base process ]; description = "the cabal companion"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vabal-lib" = callPackage @@ -275197,8 +258542,6 @@ self: { testHaskellDepends = [ base Cabal containers ]; description = "Core algorithms and datatypes used by vabal"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vacuum" = callPackage @@ -275210,8 +258553,6 @@ self: { libraryHaskellDepends = [ array base containers ghc-prim ]; description = "Graph representation of the GHC heap"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vacuum-cairo" = callPackage @@ -275228,8 +258569,6 @@ self: { ]; description = "Visualize live Haskell data structures using vacuum, graphviz and cairo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vacuum-graphviz" = callPackage @@ -275241,8 +258580,6 @@ self: { libraryHaskellDepends = [ base filepath graphviz vacuum ]; description = "A library for transforming vacuum graphs into GraphViz output"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vacuum-opengl" = callPackage @@ -275262,8 +258599,6 @@ self: { ]; description = "Visualize live Haskell data structures using vacuum, graphviz and OpenGL"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vacuum-ubigraph" = callPackage @@ -275275,8 +258610,6 @@ self: { libraryHaskellDepends = [ base containers hubigraph vacuum ]; description = "Visualize Haskell data structures using vacuum and Ubigraph"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vado" = callPackage @@ -275322,8 +258655,6 @@ self: { libraryHaskellDepends = [ base containers MonadRandom ]; description = "Valid operator/module characters"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "validate" = callPackage @@ -275352,8 +258683,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Input validation combinator library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "validated-literals" = callPackage @@ -275385,8 +258714,6 @@ self: { testHaskellDepends = [ base ]; description = "Type-level constraints on strings and other input"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "validation" = callPackage @@ -275440,8 +258767,6 @@ self: { ]; description = "A nice way to define field validations in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "validationt" = callPackage @@ -275652,8 +258977,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for generating values without having to thread state"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vampire" = callPackage @@ -275676,8 +258999,6 @@ self: { ]; description = "Analyze and visualize expression trees"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "var" = callPackage @@ -275695,8 +259016,6 @@ self: { benchmarkHaskellDepends = [ array base criterion deepseq ]; description = "Mutable variables and tuples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "var-monad" = callPackage @@ -275726,8 +259045,6 @@ self: { ]; description = "Process mpileup output to identify significant differences"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "variable-precision" = callPackage @@ -275744,8 +259061,6 @@ self: { ]; description = "variable-precision floating point"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "variables" = callPackage @@ -275758,8 +259073,6 @@ self: { testHaskellDepends = [ base hspec mtl QuickCheck stm ]; description = "Monads with variables, without deep magic"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "variadic" = callPackage @@ -275791,8 +259104,6 @@ self: { ]; description = "nominal value with possible variations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "varying" = callPackage @@ -275866,8 +259177,6 @@ self: { ]; description = "Utility library for spawning a HashiCorp Vault process"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vault-trans" = callPackage @@ -275884,8 +259193,6 @@ self: { ]; description = "A monad transformer for vault-tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vaultaire-common" = callPackage @@ -275909,8 +259216,6 @@ self: { ]; description = "Common types and instances for Vaultaire"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vcache" = callPackage @@ -275927,8 +259232,6 @@ self: { ]; description = "semi-transparent persistence for Haskell using LMDB, STM"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vcache-trie" = callPackage @@ -275944,8 +259247,6 @@ self: { ]; description = "patricia tries modeled above VCache"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vcard" = callPackage @@ -275959,8 +259260,6 @@ self: { ]; description = "A library for parsing/printing vCards from/to various formats"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vcatt" = callPackage @@ -275975,8 +259274,6 @@ self: { executableHaskellDepends = [ base shelly text ]; description = "Recursively check that a directory is under version control"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vcd" = callPackage @@ -276004,8 +259301,6 @@ self: { ]; description = "A package to parse VCF files inspired in similar python libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vcs-revision" = callPackage @@ -276051,8 +259346,6 @@ self: { ]; description = "GUI library for source code management systems"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vcswrapper" = callPackage @@ -276076,8 +259369,6 @@ self: { ]; description = "Wrapper for source code management systems"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vec" = callPackage @@ -276144,8 +259435,6 @@ self: { libraryHaskellDepends = [ base random ]; description = "A low-dimensional linear algebra library, operating on the Floating typeclass"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vect-floating-accelerate" = callPackage @@ -276159,8 +259448,6 @@ self: { libraryHaskellDepends = [ accelerate base vect-floating ]; description = "Accelerate instances for vect-floating types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vect-opengl" = callPackage @@ -276172,8 +259459,6 @@ self: { libraryHaskellDepends = [ base OpenGL vect ]; description = "OpenGL support for the `vect' low-dimensional linear algebra library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector" = callPackage @@ -276297,8 +259582,6 @@ self: { testHaskellDepends = [ base directory QuickCheck random ]; description = "ByteStrings as type synonyms of Storable Vectors of Word8s"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-circular" = callPackage @@ -276336,8 +259619,6 @@ self: { ]; description = "Vector clocks for versioning message flows"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-conduit" = callPackage @@ -276356,8 +259637,6 @@ self: { ]; description = "Conduit utilities for vectors"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-doublezip" = callPackage @@ -276383,8 +259662,6 @@ self: { doHaddock = false; description = "Storable vectors with cpu-independent representation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-extras" = callPackage @@ -276430,8 +259707,6 @@ self: { ]; description = "A binding to the fftw library for one-dimensional vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fftw;}; "vector-functorlazy" = callPackage @@ -276446,8 +259721,6 @@ self: { ]; description = "vectors that perform the fmap operation in constant time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-heterogenous" = callPackage @@ -276459,8 +259732,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "A type-safe library for vectors whose elements can be of any type, or any type satisfying some constraints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-instances" = callPackage @@ -276489,8 +259760,6 @@ self: { ]; description = "Instances of the Data.Collections classes for Data.Vector.*"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-mmap" = callPackage @@ -276518,8 +259787,6 @@ self: { libraryHaskellDepends = [ base mersenne-random-pure64 vector ]; description = "Generate vectors filled with high quality pseudorandom numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-read-instances" = callPackage @@ -276531,8 +259798,6 @@ self: { libraryHaskellDepends = [ base vector ]; description = "(deprecated) Read instances for 'Data.Vector'"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-rotcev" = callPackage @@ -276596,8 +259861,6 @@ self: { testHaskellDepends = [ base doctest ]; description = "vector-space operations for finite maps using Data.Map"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-space-opengl" = callPackage @@ -276615,8 +259878,6 @@ self: { ]; description = "Instances of vector-space classes for OpenGL types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-space-points" = callPackage @@ -276630,8 +259891,6 @@ self: { libraryHaskellDepends = [ base vector-space ]; description = "A type for points, as distinct from vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-split" = callPackage @@ -276659,8 +259918,6 @@ self: { libraryHaskellDepends = [ base primitive vector ]; description = "Statically checked sizes on Data.Vector"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-strategies" = callPackage @@ -276687,8 +259944,6 @@ self: { ]; description = "Text implementation based on unboxed char vector"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vector-th-unbox" = callPackage @@ -276747,8 +260002,6 @@ self: { ]; description = "Easily view Vega or Vega-Lite visualizations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "venzone" = callPackage @@ -276775,8 +260028,6 @@ self: { ]; description = "ASCII platform-adventure game"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "verbalexpressions" = callPackage @@ -276788,8 +260039,6 @@ self: { libraryHaskellDepends = [ base regex-pcre ]; description = "Regular expressions made easy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "verbosity" = callPackage @@ -276822,8 +260071,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Validation framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "verdict-json" = callPackage @@ -276844,8 +260091,6 @@ self: { ]; description = "JSON instances and JSON Schema for verdict"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "verifiable-expressions" = callPackage @@ -276861,8 +260106,6 @@ self: { ]; description = "An intermediate language for Hoare logic style verification"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "verify" = callPackage @@ -276885,8 +260128,6 @@ self: { ]; description = "A new Haskeleton package"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "verilog" = callPackage @@ -276899,8 +260140,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "Verilog preprocessor, parser, and AST"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "verismith" = callPackage @@ -276937,8 +260176,6 @@ self: { benchmarkHaskellDepends = [ base criterion lens ]; description = "Random verilog generation and simulator testing"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "versioning" = callPackage @@ -276951,8 +260188,6 @@ self: { testHaskellDepends = [ aeson base bytestring hspec ]; description = "Type-safe data versioning"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "versioning-servant" = callPackage @@ -276973,8 +260208,6 @@ self: { ]; description = "Servant combinators for the versioning library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "versions" = callPackage @@ -277036,8 +260269,6 @@ self: { ]; description = "types for ingesting vflow data with aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vformat" = callPackage @@ -277115,8 +260346,6 @@ self: { ]; description = "VFR waypoints, as published in the AIP (ERSA)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vgrep" = callPackage @@ -277148,8 +260377,6 @@ self: { ]; description = "A pager for grep"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vhd" = callPackage @@ -277175,8 +260402,6 @@ self: { ]; description = "Provides functions to inspect and manipulate virtual hard disk (VHD) files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vhdl" = callPackage @@ -277188,8 +260413,6 @@ self: { libraryHaskellDepends = [ base mtl pretty regex-posix ]; description = "VHDL AST and pretty printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vicinity" = callPackage @@ -277205,8 +260428,6 @@ self: { base containers doctest QuickCheck quickcheck-classes ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "viewprof" = callPackage @@ -277225,8 +260446,6 @@ self: { ]; description = "Text-based interactive GHC .prof viewer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "views" = callPackage @@ -277238,8 +260457,6 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Views allow you to run a State monad on part of a state"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vigilance" = callPackage @@ -277280,8 +260497,6 @@ self: { ]; description = "An extensible dead-man's switch system"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vimeta" = callPackage @@ -277308,8 +260523,6 @@ self: { ]; description = "Frontend for video metadata tagging tools"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vimus" = callPackage @@ -277339,8 +260552,6 @@ self: { ]; description = "An MPD client with vim-like key bindings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) ncurses;}; "vintage-basic" = callPackage @@ -277361,8 +260572,6 @@ self: { testHaskellDepends = [ base ]; description = "Interpreter for microcomputer-era BASIC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vinyl" = callPackage @@ -277439,8 +260648,6 @@ self: { testHaskellDepends = [ base hlint ]; description = "Provide json instances automagically to vinyl types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vinyl-loeb" = callPackage @@ -277463,8 +260670,6 @@ self: { libraryHaskellDepends = [ base vinyl ]; description = "Syntax sugar for vinyl records using overloaded labels"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vinyl-operational" = callPackage @@ -277479,8 +260684,6 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vinyl-plus" = callPackage @@ -277500,8 +260703,6 @@ self: { testHaskellDepends = [ base doctest vinyl ]; description = "Vinyl records utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vinyl-utils" = callPackage @@ -277513,8 +260714,6 @@ self: { libraryHaskellDepends = [ base contravariant transformers vinyl ]; description = "Utilities for vinyl"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vinyl-vectors" = callPackage @@ -277533,8 +260732,6 @@ self: { ]; description = "Vectors for vinyl vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "virthualenv" = callPackage @@ -277554,8 +260751,6 @@ self: { ]; description = "Virtual Haskell Environment builder"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "visibility" = callPackage @@ -277567,8 +260762,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple computation of visibility polygons"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vision" = callPackage @@ -277590,8 +260783,6 @@ self: { ]; description = "An XMMS2 client"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "visual-graphrewrite" = callPackage @@ -277619,8 +260810,6 @@ self: { ]; description = "Visualize the graph-rewrite steps of a Haskell program"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "visual-prof" = callPackage @@ -277639,8 +260828,6 @@ self: { ]; description = "Create a visual profile of a program's source code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "visualize-cbn" = callPackage @@ -277660,8 +260847,6 @@ self: { ]; description = "Visualize CBN reduction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vitrea" = callPackage @@ -277673,8 +260858,6 @@ self: { libraryHaskellDepends = [ base mtl profunctors ]; description = "Profunctor optics via the profunctor representation theorem"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vivid" = callPackage @@ -277743,8 +260926,6 @@ self: { ]; description = "Amazon Route53 DNS service plugin for the aws package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vk-posix-pty" = callPackage @@ -277783,8 +260964,6 @@ self: { libraryHaskellDepends = [ base random vector vector-fftw ]; description = "Phase vocoder"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vocoder-audio" = callPackage @@ -277803,8 +260982,6 @@ self: { ]; description = "Phase vocoder for conduit-audio"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vocoder-conduit" = callPackage @@ -277826,8 +261003,6 @@ self: { ]; description = "Phase vocoder for Conduit"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vocoder-dunai" = callPackage @@ -277849,8 +261024,6 @@ self: { ]; description = "Phase vocoder for Dunai and Rhine"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "voicebase" = callPackage @@ -277875,8 +261048,6 @@ self: { testHaskellDepends = [ aeson base hspec roundtrip-aeson ]; description = "Upload audio files to voicebase to get a transcription"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "void" = callPackage @@ -277913,8 +261084,6 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Vowpal Wabbit utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "voyeur" = callPackage @@ -277926,8 +261095,6 @@ self: { libraryHaskellDepends = [ base bytestring process utf8-string ]; description = "Haskell bindings for libvoyeur"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vp-tree" = callPackage @@ -277968,8 +261135,6 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Priority queue based on vector"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vrpn" = callPackage @@ -278030,8 +261195,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the VTE library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) vte;}; "vtegtk3" = callPackage @@ -278049,8 +261212,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the VTE library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) vte;}; "vty" = callPackage @@ -278108,8 +261269,6 @@ self: { ]; description = "Examples programs using the vty library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vty-menu" = callPackage @@ -278123,8 +261282,6 @@ self: { libraryHaskellDepends = [ base vty ]; description = "A lib for displaying a menu and getting a selection using VTY"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vty-ui" = callPackage @@ -278146,8 +261303,6 @@ self: { executableHaskellDepends = [ base QuickCheck random text vty ]; description = "An interactive terminal user interface library for Vty"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vty-ui-extras" = callPackage @@ -278159,8 +261314,6 @@ self: { libraryHaskellDepends = [ base regex-base regex-pcre vty vty-ui ]; description = "Extra vty-ui functionality not included in the core library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vulkan" = callPackage @@ -278185,8 +261338,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Low-level low-overhead vulkan api bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "vulkan-utils" = callPackage @@ -278249,8 +261400,6 @@ self: { ]; description = "JSON wrangling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wacom-daemon" = callPackage @@ -278274,8 +261423,6 @@ self: { ]; description = "Manage Wacom tablet settings profiles, including Intuos Pro ring modes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "waddle" = callPackage @@ -278298,8 +261445,6 @@ self: { ]; description = "DOOM WAD file utilities"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wahsp" = callPackage @@ -278320,8 +261465,6 @@ self: { ]; description = "A haskell binding of the Web Audio API ala blank-canvas"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai" = callPackage @@ -278441,8 +261584,6 @@ self: { ]; description = "Command line runner for Wai apps (using Warp) with TLS, CGI, socket activation & graceful shutdown"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-conduit" = callPackage @@ -278526,8 +261667,6 @@ self: { testHaskellDepends = [ base hspec stm ]; description = "A web server for the development of WAI compliant web applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-digestive-functors" = callPackage @@ -278678,8 +261817,6 @@ self: { ]; description = "Git http-backend CGI App of WAI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-graceful" = callPackage @@ -278691,8 +261828,6 @@ self: { libraryHaskellDepends = [ base http-types mtl resourcet unix wai ]; description = "Graceful shutdown for WAI applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-handler-devel" = callPackage @@ -278713,8 +261848,6 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "WAI server that automatically reloads code after modification. (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-handler-fastcgi" = callPackage @@ -278727,8 +261860,6 @@ self: { librarySystemDepends = [ fcgi ]; description = "Wai handler to fastcgi"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) fcgi;}; "wai-handler-hal" = callPackage @@ -278746,8 +261877,6 @@ self: { ]; description = "Wrap WAI applications to run on AWS Lambda"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-handler-launch" = callPackage @@ -278775,8 +261904,6 @@ self: { libraryHaskellDepends = [ base bytestring wai wai-extra ]; description = "Wai handler to SCGI (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-handler-snap" = callPackage @@ -278793,8 +261920,6 @@ self: { ]; description = "Web Application Interface handler using snap-server. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-handler-webkit" = callPackage @@ -278807,8 +261932,6 @@ self: { libraryPkgconfigDepends = [ QtWebKit ]; description = "Turn WAI applications into standalone GUIs using QtWebkit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {QtWebKit = null;}; "wai-hastache" = callPackage @@ -278847,8 +261970,6 @@ self: { ]; description = "hmac authentication tools for WAI apps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-http2-extra" = callPackage @@ -278905,8 +262026,6 @@ self: { ]; description = "Lenses for WAI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-lite" = callPackage @@ -278922,8 +262041,6 @@ self: { ]; description = "DEPCRECATED (use package \"simple\" instead) A minimalist web framework for WAI web applications"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-log" = callPackage @@ -278980,8 +262097,6 @@ self: { ]; description = "Buffer requets before logging them"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-logger-prefork" = callPackage @@ -278998,8 +262113,6 @@ self: { ]; description = "A logging system for preforked WAI apps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-make-assets" = callPackage @@ -279029,8 +262142,6 @@ self: { ]; description = "Compiling and serving assets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-auth" = callPackage @@ -279116,8 +262227,6 @@ self: { ]; description = "Caching middleware for WAI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-cache-redis" = callPackage @@ -279136,8 +262245,6 @@ self: { ]; description = "Redis backend for wai-middleware-cache"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-caching" = callPackage @@ -279200,8 +262307,6 @@ self: { ]; description = "Wai error catching middleware"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-clacks" = callPackage @@ -279243,8 +262348,6 @@ self: { ]; description = "Wai Middleware for Consul"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-content-type" = callPackage @@ -279277,8 +262380,6 @@ self: { ]; description = "Route to different middlewares based on the incoming Accept header"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-crowd" = callPackage @@ -279310,8 +262411,6 @@ self: { ]; description = "Middleware and utilities for using Atlassian Crowd authentication"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-delegate" = callPackage @@ -279338,8 +262437,6 @@ self: { ]; description = "WAI middleware that delegates handling of requests"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-etag" = callPackage @@ -279357,8 +262454,6 @@ self: { ]; description = "WAI ETag middleware for static files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-gunzip" = callPackage @@ -279385,8 +262480,6 @@ self: { libraryHaskellDepends = [ base bytestring http-types wai ]; description = "cors and addHeaders for WAI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-hmac" = callPackage @@ -279429,8 +262522,6 @@ self: { ]; description = "WAI HMAC Authentication Middleware Client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-json-errors" = callPackage @@ -279489,8 +262580,6 @@ self: { ]; description = "WAI middleware for preprocessing static files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-prometheus" = callPackage @@ -279524,8 +262613,6 @@ self: { ]; description = "Middleware that communicates to Rollbar"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-route" = callPackage @@ -279546,8 +262633,6 @@ self: { ]; description = "Wai dispatch middleware"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-slack-verify" = callPackage @@ -279614,8 +262699,6 @@ self: { ]; description = "WAI middleware that serves requests to static files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-static-embedded" = callPackage @@ -279675,8 +262758,6 @@ self: { ]; description = "WAI middleware for authenticating webhook payloads from Travis CI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-validation" = callPackage @@ -279698,8 +262779,6 @@ self: { ]; description = "WAI Middleware to validate the request and response bodies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-middleware-verbs" = callPackage @@ -279770,8 +262849,6 @@ self: { ]; description = "Redis backend for rate limiting as WAI middleware"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-request-spec" = callPackage @@ -279790,8 +262867,6 @@ self: { ]; description = "Declarative request parsing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-responsible" = callPackage @@ -279803,8 +262878,6 @@ self: { libraryHaskellDepends = [ base bytestring http-types wai ]; description = "Response interface for WAI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-route" = callPackage @@ -279838,8 +262911,6 @@ self: { libraryHaskellDepends = [ base text wai ]; description = "Provides basic routing on URL paths for WAI"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-routes" = callPackage @@ -279864,8 +262935,6 @@ self: { ]; description = "Typesafe URLs for Wai applications"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-routing" = callPackage @@ -279892,8 +262961,6 @@ self: { ]; description = "Declarative routing for WAI"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-saml2" = callPackage @@ -279934,8 +263001,6 @@ self: { wai-extra ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-session" = callPackage @@ -279970,8 +263035,6 @@ self: { ]; description = "An alternative session middleware for WAI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-session-clientsession" = callPackage @@ -280009,8 +263072,6 @@ self: { ]; description = "MySQL backed Wai session store"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-session-postgresql" = callPackage @@ -280033,8 +263094,6 @@ self: { ]; description = "PostgreSQL backed Wai session store"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-session-redis" = callPackage @@ -280060,8 +263119,6 @@ self: { ]; description = "Simple Redis backed wai-session backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-session-tokyocabinet" = callPackage @@ -280110,8 +263167,6 @@ self: { ]; description = "A simple cache for serving static files in a WAI middleware"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-static-pages" = callPackage @@ -280155,8 +263210,6 @@ self: { ]; description = "Thrift transport layer for Wai"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-throttler" = callPackage @@ -280172,8 +263225,6 @@ self: { ]; description = "Wai middleware for request throttling"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wai-transformers" = callPackage @@ -280253,8 +263304,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A wrapping library for waitfree computation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "waitra" = callPackage @@ -280279,8 +263328,6 @@ self: { ]; description = "A very simple Wai router"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wakame" = callPackage @@ -280331,8 +263378,6 @@ self: { ]; description = "A generator of comics based on some ascertainable data about the requester"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wallpaper" = callPackage @@ -280354,8 +263399,6 @@ self: { testHaskellDepends = [ base ]; description = "A library and executable for creating wallpaper, frieze, and rosette patterns"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "warc" = callPackage @@ -280384,8 +263427,6 @@ self: { ]; description = "A parser for the Web Archive (WARC) format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "warp" = callPackage @@ -280435,8 +263476,6 @@ self: { executableHaskellDepends = [ base ]; description = "Dynamic configurable warp HTTP server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "warp-grpc" = callPackage @@ -280454,8 +263493,6 @@ self: { ]; description = "A minimal gRPC server on top of Warp"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "warp-static" = callPackage @@ -280476,8 +263513,6 @@ self: { ]; description = "Static file server based on Warp and wai-app-static (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "warp-systemd" = callPackage @@ -280489,8 +263524,6 @@ self: { libraryHaskellDepends = [ base network systemd unix wai warp ]; description = "Socket activation and other systemd integration for the Warp web server (WAI)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "warp-tls" = callPackage @@ -280544,8 +263577,6 @@ self: { ]; description = "Warp and Wai Library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wasm" = callPackage @@ -280574,8 +263605,6 @@ self: { testToolDepends = [ alex happy ]; description = "WebAssembly Language Toolkit and Interpreter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "watchdog" = callPackage @@ -280589,8 +263618,6 @@ self: { libraryHaskellDepends = [ base mtl time ]; description = "Simple control structure to re-try an action with exponential backoff"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "watcher" = callPackage @@ -280607,8 +263634,6 @@ self: { ]; description = "Opinionated filesystem watcher"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "watchit" = callPackage @@ -280637,8 +263662,6 @@ self: { ]; description = "File change watching utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wavconvert" = callPackage @@ -280689,8 +263712,6 @@ self: { ]; description = "Wavefront OBJ loader"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wavefront-obj" = callPackage @@ -280709,8 +263730,6 @@ self: { testHaskellDepends = [ base hspec linear ]; description = "Wavefront .obj file loader"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wavesurfer" = callPackage @@ -280727,8 +263746,6 @@ self: { ]; description = "Parse WaveSurfer files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wavy" = callPackage @@ -280749,8 +263766,6 @@ self: { ]; description = "Process WAVE files in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wcwidth" = callPackage @@ -280786,8 +263801,6 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Mutable bag backed by weak pointers to each item"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "weather-api" = callPackage @@ -280804,8 +263817,6 @@ self: { ]; description = "Weather API implemented in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-browser-in-haskell" = callPackage @@ -280829,8 +263840,6 @@ self: { libraryHaskellDepends = [ base text ]; description = "Simple functions for CSS"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-encodings" = callPackage @@ -280848,8 +263857,6 @@ self: { ]; description = "Encapsulate multiple web encoding in a single package. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-fpco" = callPackage @@ -280903,8 +263910,6 @@ self: { ]; description = "Bindings for the Mongrel2 web server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-output" = callPackage @@ -280923,8 +263928,6 @@ self: { ]; description = "Library to present content to an user via their browser"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-page" = callPackage @@ -280944,8 +263947,6 @@ self: { ]; description = "Monoidally construct web pages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-plugins" = callPackage @@ -280982,8 +263983,6 @@ self: { ]; description = "Send messages using Web Push protocol"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-rep" = callPackage @@ -281013,8 +264012,6 @@ self: { ]; description = "representations of a web page"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-routes" = callPackage @@ -281107,8 +264104,6 @@ self: { libraryHaskellDepends = [ base path-pieces template-haskell text ]; description = "Define data types and parse/build functions for web-routes via a quasi-quoted DSL (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-routes-regular" = callPackage @@ -281120,8 +264115,6 @@ self: { libraryHaskellDepends = [ base parsec regular text web-routes ]; description = "portable, type-safe URL routing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-routes-th" = callPackage @@ -281149,8 +264142,6 @@ self: { libraryHaskellDepends = [ base transformers web-routes ]; description = "Extends web-routes with some transformers instances for RouteT"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web-routes-wai" = callPackage @@ -281185,8 +264176,6 @@ self: { benchmarkHaskellDepends = [ base criterion text ]; description = "simple routing library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "web3" = callPackage @@ -281226,8 +264215,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Web3 API for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webapi" = callPackage @@ -281254,8 +264241,6 @@ self: { ]; description = "WAI based library for web api"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webapp" = callPackage @@ -281278,8 +264263,6 @@ self: { ]; description = "Haskell web app framework based on WAI & Warp"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webauthn" = callPackage @@ -281299,8 +264282,6 @@ self: { ]; description = "Web Authentication API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webby" = callPackage @@ -281341,8 +264322,6 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Turn an optparse-applicative program into a CGI program!"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webcrank" = callPackage @@ -281370,8 +264349,6 @@ self: { ]; description = "Webmachine inspired toolkit for building http applications and services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webcrank-dispatch" = callPackage @@ -281387,8 +264364,6 @@ self: { ]; description = "A simple request dispatcher"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webcrank-wai" = callPackage @@ -281406,8 +264381,6 @@ self: { ]; description = "Build a WAI Application from Webcrank Resources"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webdriver" = callPackage @@ -281452,8 +264425,6 @@ self: { ]; description = "Webdriver actions to assist with testing a webpage which uses Angular.Js"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webdriver-snoy" = callPackage @@ -281480,8 +264451,6 @@ self: { testHaskellDepends = [ base parallel text ]; description = "a Haskell client for the Selenium WebDriver protocol (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webdriver-w3c" = callPackage @@ -281517,8 +264486,6 @@ self: { ]; description = "Bindings to the WebDriver API"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webex-teams-api" = callPackage @@ -281618,8 +264585,6 @@ self: { ]; description = "WebFinger client library"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webgear-server" = callPackage @@ -281687,8 +264652,6 @@ self: { ]; description = "webfont generator"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webkit" = callPackage @@ -281722,8 +264685,6 @@ self: { libraryPkgconfigDepends = [ webkit ]; description = "JavaScriptCore FFI from webkitgtk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {webkit = null;}; "webkit2gtk3-javascriptcore" = callPackage @@ -281797,8 +264758,6 @@ self: { ]; description = "Types and functions for working with Webmentions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webp" = callPackage @@ -281860,8 +264819,6 @@ self: { ]; description = "HTTP server library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "webshow" = callPackage @@ -281881,8 +264838,6 @@ self: { ]; description = "Show programming language printed values in a web UI"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "websnap" = callPackage @@ -281958,8 +264913,6 @@ self: { ]; description = "Simple streaming RPC mechanism using WebSockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "websockets-simple" = callPackage @@ -282030,8 +264983,6 @@ self: { ]; description = "Functional reactive web framework"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wedding-announcement" = callPackage @@ -282117,8 +265068,6 @@ self: { ]; description = "A school-timetable problem-solver"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "weigh" = callPackage @@ -282145,8 +265094,6 @@ self: { libraryHaskellDepends = [ base mtl semiring-num transformers ]; description = "Writer monad which uses semiring constraint"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "weighted-regexp" = callPackage @@ -282161,8 +265108,6 @@ self: { libraryToolDepends = [ happy ]; description = "Weighted Regular Expression Matcher"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "weighted-search" = callPackage @@ -282193,8 +265138,6 @@ self: { ]; description = "Haskell web framework (because Scotty had trouble yodeling)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wembley" = callPackage @@ -282236,8 +265179,6 @@ self: { ]; description = "A game engine for playing werewolf within an arbitrary chat client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "werewolf-slack" = callPackage @@ -282257,8 +265198,6 @@ self: { ]; description = "A chat interface for playing werewolf in Slack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "what4" = callPackage @@ -282296,8 +265235,6 @@ self: { ]; description = "Solver-agnostic symbolic values support for issuing queries"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wheb-mongo" = callPackage @@ -282309,8 +265246,6 @@ self: { libraryHaskellDepends = [ base bson mongoDB mtl text Wheb ]; description = "MongoDB plugin for Wheb"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wheb-redis" = callPackage @@ -282322,8 +265257,6 @@ self: { libraryHaskellDepends = [ base bytestring hedis mtl text Wheb ]; description = "Redis connection for Wheb"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wheb-strapped" = callPackage @@ -282335,8 +265268,6 @@ self: { libraryHaskellDepends = [ base mtl StrappedTemplates text Wheb ]; description = "Strapped templates for Wheb"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "which" = callPackage @@ -282359,8 +265290,6 @@ self: { libraryHaskellDepends = [ base indents parsec ]; description = "Parser for the While language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "whim" = callPackage @@ -282379,8 +265308,6 @@ self: { ]; description = "A Haskell window manager"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "whiskers" = callPackage @@ -282392,8 +265319,6 @@ self: { libraryHaskellDepends = [ base parsec template-haskell ]; description = "Mustache templates with Template Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "whitespace" = callPackage @@ -282408,8 +265333,6 @@ self: { executableHaskellDepends = [ haskell98 random ]; description = "Whitespace, an esoteric programming language"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "whois" = callPackage @@ -282423,8 +265346,6 @@ self: { libraryHaskellDepends = [ base network network-uri split ]; description = "WHOIS client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wholepixels" = callPackage @@ -282459,8 +265380,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "Haskell support for the Why3 input format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wide-word" = callPackage @@ -282480,8 +265399,6 @@ self: { ]; description = "Data types for large but fixed width signed and unsigned integers"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wide-word-instances" = callPackage @@ -282493,8 +265410,6 @@ self: { libraryHaskellDepends = [ base binary serialise wide-word ]; description = "Instances for wide-word"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wigner-symbols" = callPackage @@ -282562,8 +265477,6 @@ self: { ]; description = "Wikipedia EPUB E-Book construction from Firefox history"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wild-bind" = callPackage @@ -282600,8 +265513,6 @@ self: { ]; description = "Graphical indicator for WildBind"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wild-bind-task-x11" = callPackage @@ -282618,8 +265529,6 @@ self: { testHaskellDepends = [ base ]; description = "Task to install and export everything you need to use WildBind in X11"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wild-bind-x11" = callPackage @@ -282704,8 +265613,6 @@ self: { librarySystemDepends = [ dnsapi ]; description = "Domain Name Service (DNS) lookup via the /dnsapi.dll standard library"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {dnsapi = null;}; "windowslive" = callPackage @@ -282723,8 +265630,6 @@ self: { ]; description = "Implements Windows Live Web Authentication and Delegated Authentication"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "winerror" = callPackage @@ -282736,8 +265641,6 @@ self: { doHaddock = false; description = "Error handling for foreign calls to the Windows API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "winery" = callPackage @@ -282775,8 +265678,6 @@ self: { ]; description = "A compact, well-typed seralisation format for Haskell values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "winio" = callPackage @@ -282793,8 +265694,6 @@ self: { librarySystemDepends = [ kernel32 ws2_32 ]; description = "I/O library for Windows"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {kernel32 = null; ws2_32 = null;}; "wire-streams" = callPackage @@ -282837,8 +265736,6 @@ self: { ]; description = "Functional reactive programming library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wiring" = callPackage @@ -282855,8 +265752,6 @@ self: { ]; description = "Wiring, promotion and demotion of types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wiringPi" = callPackage @@ -283029,8 +265924,6 @@ self: { executableHaskellDepends = [ base bytestring network unix ]; description = "A network server to show bottlenecks of GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wizard" = callPackage @@ -283077,8 +265970,6 @@ self: { ]; description = "Parsec parsers and types for geographic data in well-known text (WKT) format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wkt-geom" = callPackage @@ -283102,8 +265993,6 @@ self: { ]; description = "A parser of WKT, WKB and eWKB"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wl-pprint" = callPackage @@ -283147,8 +266036,6 @@ self: { ]; description = "ANSI Terminal support with wl-pprint-extras"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wl-pprint-console" = callPackage @@ -283183,8 +266070,6 @@ self: { ]; description = "A free monad based on the Wadler/Leijen pretty printer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wl-pprint-terminfo" = callPackage @@ -283202,8 +266087,6 @@ self: { ]; description = "A color pretty printer with terminfo support"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wl-pprint-text" = callPackage @@ -283233,8 +266116,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell bindings for the wlc library"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {wlc = null;}; "wobsurv" = callPackage @@ -283270,8 +266151,6 @@ self: { ]; description = "A simple and highly performant HTTP file server"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "woe" = callPackage @@ -283283,8 +266162,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Convenient typeclass for defining arbitrary-index enums"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "woffex" = callPackage @@ -283300,8 +266177,6 @@ self: { ]; description = "Web Open Font Format (WOFF) unpacker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wol" = callPackage @@ -283316,8 +266191,6 @@ self: { executableHaskellDepends = [ base ]; description = "Send a Wake on LAN Magic Packet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wolf" = callPackage @@ -283340,8 +266213,6 @@ self: { executableHaskellDepends = [ base optparse-generic ]; description = "Amazon Simple Workflow Service Wrapper"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "woot" = callPackage @@ -283372,8 +266243,6 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Words of arbitrary size"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "word-trie" = callPackage @@ -283458,8 +266327,6 @@ self: { ]; description = "Reading word2vec binary models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "word8" = callPackage @@ -283499,8 +266366,6 @@ self: { benchmarkHaskellDepends = [ base criterion pandoc text ]; description = "Get word counts and distributions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wordcloud" = callPackage @@ -283553,8 +266418,6 @@ self: { unordered-containers ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wordlist" = callPackage @@ -283573,8 +266436,6 @@ self: { ]; description = "Command-line tool to get random words"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wordn" = callPackage @@ -283617,8 +266478,6 @@ self: { ]; description = "Dictionary-based password generator"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wordpress-auth" = callPackage @@ -283637,8 +266496,6 @@ self: { ]; description = "Validate Wordpress Cookies & Nonces; Build Wordpress Hashes & Salts"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "words" = callPackage @@ -283665,8 +266522,6 @@ self: { executableHaskellDepends = [ base containers fclabels ]; description = "A word search solver library and executable"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wordsetdiff" = callPackage @@ -283699,8 +266554,6 @@ self: { executableHaskellDepends = [ base text ]; description = "A library for parsing a chat-based work hour reporting scheme"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "workdays" = callPackage @@ -283713,8 +266566,6 @@ self: { testHaskellDepends = [ base containers doctest hspec ]; description = "Workday calculations"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "workflow-extra" = callPackage @@ -283737,8 +266588,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Utilities (e.g. Googling the clipboard contents) for the `workflow` pacakge"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "workflow-osx" = callPackage @@ -283758,8 +266607,6 @@ self: { executableHaskellDepends = [ base ]; description = "a \"Desktop Workflow\" monad with Objective-C bindings"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "workflow-pure" = callPackage @@ -283782,8 +266629,6 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "manipulate `workflow-types:Workflow`'s"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "workflow-types" = callPackage @@ -283802,8 +266647,6 @@ self: { executableHaskellDepends = [ base ]; description = "Automate keyboard\\/mouse\\/clipboard\\/application interaction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "workflow-windows" = callPackage @@ -283818,8 +266661,6 @@ self: { testHaskellDepends = [ base doctest hspec QuickCheck ]; description = "Automate keyboard/mouse/clipboard/application interaction"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "world-peace" = callPackage @@ -283862,8 +266703,6 @@ self: { ]; description = "Subscribe to a wiki's RSS feed and archive external links"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wrap" = callPackage @@ -283906,8 +266745,6 @@ self: { ]; description = "Lazy wrapper to HaXML, HXT, TagSoup via custom XML tree structure"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wrecker" = callPackage @@ -283946,8 +266783,6 @@ self: { ]; description = "An HTTP Performance Benchmarker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wrecker-ui" = callPackage @@ -283980,8 +266815,6 @@ self: { ]; description = "A web interface for Wrecker, the HTTP Performance Benchmarker"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wreq" = callPackage @@ -284073,8 +266906,6 @@ self: { ]; description = "An easy-to-use HTTP client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wreq-sb" = callPackage @@ -284112,8 +266943,6 @@ self: { ]; description = "An easy-to-use HTTP client library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wreq-stringless" = callPackage @@ -284142,8 +266971,6 @@ self: { ]; description = "Colour space transformations and metrics"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "write-buffer-core" = callPackage @@ -284204,8 +267031,6 @@ self: { ]; description = "WriteT and RWST monad transformers (Reexport with all dependencies)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "writer-cps-lens" = callPackage @@ -284222,8 +267047,6 @@ self: { ]; description = "Lens instances for the stricter CPS WriterT and RWST"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "writer-cps-monads-tf" = callPackage @@ -284239,8 +267062,6 @@ self: { ]; description = "MonadWriter orphan instances for writer-cps-transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "writer-cps-morph" = callPackage @@ -284254,8 +267075,6 @@ self: { libraryHaskellDepends = [ base mmorph writer-cps-transformers ]; description = "MFunctor instance for CPS style WriterT and RWST"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "writer-cps-mtl" = callPackage @@ -284318,8 +267137,6 @@ self: { ]; description = "A simple CLI utility for interacting with a websocket"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ws-chans" = callPackage @@ -284361,8 +267178,6 @@ self: { ]; description = "WSDL parsing in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wsedit" = callPackage @@ -284380,8 +267195,6 @@ self: { ]; description = "A small tool to list, add and remove webseeds from a torrent file"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wshterm" = callPackage @@ -284403,8 +267216,6 @@ self: { ]; description = "Terminal emulator over websockets"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wsjtx-udp" = callPackage @@ -284423,8 +267234,6 @@ self: { executableHaskellDepends = [ base ]; description = "WSJT-X UDP protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wss-client" = callPackage @@ -284443,8 +267252,6 @@ self: { testHaskellDepends = [ base bytestring envy hspec skews text ]; description = "A-little-higher-level WebSocket client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wstunnel" = callPackage @@ -284484,8 +267291,6 @@ self: { libraryHaskellDepends = [ base old-locale time transformers ]; description = "Wojcik Tool Kit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wtk-gtk" = callPackage @@ -284501,8 +267306,6 @@ self: { ]; description = "GTK tools within Wojcik Tool Kit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wu-wei" = callPackage @@ -284518,8 +267321,6 @@ self: { ]; description = "Unimportant Unix adminstration tool"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wumpus-basic" = callPackage @@ -284535,8 +267336,6 @@ self: { ]; description = "Basic objects and system code built on Wumpus-Core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wumpus-core" = callPackage @@ -284550,8 +267349,6 @@ self: { libraryHaskellDepends = [ base containers time vector-space ]; description = "Pure Haskell PostScript and SVG generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wumpus-drawing" = callPackage @@ -284567,8 +267364,6 @@ self: { ]; description = "High-level drawing objects built on Wumpus-Basic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wumpus-microprint" = callPackage @@ -284584,8 +267379,6 @@ self: { ]; description = "Microprints - \"greek-text\" pictures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wumpus-tree" = callPackage @@ -284602,8 +267395,6 @@ self: { ]; description = "Drawing trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wuss" = callPackage @@ -284645,8 +267436,6 @@ self: { executableHaskellDepends = [ base directory random wx wxcore ]; description = "Try to avoid the asteroids with your space ship"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wxFruit" = callPackage @@ -284661,8 +267450,6 @@ self: { executableHaskellDepends = [ base wx wxcore Yampa ]; description = "An implementation of Fruit using wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wxSimpleCanvas" = callPackage @@ -284674,8 +267461,6 @@ self: { libraryHaskellDepends = [ base cubicbezier wx wxcore ]; description = "Simple zoomable canvas for wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wxc" = callPackage @@ -284738,8 +267523,6 @@ self: { ]; description = "helper tool for building wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wxhnotepad" = callPackage @@ -284754,8 +267537,6 @@ self: { executableHaskellDepends = [ base wx wxcore ]; description = "An example of how to implement a basic notepad with wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wxturtle" = callPackage @@ -284771,8 +267552,6 @@ self: { ]; description = "turtle like LOGO with wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "wybor" = callPackage @@ -284812,8 +267591,6 @@ self: { ]; description = "An autoresponder for Dragon Go Server"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "x-dsp" = callPackage @@ -284830,8 +267607,6 @@ self: { ]; description = "A embedded DSL for manipulating DSP languages in Haskell"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "x11-xim" = callPackage @@ -285065,8 +267840,6 @@ self: { ]; description = "XChat"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xcp" = callPackage @@ -285082,8 +267855,6 @@ self: { ]; description = "Partial implementation of the XCP protocol with ethernet as transport layer"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xdcc" = callPackage @@ -285109,8 +267880,6 @@ self: { ]; description = "A wget-like utility for retrieving files from XDCC bots on IRC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xdg-basedir" = callPackage @@ -285172,8 +267941,6 @@ self: { ]; description = "Parse Graphviz xdot files and interactively view them using GTK and Cairo"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xeno" = callPackage @@ -285209,8 +267976,6 @@ self: { libraryHaskellDepends = [ base bytestring cereal mtl network ]; description = "Xenstore client access"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xfconf" = callPackage @@ -285231,8 +267996,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "FFI bindings to xfconf"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {libxfconf = null;}; "xformat" = callPackage @@ -285245,8 +268008,6 @@ self: { testHaskellDepends = [ base ]; description = "Extensible, type-safe formatting with scanf- and printf-like functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xgboost-haskell" = callPackage @@ -285278,8 +268039,6 @@ self: { ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xhb" = callPackage @@ -285296,8 +268055,6 @@ self: { ]; description = "X Haskell Bindings"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xhb-atom-cache" = callPackage @@ -285313,8 +268070,6 @@ self: { ]; description = "Atom cache for XHB"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xhb-ewmh" = callPackage @@ -285331,8 +268086,6 @@ self: { ]; description = "EWMH utilities for XHB"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xhtml_3000_2_2_1" = callPackage @@ -285375,8 +268128,6 @@ self: { executableHaskellDepends = [ base directory process ]; description = "The Lava system for Xilinx FPGA design with layout combinators"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xine" = callPackage @@ -285391,8 +268142,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to xine-lib"; license = "LGPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {libxine = null; xine = null;}; "xing-api" = callPackage @@ -285416,8 +268165,6 @@ self: { ]; description = "Wrapper for the XING API, v1"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xinput-conduit" = callPackage @@ -285457,8 +268204,6 @@ self: { benchmarkHaskellDepends = [ base random time vector ]; description = "Haskell bindings for libxkbcommon"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libxkbcommon;}; "xkcd" = callPackage @@ -285478,8 +268223,6 @@ self: { ]; description = "Downloads the most recent xkcd comic"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xleb" = callPackage @@ -285495,8 +268238,6 @@ self: { libraryHaskellDepends = [ base containers mtl xml ]; description = "A simple monadic language for parsing XML structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xls" = callPackage @@ -285518,8 +268259,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "Parse Microsoft Excel xls files (BIFF/Excel 97-2004)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xlsior" = callPackage @@ -285543,8 +268282,6 @@ self: { ]; description = "Streaming Excel file generation and parsing"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xlsx" = callPackage @@ -285589,8 +268326,6 @@ self: { testHaskellDepends = [ base ]; description = "Xlsx table cell value extraction utility"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xlsx-templater" = callPackage @@ -285609,8 +268344,6 @@ self: { ]; description = "Simple and incomplete Excel file templater"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml" = callPackage @@ -285656,8 +268389,6 @@ self: { ]; description = "Parse XML catalog files (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-conduit" = callPackage @@ -285701,8 +268432,6 @@ self: { ]; description = "Historical cursors & decoding on top of xml-conduit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-conduit-parse" = callPackage @@ -285746,8 +268475,6 @@ self: { ]; description = "jQuery-style CSS selectors for xml-conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-conduit-stylist" = callPackage @@ -285766,8 +268493,6 @@ self: { ]; description = "Bridge between xml-conduit/html-conduit and stylist"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-conduit-writer" = callPackage @@ -285807,8 +268532,6 @@ self: { ]; description = "Pure-Haskell utilities for dealing with XML with the enumerator package. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-enumerator-combinators" = callPackage @@ -285826,8 +268549,6 @@ self: { ]; description = "Parser combinators for xml-enumerator and compatible XML parsers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-extractors" = callPackage @@ -285888,8 +268609,6 @@ self: { ]; description = "Optics for xml-conduit and html-conduit"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-html-qq" = callPackage @@ -285985,8 +268704,6 @@ self: { ]; description = "Monadic extensions to the xml package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-optics" = callPackage @@ -286012,8 +268729,6 @@ self: { libraryHaskellDepends = [ base HaXml parsec ]; description = "Parsing XML with Parsec"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-picklers" = callPackage @@ -286042,8 +268757,6 @@ self: { libraryHaskellDepends = [ base bytestring papillon simple-pipe ]; description = "XML parser which uses simple-pipe"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-prettify" = callPackage @@ -286058,8 +268771,6 @@ self: { executableHaskellDepends = [ base cmdargs unix ]; description = "Pretty print XML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-push" = callPackage @@ -286080,8 +268791,6 @@ self: { ]; description = "Push XML from/to client to/from server over XMPP or HTTP"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-query" = callPackage @@ -286093,8 +268802,6 @@ self: { libraryHaskellDepends = [ base-prelude free text ]; description = "A parser-agnostic declarative API for querying XML-documents"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-query-xml-conduit" = callPackage @@ -286111,8 +268818,6 @@ self: { ]; description = "A binding for the \"xml-query\" and \"xml-conduit\" libraries"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-query-xml-types" = callPackage @@ -286136,8 +268841,6 @@ self: { ]; description = "An interpreter of \"xml-query\" queries for the \"xml-types\" documents"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-to-json" = callPackage @@ -286194,8 +268897,6 @@ self: { ]; description = "Typed XML encoding for an xml-conduit backend"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-tydom-core" = callPackage @@ -286207,8 +268908,6 @@ self: { libraryHaskellDepends = [ base containers mtl QuickCheck text ]; description = "Typed XML encoding (core library)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml-types" = callPackage @@ -286260,8 +268959,6 @@ self: { ]; description = "translate xml to json"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xml2x" = callPackage @@ -286280,8 +268977,6 @@ self: { ]; description = "Convert BLAST output in XML format to CSV or HTML"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmlbf" = callPackage @@ -286413,8 +269108,6 @@ self: { ]; description = "Show tv channels in the terminal"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmms2-client" = callPackage @@ -286431,8 +269124,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "An XMMS2 client library"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmms2-client-glib" = callPackage @@ -286445,8 +269136,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "An XMMS2 client library — GLib integration"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmobar" = callPackage @@ -286542,8 +269231,6 @@ self: { ]; description = "A tiling window manager"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmonad-contrib" = callPackage @@ -286582,8 +269269,6 @@ self: { ]; description = "Third party extensions for xmonad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmonad-contrib-gpl" = callPackage @@ -286595,8 +269280,6 @@ self: { libraryHaskellDepends = [ base mtl xmonad xmonad-contrib ]; description = "Third party extensions for xmonad"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmonad-dbus" = callPackage @@ -286611,8 +269294,6 @@ self: { executableHaskellDepends = [ base dbus utf8-string ]; testHaskellDepends = [ base dbus utf8-string ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmonad-entryhelper" = callPackage @@ -286645,8 +269326,6 @@ self: { ]; description = "Module for evaluation Haskell expressions in the running xmonad instance"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmonad-extras" = callPackage @@ -286727,8 +269406,6 @@ self: { testHaskellDepends = [ base hspec xmonad ]; description = "Custom xmonad, which builds with stack or cabal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmonad-volume" = callPackage @@ -286777,8 +269454,6 @@ self: { ]; description = "A library to automatically put named windows into the DynamicLog"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xmpipe" = callPackage @@ -286795,8 +269470,6 @@ self: { ]; description = "XMPP implementation using simple-PIPE"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xor" = callPackage @@ -286817,8 +269490,6 @@ self: { ]; description = "Efficient XOR masking"; license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xorshift" = callPackage @@ -286848,8 +269519,6 @@ self: { ]; description = "Simple implementation of xorshift+ PRNG"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xosd" = callPackage @@ -286879,8 +269548,6 @@ self: { ]; description = "text builder for xournal file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xournal-convert" = callPackage @@ -286902,8 +269569,6 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "convert utility for xoj files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xournal-parser" = callPackage @@ -286923,8 +269588,6 @@ self: { ]; description = "Xournal file parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xournal-render" = callPackage @@ -286942,8 +269605,6 @@ self: { ]; description = "Xournal file renderer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xournal-types" = callPackage @@ -286961,8 +269622,6 @@ self: { ]; description = "Data types for programs for xournal file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xpathdsv" = callPackage @@ -287024,8 +269683,6 @@ self: { ]; testToolDepends = [ hspec-discover ]; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xsact" = callPackage @@ -287043,8 +269700,6 @@ self: { ]; description = "Cluster EST sequences"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xsd" = callPackage @@ -287061,8 +269716,6 @@ self: { ]; description = "XML Schema data structures"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xsha1" = callPackage @@ -287086,8 +269739,6 @@ self: { librarySystemDepends = [ xslt ]; description = "Binding to libxslt"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {xslt = null;}; "xss-sanitize" = callPackage @@ -287120,8 +269771,6 @@ self: { libraryHaskellDepends = [ base wx wxcore ]; description = "eXtended & Typed Controls for wxHaskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xtest" = callPackage @@ -287166,8 +269815,6 @@ self: { ]; description = "A Haskell implementation of the xxHash algorithm"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "xxhash-ffi" = callPackage @@ -287204,8 +269851,6 @@ self: { ]; description = "#plaimi's all-encompassing bot"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yabi" = callPackage @@ -287239,8 +269884,6 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Yet Another Brainfuck Interpreter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yackage" = callPackage @@ -287264,8 +269907,6 @@ self: { ]; description = "Personal Hackage replacement for testing new packages"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yahoo-finance-api" = callPackage @@ -287287,8 +269928,6 @@ self: { ]; description = "Read quotes from Yahoo Finance API"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yahoo-finance-conduit" = callPackage @@ -287304,8 +269943,6 @@ self: { ]; description = "Streaming aproach to the yahoo finance api"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yahoo-prices" = callPackage @@ -287323,8 +269960,6 @@ self: { doHaddock = false; description = "A wrapper around Yahoo API for downloading market data"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yahoo-web-search" = callPackage @@ -287336,8 +269971,6 @@ self: { libraryHaskellDepends = [ base HTTP network xml ]; description = "Yahoo Web Search Services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yajl" = callPackage @@ -287351,8 +269984,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings for YAJL, an event-based JSON implementation"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) yajl;}; "yajl-enumerator" = callPackage @@ -287368,8 +269999,6 @@ self: { ]; description = "Enumerator-based interface to YAJL, an event-based JSON implementation"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yak" = callPackage @@ -287397,8 +270026,6 @@ self: { libraryHaskellDepends = [ base categories transformers ]; description = "Lenses with a southern twang"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam" = callPackage @@ -287432,8 +270059,6 @@ self: { ]; description = "A wrapper of servant"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-app" = callPackage @@ -287473,8 +270098,6 @@ self: { ]; description = "Yam Configuation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-datasource" = callPackage @@ -287492,8 +270115,6 @@ self: { ]; description = "Yam DataSource Middleware"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-job" = callPackage @@ -287519,8 +270140,6 @@ self: { ]; description = "Yam Logger"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-redis" = callPackage @@ -287537,8 +270156,6 @@ self: { ]; description = "Yam Redis Middleware"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-servant" = callPackage @@ -287555,8 +270172,6 @@ self: { servant-swagger-ui swagger2 text wai wai-extra warp yam-app yam-job ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-transaction" = callPackage @@ -287577,8 +270192,6 @@ self: { ]; description = "Yam transaction"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-transaction-odbc" = callPackage @@ -287591,8 +270204,6 @@ self: { base containers persistent-odbc yam-app ]; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yam-transaction-postgresql" = callPackage @@ -287636,8 +270247,6 @@ self: { ]; description = "Yam Web"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yamemo" = callPackage @@ -287757,8 +270366,6 @@ self: { testHaskellDepends = [ base hspec microlens-platform rio ]; description = "Extra functionality for pretty printing Yaml documents"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaml-rpc" = callPackage @@ -287777,8 +270384,6 @@ self: { ]; description = "Simple library for network (HTTP REST-like) YAML RPC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaml-rpc-scotty" = callPackage @@ -287795,8 +270400,6 @@ self: { ]; description = "Scotty server backend for yaml-rpc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaml-rpc-snap" = callPackage @@ -287813,8 +270416,6 @@ self: { ]; description = "Snap server backend for yaml-rpc"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaml-union" = callPackage @@ -287868,8 +270469,6 @@ self: { ]; description = "Flexible declarative YAML parsing toolkit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaml2owl" = callPackage @@ -287957,8 +270556,6 @@ self: { ]; description = "Connects GLFW-b (GLFW 3+) with the Yampa FRP library"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yampa-gloss" = callPackage @@ -287972,8 +270569,6 @@ self: { libraryHaskellDepends = [ base gloss Yampa ]; description = "A GLOSS backend for Yampa"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yampa-glut" = callPackage @@ -287991,8 +270586,6 @@ self: { ]; description = "Connects Yampa and GLUT"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yampa-sdl2" = callPackage @@ -288011,8 +270604,6 @@ self: { ]; description = "Yampa and SDL2 made easy"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yampa-test" = callPackage @@ -288031,8 +270622,6 @@ self: { ]; description = "Testing library for Yampa"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yampa2048" = callPackage @@ -288046,8 +270635,6 @@ self: { executableHaskellDepends = [ base gloss random Yampa ]; description = "2048 game clone using Yampa/Gloss"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yandex-translate" = callPackage @@ -288065,8 +270652,6 @@ self: { ]; description = "Bindings to Yandex translate API"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaop" = callPackage @@ -288080,8 +270665,6 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Yet another option parser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yap" = callPackage @@ -288093,8 +270676,6 @@ self: { libraryHaskellDepends = [ base ]; description = "yet another prelude - a simplistic refactoring with algebraic classes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yapb" = callPackage @@ -288190,8 +270771,6 @@ self: { ]; description = "Yet another array library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yarr-image-io" = callPackage @@ -288204,8 +270783,6 @@ self: { librarySystemDepends = [ libdevil ]; description = "Image IO for Yarr library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) libdevil;}; "yasi" = callPackage @@ -288225,8 +270802,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Yet another string interpolator"; license = lib.licenses.cc0; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yate" = callPackage @@ -288265,8 +270840,6 @@ self: { executableHaskellDepends = [ base Cabal directory process ]; description = "yet another visual editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaya" = callPackage @@ -288313,8 +270886,6 @@ self: { ]; description = "Test suites for `yaya`"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yaya-unsafe" = callPackage @@ -288346,8 +270917,6 @@ self: { ]; description = "Test suites for `yaya-unsafe`"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ycextra" = callPackage @@ -288362,8 +270931,6 @@ self: { ]; description = "Additional utilities to work with Yhc Core"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yeamer" = callPackage @@ -288399,8 +270966,6 @@ self: { ]; description = "Yesod-based server for interactive presentation slides"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yeganesh" = callPackage @@ -288444,8 +271009,6 @@ self: { ]; description = "A Yeller Client For Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yes-precure5-command" = callPackage @@ -288478,8 +271041,6 @@ self: { libraryHaskellDepends = [ base yeshql-core yeshql-hdbc ]; description = "YesQL-style SQL database abstraction (legacy compatibility wrapper)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yeshql-core" = callPackage @@ -288519,8 +271080,6 @@ self: { ]; description = "YesQL-style SQL database abstraction (HDBC backend)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yeshql-postgresql-simple" = callPackage @@ -288542,8 +271101,6 @@ self: { ]; description = "YesQL-style SQL database abstraction (postgresql-simple backend)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod" = callPackage @@ -288596,8 +271153,6 @@ self: { ]; description = "Angular JS integratoin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-angular-ui" = callPackage @@ -288617,8 +271172,6 @@ self: { ]; description = "Angular Helpers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-articles" = callPackage @@ -288641,8 +271194,6 @@ self: { ]; description = "Automatically generate article previews for a yesod site"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth" = callPackage @@ -288693,8 +271244,6 @@ self: { ]; description = "An account authentication plugin for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-account-fork" = callPackage @@ -288719,8 +271268,6 @@ self: { ]; description = "An account authentication plugin for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-basic" = callPackage @@ -288754,8 +271301,6 @@ self: { ]; description = "BCrypt salted and hashed passwords in a database as auth for yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-bcryptdb" = callPackage @@ -288772,8 +271317,6 @@ self: { ]; description = "Authentication plugin for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-deskcom" = callPackage @@ -288795,8 +271338,6 @@ self: { ]; description = "Desk.com remote authentication support for Yesod apps."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-fb" = callPackage @@ -288857,8 +271398,6 @@ self: { ]; description = "An account authentication plugin for yesod with encrypted token transfer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-kerberos" = callPackage @@ -288876,8 +271415,6 @@ self: { ]; description = "Kerberos Authentication for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-ldap" = callPackage @@ -288894,8 +271431,6 @@ self: { ]; description = "LDAP Authentication for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-ldap-mediocre" = callPackage @@ -288911,8 +271446,6 @@ self: { ]; description = "Very simlple LDAP auth for yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-ldap-native" = callPackage @@ -288930,8 +271463,6 @@ self: { testHaskellDepends = [ base ]; description = "Yesod LDAP authentication plugin"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-lti13" = callPackage @@ -288954,8 +271485,6 @@ self: { ]; description = "A yesod-auth plugin for LTI 1.3"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-nopassword" = callPackage @@ -288972,8 +271501,6 @@ self: { ]; description = "A plugin for Yesod to provide email-only authentication"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-oauth" = callPackage @@ -289012,8 +271539,6 @@ self: { testHaskellDepends = [ base hspec uri-bytestring ]; description = "OAuth 2.0 authentication plugins"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-pam" = callPackage @@ -289029,8 +271554,6 @@ self: { ]; description = "Provides PAM authentication module"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-smbclient" = callPackage @@ -289047,8 +271570,6 @@ self: { ]; description = "Authentication plugin for Yesod using smbclient"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-auth-zendesk" = callPackage @@ -289067,8 +271588,6 @@ self: { ]; description = "Zendesk remote authentication support for Yesod apps"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-bin" = callPackage @@ -289112,8 +271631,6 @@ self: { ]; description = "Bootstrap widgets for yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-colonnade" = callPackage @@ -289132,8 +271649,6 @@ self: { ]; description = "Helper functions for using yesod with colonnade"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-comments" = callPackage @@ -289152,8 +271667,6 @@ self: { ]; description = "A generic comments interface for a Yesod application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-content-pdf" = callPackage @@ -289175,8 +271688,6 @@ self: { ]; description = "PDF Content Type for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-continuations" = callPackage @@ -289195,8 +271706,6 @@ self: { ]; description = "Continuations for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-core" = callPackage @@ -289251,8 +271760,6 @@ self: { ]; description = "Generic administrative CRUD operations as a Yesod subsite"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-crud-persist" = callPackage @@ -289271,8 +271778,6 @@ self: { ]; description = "Flexible CRUD subsite usable with Yesod and Persistent"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-csp" = callPackage @@ -289320,8 +271825,6 @@ self: { ]; description = "Yesod plugin for DataTables (jQuery grid plugin)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-default" = callPackage @@ -289359,8 +271862,6 @@ self: { ]; description = "DSL for generating Yesod subsite to manage an RDBMS;"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-elements" = callPackage @@ -289412,8 +271913,6 @@ self: { executableSystemDepends = [ sqlite ]; description = "Example programs using the Yesod Web Framework. (deprecated)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) sqlite;}; "yesod-fast-devel" = callPackage @@ -289435,8 +271934,6 @@ self: { ]; description = "Fast live-reloading for yesod applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-fay" = callPackage @@ -289456,8 +271953,6 @@ self: { ]; description = "Utilities for using the Fay Haskell-to-JS compiler with Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-fb" = callPackage @@ -289495,8 +271990,6 @@ self: { ]; description = "Automatic filter generator for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-form" = callPackage @@ -289628,8 +272121,6 @@ self: { ]; description = "Various rich-text WYSIWYG editors for Yesod forms"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-gitrepo" = callPackage @@ -289661,8 +272152,6 @@ self: { testHaskellDepends = [ base yesod-core ]; description = "A subsite for displaying git information"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-goodies" = callPackage @@ -289679,8 +272168,6 @@ self: { ]; description = "A collection of various small helpers useful in any yesod application"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-ip" = callPackage @@ -289699,8 +272186,6 @@ self: { ]; description = "Code for using the ip package with yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-job-queue" = callPackage @@ -289722,8 +272207,6 @@ self: { testHaskellDepends = [ base ]; description = "Background jobs library for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-json" = callPackage @@ -289763,8 +272246,6 @@ self: { libraryHaskellDepends = [ base text yesod-core ]; description = "A typeclass which simplifies creating link widgets throughout your site"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-lucid" = callPackage @@ -289776,8 +272257,6 @@ self: { libraryHaskellDepends = [ base lucid monads-tf text yesod-core ]; description = "Lucid support for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-mangopay" = callPackage @@ -289797,8 +272276,6 @@ self: { ]; description = "Yesod library for MangoPay API access"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-markdown" = callPackage @@ -289817,8 +272294,6 @@ self: { testHaskellDepends = [ base blaze-html hspec text ]; description = "Tools for using markdown in a yesod application"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-media-simple" = callPackage @@ -289875,8 +272350,6 @@ self: { time unliftio unliftio-core wai-extra yesod yesod-core yesod-test ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-paginate" = callPackage @@ -289888,8 +272361,6 @@ self: { libraryHaskellDepends = [ base template-haskell yesod ]; description = "Pagination for Yesod sites"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-pagination" = callPackage @@ -289908,8 +272379,6 @@ self: { ]; description = "Pagination in Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-paginator" = callPackage @@ -289946,8 +272415,6 @@ self: { ]; description = "Yesod plugin to use PayPal with the paypal-rest-client library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-persistent" = callPackage @@ -290060,8 +272527,6 @@ self: { ]; description = "Meta package for Yesod (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-pnotify" = callPackage @@ -290082,8 +272547,6 @@ self: { ]; description = "Yet another getMessage/setMessage using pnotify jquery plugins"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-pure" = callPackage @@ -290095,8 +272558,6 @@ self: { libraryHaskellDepends = [ base fast-logger text yesod yesod-core ]; description = "Yesod in pure Haskell: no Template Haskell or QuasiQuotes (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-purescript" = callPackage @@ -290116,8 +272577,6 @@ self: { ]; description = "PureScript integration for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-raml" = callPackage @@ -290141,8 +272600,6 @@ self: { ]; description = "RAML style route definitions for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-raml-bin" = callPackage @@ -290165,8 +272622,6 @@ self: { ]; description = "The raml helper executable"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-raml-docs" = callPackage @@ -290183,8 +272638,6 @@ self: { ]; description = "A html documentation generator library for RAML"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-raml-mock" = callPackage @@ -290208,8 +272661,6 @@ self: { ]; description = "A mock-handler generator library from RAML"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-recaptcha" = callPackage @@ -290228,8 +272679,6 @@ self: { ]; description = "Dead simple support for reCAPTCHA on Yesod applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-recaptcha2" = callPackage @@ -290266,8 +272715,6 @@ self: { ]; description = "Efficient routing for Yesod. (deprecated)"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-routes-flow" = callPackage @@ -290284,8 +272731,6 @@ self: { ]; description = "Generate Flow routes for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-routes-typescript" = callPackage @@ -290302,8 +272747,6 @@ self: { ]; description = "generate TypeScript routes for Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-rst" = callPackage @@ -290320,8 +272763,6 @@ self: { ]; description = "Tools for using reStructuredText (RST) in a yesod application"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-s3" = callPackage @@ -290338,8 +272779,6 @@ self: { ]; description = "Simple Helper Library for using Amazon's Simple Storage Service (S3) with Yesod"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-sass" = callPackage @@ -290356,8 +272795,6 @@ self: { ]; description = "A simple quasiquoter to include sass code in yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-session-redis" = callPackage @@ -290375,8 +272812,6 @@ self: { ]; description = "Redis-Powered Sessions for Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-sitemap" = callPackage @@ -290451,8 +272886,6 @@ self: { ]; description = "Yesod generators for embedding AngularJs code into yesod-static at compile time"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-static-remote" = callPackage @@ -290469,8 +272902,6 @@ self: { ]; testHaskellDepends = [ base yesod-static ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-table" = callPackage @@ -290540,8 +272971,6 @@ self: { ]; description = "Utility functions for testing JSON web services written in Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-text-markdown" = callPackage @@ -290574,8 +273003,6 @@ self: { ]; description = "Provides main functions using warp-tls for yesod projects"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-transloadit" = callPackage @@ -290620,8 +273047,6 @@ self: { ]; description = "Simple CRUD classes for easy view creation for Yesod"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yesod-websockets" = callPackage @@ -290669,8 +273094,6 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yet-another-logger" = callPackage @@ -290717,8 +273140,6 @@ self: { testHaskellDepends = [ base cryptonite hspec QuickCheck ]; description = "Executable specifications of composable cryptographic protocols"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yhccore" = callPackage @@ -290730,8 +273151,6 @@ self: { libraryHaskellDepends = [ base containers mtl pretty uniplate ]; description = "Yhc's Internal Core language"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yhseq" = callPackage @@ -290750,8 +273169,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Calculation of YH sequence system"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yi" = callPackage @@ -290792,8 +273209,6 @@ self: { ]; description = "Add-ons to Yi, the Haskell-Scriptable Editor"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yi-core" = callPackage @@ -291080,8 +273495,6 @@ self: { libraryHaskellDepends = [ base yi ]; description = "Monokai colour theme for the Yi text editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yi-rope" = callPackage @@ -291132,8 +273545,6 @@ self: { libraryHaskellDepends = [ base yi ]; description = "Solarized colour theme for the Yi text editor"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yi-spolsky" = callPackage @@ -291145,8 +273556,6 @@ self: { libraryHaskellDepends = [ base yi ]; description = "Spolsky colour theme for the Yi text editor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yi-vty" = callPackage @@ -291170,8 +273579,6 @@ self: { libraryHaskellDepends = [ base parsec process ]; description = "Haskell programming interface to Yices SMT solver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yices-easy" = callPackage @@ -291244,8 +273651,6 @@ self: { executableHaskellDepends = [ hsConfigure ]; description = "CUI FTP client like 'ftp', 'ncftp'"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yjftp-libs" = callPackage @@ -291259,8 +273664,6 @@ self: { libraryHaskellDepends = [ base directory ftphs mtl process unix ]; description = "CUI FTP client like 'ftp', 'ncftp'"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yjsvg" = callPackage @@ -291312,8 +273715,6 @@ self: { libraryHaskellDepends = [ base free mtl ]; description = "A truly tiny monadic parsing library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yoda" = callPackage @@ -291325,8 +273726,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Parser combinators for young padawans"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yoga" = callPackage @@ -291359,8 +273758,6 @@ self: { ]; description = "Generic Programming with Disbanded Data Types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "york-lava" = callPackage @@ -291372,8 +273769,6 @@ self: { libraryHaskellDepends = [ base containers haskell98 ]; description = "A library for digital circuit description"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "youtube" = callPackage @@ -291414,8 +273809,6 @@ self: { ]; description = "A YQL engine to execute Open Data Tables"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yst" = callPackage @@ -291438,8 +273831,6 @@ self: { ]; description = "Builds a static website from templates and data in YAML or CSV files"; license = "GPL"; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ytl" = callPackage @@ -291468,8 +273859,6 @@ self: { testHaskellDepends = [ base MonadRandom random yu-utils ]; description = "Auth module for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yu-core" = callPackage @@ -291482,8 +273871,6 @@ self: { testHaskellDepends = [ base blaze-markup hspec yu-utils ]; description = "The core of Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yu-launch" = callPackage @@ -291499,8 +273886,6 @@ self: { ]; description = "The launcher for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yu-tool" = callPackage @@ -291518,8 +273903,6 @@ self: { ]; description = "Tool for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yu-utils" = callPackage @@ -291543,8 +273926,6 @@ self: { ]; description = "Utils for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yuiGrid" = callPackage @@ -291580,8 +273961,6 @@ self: { ]; description = "A transcendental HTML parser gently wrapping the HXT library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yx" = callPackage @@ -291594,8 +273973,6 @@ self: { testHaskellDepends = [ array base bytestring hspec mtl ]; description = "Row-major coordinates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "yxdb-utils" = callPackage @@ -291634,8 +274011,6 @@ self: { ]; description = "Utilities for reading and writing Alteryx .yxdb files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "z3" = callPackage @@ -291665,8 +274040,6 @@ self: { testHaskellDepends = [ base containers hspec z3 ]; description = "High-level assertion encoding to Z3 solver"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "z85" = callPackage @@ -291690,8 +274063,6 @@ self: { ]; description = "Implementation of the z85 binary codec"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zabt" = callPackage @@ -291704,8 +274075,6 @@ self: { testHaskellDepends = [ base tasty tasty-hspec ]; description = "Simple-minded abstract binding trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zalgo" = callPackage @@ -291735,8 +274104,6 @@ self: { ]; description = "A tool for checking how much work is done on group projects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zasni-gerna" = callPackage @@ -291748,8 +274115,6 @@ self: { libraryHaskellDepends = [ base papillon ]; description = "lojban parser (zasni gerna)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zbar" = callPackage @@ -291763,8 +274128,6 @@ self: { libraryToolDepends = [ c2hs ]; description = "zbar bindings in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zbar;}; "zcache" = callPackage @@ -291859,8 +274222,6 @@ self: { ]; description = "Zendesk API for Haskell programming language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zenhack-prelude" = callPackage @@ -291874,8 +274235,6 @@ self: { libraryHaskellDepends = [ base ]; description = "@zenhack's personal custom prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zeno" = callPackage @@ -291895,8 +274254,6 @@ self: { ]; description = "An automated proof system for Haskell programs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zeolite-lang" = callPackage @@ -291955,8 +274312,6 @@ self: { testToolDepends = [ purescript ]; description = "Zephyr, tree-shaking for the PureScript language"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zero" = callPackage @@ -291989,8 +274344,6 @@ self: { ]; description = "Post to 0bin services"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zeromq-haskell" = callPackage @@ -292009,8 +274362,6 @@ self: { ]; description = "Bindings to ZeroMQ 2.1.x"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zeromq;}; "zeromq3-conduit" = callPackage @@ -292027,8 +274378,6 @@ self: { ]; description = "Conduit bindings for zeromq3-haskell"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zeromq3-haskell" = callPackage @@ -292051,8 +274400,6 @@ self: { ]; description = "Bindings to ZeroMQ 3.x"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zeromq;}; "zeromq4-clone-pattern" = callPackage @@ -292079,8 +274426,6 @@ self: { ]; description = "Haskell implementation of the ZeroMQ clone pattern"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zeromq4-conduit" = callPackage @@ -292099,8 +274444,6 @@ self: { testHaskellDepends = [ base ]; description = "Conduit wrapper around zeromq4-haskell"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zeromq4-haskell" = callPackage @@ -292145,8 +274488,6 @@ self: { ]; description = "Haskell implementation of several ZeroMQ patterns"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zeromq4-simple" = callPackage @@ -292185,8 +274526,6 @@ self: { ]; description = "ZeroTH - remove unnecessary TH dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zettelkast" = callPackage @@ -292211,8 +274550,6 @@ self: { testHaskellDepends = [ base ]; description = "Command-line utility for working with zettelkast files"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zifter" = callPackage @@ -292236,8 +274573,6 @@ self: { ]; description = "zifter"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zifter-cabal" = callPackage @@ -292253,8 +274588,6 @@ self: { ]; description = "zifter-cabal"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zifter-git" = callPackage @@ -292266,8 +274599,6 @@ self: { libraryHaskellDepends = [ base path process zifter ]; description = "zifter-git"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zifter-google-java-format" = callPackage @@ -292283,8 +274614,6 @@ self: { ]; description = "zifter-google-java-format"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zifter-hindent" = callPackage @@ -292300,8 +274629,6 @@ self: { ]; description = "zifter-hindent"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zifter-hlint" = callPackage @@ -292316,8 +274643,6 @@ self: { ]; description = "zifter-hlint"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zifter-stack" = callPackage @@ -292337,8 +274662,6 @@ self: { ]; description = "zifter-stack"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zigbee-znet25" = callPackage @@ -292355,8 +274678,6 @@ self: { testHaskellDepends = [ base bytestring mtl QuickCheck random ]; description = "XBee ZNet 2.5 (ZigBee) wireless modem communications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zim-parser" = callPackage @@ -292500,8 +274821,6 @@ self: { ]; description = "Working with zip archives via conduits"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zip-stream" = callPackage @@ -292538,8 +274857,6 @@ self: { libraryHaskellDepends = [ base directory mtl process ]; description = "Create simple list editor interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zipkin" = callPackage @@ -292555,8 +274872,6 @@ self: { ]; description = "Zipkin-style request tracing monad"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zipper" = callPackage @@ -292568,8 +274883,6 @@ self: { libraryHaskellDepends = [ base multirec ]; description = "Generic zipper for families of recursive datatypes"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zipper-extra" = callPackage @@ -292612,8 +274925,6 @@ self: { libraryHaskellDepends = [ base mtl yall ]; description = "A simple lens-based, generic, heterogenous, type-checked zipper library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ziptastic-client" = callPackage @@ -292635,8 +274946,6 @@ self: { ]; description = "A type-safe client for the Ziptastic API for doing forward and reverse geocoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ziptastic-core" = callPackage @@ -292656,8 +274965,6 @@ self: { ]; description = "Core Servant specification for the Ziptastic API for doing forward and reverse geocoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zlib" = callPackage @@ -292718,8 +275025,6 @@ self: { ]; description = "Enumerator interface for zlib compression"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zlib-lens" = callPackage @@ -292753,8 +275058,6 @@ self: { ]; description = "Language independent, reproducible, absolute types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zmcat" = callPackage @@ -292769,8 +275072,6 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Command-line tool for ZeroMQ"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zmidi-core" = callPackage @@ -292799,8 +275100,6 @@ self: { ]; description = "Representing MIDI a simple score"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zmqat" = callPackage @@ -292830,8 +275129,6 @@ self: { libraryHaskellDepends = [ base time ]; description = "ZoneInfo library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zoom" = callPackage @@ -292850,8 +275147,6 @@ self: { ]; description = "A rake/thor-like task runner written in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zoom-cache" = callPackage @@ -292883,8 +275178,6 @@ self: { ]; description = "A streamable, seekable, zoomable cache file format"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zoom-cache-pcm" = callPackage @@ -292901,8 +275194,6 @@ self: { ]; description = "Library for zoom-cache PCM audio codecs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zoom-cache-sndfile" = callPackage @@ -292922,8 +275213,6 @@ self: { ]; description = "Tools for generating zoom-cache-pcm files"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zoom-refs" = callPackage @@ -292935,8 +275224,6 @@ self: { libraryHaskellDepends = [ base lens stm ]; description = "Zoom (~ Functor) and pairing (~ Applicative) for mutable references"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zoovisitor" = callPackage @@ -292950,8 +275237,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A haskell binding to Apache Zookeeper C library(mt) using Haskell Z project"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) zookeeper_mt;}; "zot" = callPackage @@ -293017,8 +275302,6 @@ self: { ]; description = "Zero-Suppressed and Reduced Decision Diagrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zsh-battery" = callPackage @@ -293032,8 +275315,6 @@ self: { executableHaskellDepends = [ base directory filepath mtl ]; description = "Ascii bars representing battery status"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zstd" = callPackage @@ -293068,8 +275349,6 @@ self: { testHaskellDepends = [ base containers mtl multiset ]; description = "Automated theorem prover for the Zsyntax biochemical calculus"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "ztail" = callPackage @@ -293111,8 +275390,6 @@ self: { ]; description = "Creating and extracting arbitrary archives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zuramaru" = callPackage @@ -293151,8 +275428,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "A lisp processor, An inline-lisp, in Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zuul" = callPackage @@ -293205,8 +275480,6 @@ self: { ]; description = "Password strength estimation based on zxcvbn"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "zxcvbn-hs" = callPackage From 61901ffd0b7dfe1ee3ec5b7817cc1e86f993e54c Mon Sep 17 00:00:00 2001 From: Daniel Fullmer Date: Sat, 8 May 2021 19:04:48 -0700 Subject: [PATCH 035/163] rtl8812au: remove myself from maintainers --- pkgs/os-specific/linux/rtl8812au/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/os-specific/linux/rtl8812au/default.nix b/pkgs/os-specific/linux/rtl8812au/default.nix index 0ed6b443e04..d0ec97b7c9a 100644 --- a/pkgs/os-specific/linux/rtl8812au/default.nix +++ b/pkgs/os-specific/linux/rtl8812au/default.nix @@ -45,7 +45,7 @@ stdenv.mkDerivation rec { homepage = "https://github.com/gordboy/rtl8812au-5.9.3.2"; license = licenses.gpl2Only; platforms = platforms.linux; - maintainers = with maintainers; [ danielfullmer ]; + maintainers = with maintainers; [ ]; broken = kernel.kernelOlder "4.10" || kernel.isHardened; }; } From 2d0fb67feabb5ffb3973bd96e9802df0f7ee0e85 Mon Sep 17 00:00:00 2001 From: Johannes Schleifenbaum Date: Sun, 9 May 2021 08:28:58 +0200 Subject: [PATCH 036/163] nzbhydra2: 3.13.2 -> 3.14.1 --- pkgs/servers/nzbhydra2/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/servers/nzbhydra2/default.nix b/pkgs/servers/nzbhydra2/default.nix index 3aef89ecd8f..b1d3b4970d6 100644 --- a/pkgs/servers/nzbhydra2/default.nix +++ b/pkgs/servers/nzbhydra2/default.nix @@ -2,11 +2,11 @@ stdenv.mkDerivation rec { pname = "nzbhydra2"; - version = "3.13.2"; + version = "3.14.1"; src = fetchzip { url = "https://github.com/theotherp/${pname}/releases/download/v${version}/${pname}-${version}-linux.zip"; - sha512 = "2pi91y966qnq6q9qqnhglmbj4610jxyyqxiwa8zfmb8r48mzwzy3q5ga00h9qbhi6a8ghrfh1yvj4h9m17gk7l3rc5fw0r3mrk437nj"; + sha512 = "2mfrqqwrfjvr48vm4r0spda3vlg1h511r6hrlv7k9233ps97bjjir6hms82lgqnlirsixayxs47cldjy8amdn3vc6kxsifmbd6a924p"; stripRoot = false; }; From 15052e0c905f1b3b2159765818ae7aeaedeac4f7 Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Sun, 9 May 2021 01:40:31 +0200 Subject: [PATCH 037/163] haskellPackages.strict-writer: disable doctests on aarch64 fail due to GHC bug --- pkgs/development/haskell-modules/configuration-arm.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/development/haskell-modules/configuration-arm.nix b/pkgs/development/haskell-modules/configuration-arm.nix index bcbf3254053..af4893afe54 100644 --- a/pkgs/development/haskell-modules/configuration-arm.nix +++ b/pkgs/development/haskell-modules/configuration-arm.nix @@ -61,6 +61,7 @@ self: super: { hsakamai = dontCheck super.hsakamai; hsemail-ns = dontCheck super.hsemail-ns; openapi3 = dontCheck super.openapi3; + strict-writer = dontCheck super.strict-writer; # https://github.com/ekmett/half/issues/35 half = dontCheck super.half; From 227cfc24fef11b4ad179c0cadcd9d9da5f785f2d Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Sun, 9 May 2021 01:41:11 +0200 Subject: [PATCH 038/163] haskellPackages.HTF: attempt to fix test suite on darwin A script used at test time in HTF assumes that you have GNU coreutils installed in a manner where all executables are prefixed with a `g`. Since we use GNU coreutils in the stdenv anyways, this is not necessary and needs to be patched out. --- pkgs/development/haskell-modules/configuration-darwin.nix | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-darwin.nix b/pkgs/development/haskell-modules/configuration-darwin.nix index 6768bc5d6b4..4f7a6a131d7 100644 --- a/pkgs/development/haskell-modules/configuration-darwin.nix +++ b/pkgs/development/haskell-modules/configuration-darwin.nix @@ -161,4 +161,11 @@ self: super: { ] ++ (drv.librarySystemDepends or []); }); + HTF = overrideCabal super.HTF (drv: { + # GNU find is not prefixed in stdenv + postPatch = '' + substituteInPlace scripts/local-htfpp --replace "find=gfind" "find=find" + '' + (drv.postPatch or ""); + }); + } From f810b49906ce0d271de99cb99211be3449b2c105 Mon Sep 17 00:00:00 2001 From: Francesco Gazzetta Date: Sun, 9 May 2021 11:40:01 +0200 Subject: [PATCH 039/163] lmdbxx: update homepage to the fork --- pkgs/development/libraries/lmdbxx/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/libraries/lmdbxx/default.nix b/pkgs/development/libraries/lmdbxx/default.nix index 2d037afbe21..4fc1573eea1 100644 --- a/pkgs/development/libraries/lmdbxx/default.nix +++ b/pkgs/development/libraries/lmdbxx/default.nix @@ -17,7 +17,7 @@ stdenv.mkDerivation rec { makeFlags = [ "PREFIX=$(out)" ]; meta = { - homepage = "https://github.com/drycpp/lmdbxx#readme"; + homepage = "https://github.com/hoytech/lmdbxx#readme"; description = "C++11 wrapper for the LMDB embedded B+ tree database library"; license = lib.licenses.unlicense; maintainers = with lib.maintainers; [ fgaz ]; From 2f2c1ca08e97762d371f4085a7228649d9baa639 Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Sun, 9 May 2021 10:00:21 +0200 Subject: [PATCH 040/163] haskell-ci: provide ShellCheck 0.7.1 to fix build haskell-ci pins a specific version of ShellCheck as ShellCheck adds new checks with new minor versions which may break CI checks. --- .../haskell-modules/configuration-common.nix | 6 ++++ .../configuration-hackage2nix/main.yaml | 1 + .../haskell-modules/hackage-packages.nix | 28 +++++++++++++++++++ 3 files changed, 35 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index d8f5348f5ad..0f2aa45b4bc 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1864,4 +1864,10 @@ self: super: { # 2021-05-09: Restrictive bound on hspec-golden. Dep removed in newer versions. tomland = assert super.tomland.version == "1.3.2.0"; doJailbreak super.tomland; + # 2021-05-09 haskell-ci pins ShellCheck 0.7.1 + # https://github.com/haskell-CI/haskell-ci/issues/507 + haskell-ci = super.haskell-ci.override { + ShellCheck = self.ShellCheck_0_7_1; + }; + } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index fe22ee7ea6d..7019f200999 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -104,6 +104,7 @@ extra-packages: - gi-gdk == 3.0.24 # 2021-05-07: For haskell-gi 0.25 without gtk4 - gi-gtk < 4.0 # 2021-05-07: For haskell-gi 0.25 without gtk4 - gi-gdkx11 == 3.0.11 # 2021-05-07: For haskell-gi 0.25 without gtk4 + - ShellCheck == 0.7.1 # 2021-05-09: haskell-ci 0.12.1 pins this version package-maintainers: peti: diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 5e4c95a3283..4dd57eb6edf 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -16918,6 +16918,34 @@ self: { license = lib.licenses.mpl20; }) {}; + "ShellCheck_0_7_1" = callPackage + ({ mkDerivation, aeson, array, base, bytestring, containers + , deepseq, Diff, directory, filepath, mtl, parsec, process + , QuickCheck, regex-tdfa + }: + mkDerivation { + pname = "ShellCheck"; + version = "0.7.1"; + sha256 = "06m4wh891nah3y0br4wh3adpsb16zawkb2ijgf1vcz61fznj6ps1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson array base bytestring containers deepseq Diff directory + filepath mtl parsec process QuickCheck regex-tdfa + ]; + executableHaskellDepends = [ + aeson array base bytestring containers deepseq Diff directory + filepath mtl parsec QuickCheck regex-tdfa + ]; + testHaskellDepends = [ + aeson array base bytestring containers deepseq Diff directory + filepath mtl parsec QuickCheck regex-tdfa + ]; + description = "Shell script analysis tool"; + license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + }) {}; + "ShellCheck" = callPackage ({ mkDerivation, aeson, array, base, bytestring, containers , deepseq, Diff, directory, filepath, mtl, parsec, process From 119009e454007e7ae1881782d72002bfa35cfe5c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Romildo=20Malaquias?= Date: Sun, 9 May 2021 10:47:13 -0300 Subject: [PATCH 041/163] marwaita: 9.0 -> 9.1 --- pkgs/data/themes/marwaita/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/data/themes/marwaita/default.nix b/pkgs/data/themes/marwaita/default.nix index 7cb28f0a008..d06d9be9aa9 100644 --- a/pkgs/data/themes/marwaita/default.nix +++ b/pkgs/data/themes/marwaita/default.nix @@ -8,13 +8,13 @@ stdenv.mkDerivation rec { pname = "marwaita"; - version = "9.0"; + version = "9.1"; src = fetchFromGitHub { owner = "darkomarko42"; repo = pname; rev = version; - sha256 = "12mgs9f8mwfpdpxdwyknw7zvgaqp96kzcv7fcrvrnm9i4ind5zra"; + sha256 = "0974pfcdbhajxvd6fnp2kix963s28n2il9w879h5zm1f6ayglsfz"; }; buildInputs = [ From d6f915eb0ec2cbe40e595d9b69dafb0276b81d50 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20Sch=C3=BCtz?= Date: Sun, 9 May 2021 15:27:55 +0200 Subject: [PATCH 042/163] surf: 2019-02-08 -> 2.1 --- pkgs/applications/networking/browsers/surf/default.nix | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/networking/browsers/surf/default.nix b/pkgs/applications/networking/browsers/surf/default.nix index 26cbc92adac..7bf3ee9e75b 100644 --- a/pkgs/applications/networking/browsers/surf/default.nix +++ b/pkgs/applications/networking/browsers/surf/default.nix @@ -7,12 +7,13 @@ stdenv.mkDerivation rec { pname = "surf"; - version = "unstable-2019-02-08"; + version = "2.1"; + # tarball is missing file common.h src = fetchgit { url = "git://git.suckless.org/surf"; - rev = "d068a3878b6b9f2841a49cd7948cdf9d62b55585"; - sha256 = "0pjsv2q8c74sdmqsalym8wa2lv55lj4pd36miam5wd12769xw68m"; + rev = version; + sha256 = "1v926hiayddylq79n8l7dy51bm0dsa9n18nx9bkhg666cx973x4z"; }; nativeBuildInputs = [ pkg-config wrapGAppsHook ]; From d7e62a766cf68e952c6be9e6c7c8d1a6b9027d0a Mon Sep 17 00:00:00 2001 From: joachimschmidt557 Date: Sat, 8 May 2021 17:23:37 +0800 Subject: [PATCH 043/163] timew-sync-server: init at 1.0.0 --- .../misc/timew-sync-server/default.nix | 23 +++++++++++++++++++ pkgs/top-level/all-packages.nix | 2 ++ 2 files changed, 25 insertions(+) create mode 100644 pkgs/applications/misc/timew-sync-server/default.nix diff --git a/pkgs/applications/misc/timew-sync-server/default.nix b/pkgs/applications/misc/timew-sync-server/default.nix new file mode 100644 index 00000000000..86a428df38f --- /dev/null +++ b/pkgs/applications/misc/timew-sync-server/default.nix @@ -0,0 +1,23 @@ +{ lib, buildGoModule, fetchFromGitHub }: + +buildGoModule rec { + pname = "timew-sync-server"; + version = "1.0.0"; + + src = fetchFromGitHub { + owner = "timewarrior-synchronize"; + repo = pname; + rev = "v${version}"; + sha256 = "041j618c2bcryhgi2j2w5zlfcxcklgbir2xj3px4w7jxbbg6p68n"; + }; + + vendorSha256 = "0wbd4cpswgbr839sk8qwly8gjq4lqmq448m624akll192mzm9wj7"; + + meta = with lib; { + homepage = "https://github.com/timewarrior-synchronize/timew-sync-server"; + description = "Server component of timewarrior synchronization application"; + license = licenses.mit; + maintainers = [ maintainers.joachimschmidt557 ]; + platforms = platforms.linux; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 544d2f71825..94e6c0c2efd 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -26409,6 +26409,8 @@ in timewarrior = callPackage ../applications/misc/timewarrior { }; + timew-sync-server = callPackage ../applications/misc/timew-sync-server { }; + timg = callPackage ../tools/graphics/timg { }; timidity = callPackage ../tools/misc/timidity { }; From 36f44dc6ab74794d213675900e33c30b88d5d4d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Romildo=20Malaquias?= Date: Sun, 9 May 2021 11:06:26 -0300 Subject: [PATCH 044/163] marwaita-manjaro: 1.8 -> 2.0 --- pkgs/data/themes/marwaita-manjaro/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/data/themes/marwaita-manjaro/default.nix b/pkgs/data/themes/marwaita-manjaro/default.nix index 4189f0ed48d..d467526582c 100644 --- a/pkgs/data/themes/marwaita-manjaro/default.nix +++ b/pkgs/data/themes/marwaita-manjaro/default.nix @@ -8,13 +8,13 @@ stdenv.mkDerivation rec { pname = "marwaita-manjaro"; - version = "1.8"; + version = "2.0"; src = fetchFromGitHub { owner = "darkomarko42"; repo = pname; rev = version; - sha256 = "0zxj20inwdfxhsc7cq6b3ijkxmrhnrwvbmyb1lw4vfjs4p4wrws0"; + sha256 = "1si0gaa1njyf4194i6rbx4qjp31sw238svvb2x8r8cfhm8mkhm8d"; }; buildInputs = [ From 10854c5a4dc3e79a273fd80ccbe78e2655708dd6 Mon Sep 17 00:00:00 2001 From: Michael Raskin <7c6f434c@mail.ru> Date: Sun, 9 May 2021 17:14:07 +0200 Subject: [PATCH 045/163] stumpwm: redirect to lispPackages.stumpwm; stumpwm-git: drop --- .../window-managers/stumpwm/default.nix | 103 ------------------ .../stumpwm/fix-module-path.patch | 16 --- pkgs/top-level/aliases.nix | 1 + pkgs/top-level/all-packages.nix | 9 +- 4 files changed, 2 insertions(+), 127 deletions(-) delete mode 100644 pkgs/applications/window-managers/stumpwm/default.nix delete mode 100644 pkgs/applications/window-managers/stumpwm/fix-module-path.patch diff --git a/pkgs/applications/window-managers/stumpwm/default.nix b/pkgs/applications/window-managers/stumpwm/default.nix deleted file mode 100644 index 0f8d933a06d..00000000000 --- a/pkgs/applications/window-managers/stumpwm/default.nix +++ /dev/null @@ -1,103 +0,0 @@ -{ lib, stdenv, fetchgit, autoconf, sbcl, lispPackages, xdpyinfo, texinfo4 -, makeWrapper , rlwrap, gnused, gnugrep, coreutils, xprop -, extraModulePaths ? [] -, version }: - -let - contrib = (fetchgit { - url = "https://github.com/stumpwm/stumpwm-contrib.git"; - rev = "9bebe3622b2b6c31a6bada9055ef3862fa79b86f"; - sha256 = "1ml6mjk2fsfv4sf65fdbji3q5x0qiq99g1k8w7a99gsl2i8h60gc"; - }); - versionSpec = { - latest = { - name = "1.0.0"; - rev = "refs/tags/1.0.0"; - sha256 = "16r0lwhxl8g71masmfbjr7s7m7fah4ii4smi1g8zpbpiqjz48ryb"; - patches = []; - }; - "0.9.9" = { - name = "0.9.9"; - rev = "refs/tags/0.9.9"; - sha256 = "0hmvbdk2yr5wrkiwn9dfzf65s4xc2qifj0sn6w2mghzp96cph79k"; - patches = [ ./fix-module-path.patch ]; - }; - git = { - name = "git-20170203"; - rev = "d20f24e58ab62afceae2afb6262ffef3cc318b97"; - sha256 = "1gi29ds1x6dq7lz8lamnhcvcrr3cvvrg5yappfkggyhyvib1ii70"; - patches = []; - }; - }.${version}; -in -stdenv.mkDerivation { - name = "stumpwm-${versionSpec.name}"; - - src = fetchgit { - url = "https://github.com/stumpwm/stumpwm"; - rev = versionSpec.rev; - sha256 = versionSpec.sha256; - }; - - # NOTE: The patch needs an update for the next release. - # `(stumpwm:set-module-dir "@MODULE_DIR@")' needs to be in it. - patches = versionSpec.patches; - - buildInputs = [ - texinfo4 makeWrapper autoconf - sbcl - lispPackages.clx - lispPackages.cl-ppcre - lispPackages.alexandria - xdpyinfo - ]; - - - # Stripping destroys the generated SBCL image - dontStrip = true; - - configurePhase = '' - ./autogen.sh - ./configure --prefix=$out --with-module-dir=$out/share/stumpwm/modules - ''; - - preBuild = '' - cp -r --no-preserve=mode ${contrib} modules - substituteInPlace head.lisp \ - --replace 'run-shell-command "xdpyinfo' 'run-shell-command "${xdpyinfo}/bin/xdpyinfo' - ''; - - installPhase = '' - mkdir -pv $out/bin - make install - - mkdir -p $out/share/stumpwm/modules - cp -r modules/* $out/share/stumpwm/modules/ - for d in ${lib.concatStringsSep " " extraModulePaths}; do - cp -r --no-preserve=mode "$d" $out/share/stumpwm/modules/ - done - - # Copy stumpish; - cp $out/share/stumpwm/modules/util/stumpish/stumpish $out/bin/ - chmod +x $out/bin/stumpish - wrapProgram $out/bin/stumpish \ - --prefix PATH ":" "${lib.makeBinPath [ rlwrap gnused gnugrep coreutils xprop ]}" - - # Paths in the compressed image $out/bin/stumpwm are not - # recognized by Nix. Add explicit reference here. - mkdir $out/nix-support - echo ${xdpyinfo} > $out/nix-support/xdpyinfo - ''; - - passthru = { - inherit sbcl lispPackages contrib; - }; - - meta = with lib; { - description = "A tiling window manager for X11"; - homepage = "https://github.com/stumpwm/"; - license = licenses.gpl2Plus; - platforms = platforms.linux; - broken = true; # 2018-04-11 - }; -} diff --git a/pkgs/applications/window-managers/stumpwm/fix-module-path.patch b/pkgs/applications/window-managers/stumpwm/fix-module-path.patch deleted file mode 100644 index 79bfaad3dec..00000000000 --- a/pkgs/applications/window-managers/stumpwm/fix-module-path.patch +++ /dev/null @@ -1,16 +0,0 @@ -diff --git a/make-image.lisp.in b/make-image.lisp.in -index 121e9d6..2210242 100644 ---- a/make-image.lisp.in -+++ b/make-image.lisp.in -@@ -2,7 +2,10 @@ - - (load "load-stumpwm.lisp") - --#-ecl (stumpwm:set-module-dir "@CONTRIB_DIR@") -+(setf asdf::*immutable-systems* -+ (uiop:list-to-hash-set (asdf:already-loaded-systems))) -+ -+#-ecl (stumpwm:set-module-dir "@MODULE_DIR@") - - #+sbcl - (sb-ext:save-lisp-and-die "stumpwm" :toplevel (lambda () diff --git a/pkgs/top-level/aliases.nix b/pkgs/top-level/aliases.nix index 44460e8f911..b8a804f9aaa 100644 --- a/pkgs/top-level/aliases.nix +++ b/pkgs/top-level/aliases.nix @@ -759,6 +759,7 @@ mapAliases ({ squid4 = squid; # added 2019-08-22 sshfsFuse = sshfs-fuse; # added 2016-09 stanchion = throw "Stanchion was part of riak-cs which is not maintained anymore"; # added 2020-10-14 + stumpwm-git = throw "stumpwm-git has been broken for a long time and lispPackages.stumpwm follows Quicklisp that is close to git version"; # added 2021-05-09 surf-webkit2 = surf; # added 2017-04-02 sup = throw "sup was deprecated on 2019-09-10: abandoned by upstream"; swfdec = throw "swfdec has been removed as broken and unmaintained."; # added 2020-08-23 diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 3fd58e1adac..d7ca36707b6 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -26192,14 +26192,7 @@ in stumpish = callPackage ../applications/window-managers/stumpish {}; - stumpwm = callPackage ../applications/window-managers/stumpwm { - version = "latest"; - }; - - stumpwm-git = stumpwm.override { - version = "git"; - inherit sbcl lispPackages; - }; + stumpwm = lispPackages.stumpwm; sublime = callPackage ../applications/editors/sublime/2 { }; From 54a69f5a7cd2c50c157a7eed6a1bebd92c0d1300 Mon Sep 17 00:00:00 2001 From: Yevhen Shymotiuk Date: Sun, 9 May 2021 15:02:28 +0300 Subject: [PATCH 046/163] python3Packages.pipx: 0.16.1.0 -> 0.16.2.1 --- pkgs/development/python-modules/pipx/default.nix | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/pipx/default.nix b/pkgs/development/python-modules/pipx/default.nix index 34a7bc6b31a..e6f9242dde6 100644 --- a/pkgs/development/python-modules/pipx/default.nix +++ b/pkgs/development/python-modules/pipx/default.nix @@ -12,7 +12,7 @@ buildPythonPackage rec { pname = "pipx"; - version = "0.16.1.0"; + version = "0.16.2.1"; disabled = pythonOlder "3.6"; @@ -21,7 +21,7 @@ buildPythonPackage rec { owner = "pipxproject"; repo = pname; rev = version; - sha256 = "081raqsaq7i2x4yxhxppv930jhajdwmngin5wazy7vqhiy3xc669"; + sha256 = "1agdp8j4lw6z0lk2vv1m8d49r5vwfkpal3hdgq67vnjyp9904pf6"; }; propagatedBuildInputs = [ @@ -54,6 +54,7 @@ buildPythonPackage rec { "suffix" "legacy_venv" "determination" + "json" ]; meta = with lib; { From e4f1d9592cb9a39cec5612425132f1c237ce29ff Mon Sep 17 00:00:00 2001 From: branwright1 Date: Sun, 9 May 2021 17:32:05 +0100 Subject: [PATCH 047/163] river: unstable-2021-04-27 > unstable-2021-05-07 --- .../window-managers/river/default.nix | 22 +++++++++++-------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/pkgs/applications/window-managers/river/default.nix b/pkgs/applications/window-managers/river/default.nix index 9b40d34b6f2..e82f290169c 100644 --- a/pkgs/applications/window-managers/river/default.nix +++ b/pkgs/applications/window-managers/river/default.nix @@ -6,37 +6,41 @@ stdenv.mkDerivation rec { pname = "river"; - version = "unstable-2021-04-27"; + version = "unstable-2021-05-07"; src = fetchFromGitHub { owner = "ifreund"; repo = pname; - rev = "0c8e718d95a6a621b9cba0caa9158915e567b076"; - sha256 = "1jjh0dzxi7hy4mg8vag6ipfwb9qxm5lfc07njp1mx6m81nq76ybk"; + rev = "7ffa2f4b9e7abf7d152134f555373c2b63ccfc1d"; + sha256 = "1z5qjid73lfn654f2k74nwgvpr88fpdfpbzhihybx9cyy1mqfz7j"; fetchSubmodules = true; }; - buildInputs = [ xwayland wayland-protocols wlroots pixman + buildInputs = [ wayland-protocols wlroots pixman libxkbcommon pixman udev libevdev libX11 libGL ]; + dontConfigure = true; + preBuild = '' export HOME=$TMPDIR ''; installPhase = '' + runHook preInstall zig build -Drelease-safe -Dxwayland -Dman-pages --prefix $out install + runHook postInstall ''; - nativeBuildInputs = [ zig wayland scdoc pkg-config ]; + nativeBuildInputs = [ zig wayland xwayland scdoc pkg-config ]; + # Builder patch install dir into river to get default config + # When installFlags is removed, river becomes half broken + # see https://github.com/ifreund/river/blob/7ffa2f4b9e7abf7d152134f555373c2b63ccfc1d/river/main.zig#L56 installFlags = [ "DESTDIR=$(out)" ]; meta = with lib; { - description = "A dynamic tiling wayland compositor"; - longDescription = '' - river is a dynamic tiling wayland compositor that takes inspiration from dwm and bspwm. - ''; homepage = "https://github.com/ifreund/river"; + description = "A dynamic tiling wayland compositor"; license = licenses.gpl3Plus; platforms = platforms.linux; maintainers = with maintainers; [ branwright1 ]; From e28009cef50fa4180fa87b348cca9afe160737f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phan=20Kochen?= Date: Sun, 9 May 2021 19:55:51 +0200 Subject: [PATCH 048/163] tremor-rs: build on darwin --- pkgs/tools/misc/tremor-rs/default.nix | 7 ++++--- pkgs/top-level/all-packages.nix | 4 +++- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/pkgs/tools/misc/tremor-rs/default.nix b/pkgs/tools/misc/tremor-rs/default.nix index 73640de76bf..92bbfdb4def 100644 --- a/pkgs/tools/misc/tremor-rs/default.nix +++ b/pkgs/tools/misc/tremor-rs/default.nix @@ -1,5 +1,5 @@ { lib, rustPlatform, pkg-config, cmake, llvmPackages, openssl, fetchFromGitHub -, installShellFiles }: +, installShellFiles, stdenv, Security, libiconv }: rustPlatform.buildRustPackage rec { pname = "tremor"; @@ -16,7 +16,8 @@ rustPlatform.buildRustPackage rec { nativeBuildInputs = [ cmake pkg-config installShellFiles ]; - buildInputs = [ openssl ]; + buildInputs = [ openssl ] + ++ lib.optionals stdenv.hostPlatform.isDarwin [ Security libiconv ]; # TODO export TREMOR_PATH($out/lib) variable postInstall = '' @@ -40,7 +41,7 @@ rustPlatform.buildRustPackage rec { description = "Early stage event processing system for unstructured data with rich support for structural pattern matching, filtering and transformation"; homepage = "https://www.tremor.rs/"; license = licenses.asl20; - platforms = [ "x86_64-linux" ]; + platforms = platforms.x86_64; maintainers = with maintainers; [ humancalico ]; }; } diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 3fd58e1adac..3eaf1d09612 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -9454,7 +9454,9 @@ in tre = callPackage ../development/libraries/tre { }; - tremor-rs = callPackage ../tools/misc/tremor-rs { }; + tremor-rs = callPackage ../tools/misc/tremor-rs { + inherit (darwin.apple_sdk.frameworks) Security; + }; ts = callPackage ../tools/system/ts { }; From 1e42bda0226ddd8e10c30988f0260f82b5f7228d Mon Sep 17 00:00:00 2001 From: Robin Gloster Date: Sun, 9 May 2021 14:41:17 -0500 Subject: [PATCH 049/163] moonlight-embedded: 2.4.10 -> 2.4.11 --- pkgs/applications/misc/moonlight-embedded/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/misc/moonlight-embedded/default.nix b/pkgs/applications/misc/moonlight-embedded/default.nix index aa23f187967..dd3fb854599 100644 --- a/pkgs/applications/misc/moonlight-embedded/default.nix +++ b/pkgs/applications/misc/moonlight-embedded/default.nix @@ -6,13 +6,13 @@ stdenv.mkDerivation rec { pname = "moonlight-embedded"; - version = "2.4.10"; + version = "2.4.11"; src = fetchFromGitHub { owner = "irtimmer"; repo = "moonlight-embedded"; rev = "v${version}"; - sha256 = "0m5i3q3hbjl51cndjpz5hxi3br6fvpn1fzdv0f6lxjxgw9z32413"; + sha256 = "19wm4gizj8q6j4jwqfcn3bkhms97d8afwxmqjmjnqqxzpd2gxc16"; fetchSubmodules = true; }; From 4ff0c782a386084c1befd5d1882fa3a2bffb673e Mon Sep 17 00:00:00 2001 From: "R. RyanTM" Date: Sun, 9 May 2021 20:32:06 +0000 Subject: [PATCH 050/163] jmol: 14.31.36 -> 14.31.38 --- pkgs/applications/science/chemistry/jmol/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/science/chemistry/jmol/default.nix b/pkgs/applications/science/chemistry/jmol/default.nix index 2da5a070ee8..d8f7bd5eb55 100644 --- a/pkgs/applications/science/chemistry/jmol/default.nix +++ b/pkgs/applications/science/chemistry/jmol/default.nix @@ -17,14 +17,14 @@ let }; in stdenv.mkDerivation rec { - version = "14.31.36"; + version = "14.31.38"; pname = "jmol"; src = let baseVersion = "${lib.versions.major version}.${lib.versions.minor version}"; in fetchurl { url = "mirror://sourceforge/jmol/Jmol/Version%20${baseVersion}/Jmol%20${version}/Jmol-${version}-binary.tar.gz"; - sha256 = "sha256-YwXgRRUZ75l1ZptscsZae2mwkRkYXJeWSrPvw+R6TkI="; + sha256 = "sha256-yXJ1KtTH3bi24GFiVXu8zzQkreDkqbCxgm7fVoSJepg="; }; patchPhase = '' From 2fcba3a99958855371e3d4c09b0f8ff2c32ceb19 Mon Sep 17 00:00:00 2001 From: Thomas Gerbet Date: Wed, 5 May 2021 17:42:05 +0200 Subject: [PATCH 051/163] peek: use ffmpeg 4 See migrate away from ffmpeg_3 #120705. --- pkgs/applications/video/peek/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/video/peek/default.nix b/pkgs/applications/video/peek/default.nix index d4e8f9d21b2..edeb848867f 100644 --- a/pkgs/applications/video/peek/default.nix +++ b/pkgs/applications/video/peek/default.nix @@ -16,7 +16,7 @@ , glib , cairo , keybinder3 -, ffmpeg_3 +, ffmpeg , python3 , libxml2 , gst_all_1 @@ -66,7 +66,7 @@ stdenv.mkDerivation rec { ''; preFixup = '' - gappsWrapperArgs+=(--prefix PATH : ${lib.makeBinPath [ which ffmpeg_3 gifski ]}) + gappsWrapperArgs+=(--prefix PATH : ${lib.makeBinPath [ which ffmpeg gifski ]}) ''; passthru = { @@ -79,7 +79,7 @@ stdenv.mkDerivation rec { meta = with lib; { homepage = "https://github.com/phw/peek"; description = "Simple animated GIF screen recorder with an easy to use interface"; - license = licenses.gpl3; + license = licenses.gpl3Plus; maintainers = with maintainers; [ puffnfresh ]; platforms = platforms.linux; }; From 521763440f0cd750565b39c9a7227085ee4b1795 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Sun, 9 May 2021 22:58:29 +0200 Subject: [PATCH 052/163] python3Packages.androidtv: 0.0.58 -> 0.0.59 --- pkgs/development/python-modules/androidtv/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/androidtv/default.nix b/pkgs/development/python-modules/androidtv/default.nix index 98ab09fd8e6..02edcea42ef 100644 --- a/pkgs/development/python-modules/androidtv/default.nix +++ b/pkgs/development/python-modules/androidtv/default.nix @@ -11,14 +11,14 @@ buildPythonPackage rec { pname = "androidtv"; - version = "0.0.58"; + version = "0.0.59"; # pypi does not contain tests, using github sources instead src = fetchFromGitHub { owner = "JeffLIrion"; repo = "python-androidtv"; rev = "v${version}"; - sha256 = "sha256-/5sYiYRFa8XJJ4QSxLzJBHaKfAKsGETiVDHerNQ79U8="; + sha256 = "sha256-QuKWOo+QMBpVJglwvaSMbKKYMN/MW31E7BgIMchESG8="; }; propagatedBuildInputs = [ adb-shell pure-python-adb ] From 4ee3a9c0430da0ba7db6d43aefdae90692a78453 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Sun, 9 May 2021 23:01:02 +0200 Subject: [PATCH 053/163] home-assistant: enable androidtv tests --- pkgs/servers/home-assistant/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index f535477827c..e19f53fcbbb 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -193,6 +193,7 @@ in with py.pkgs; buildPythonApplication rec { "accuweather" "airly" "analytics" + "androidtv" "alert" "api" "auth" From 86632357e6e18173fe0d7924150bacba646bf3f7 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Sun, 9 May 2021 23:33:02 +0200 Subject: [PATCH 054/163] python3Packages.async-upnp-client: 0.16.2 -> 0.17.0 --- pkgs/development/python-modules/async-upnp-client/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/async-upnp-client/default.nix b/pkgs/development/python-modules/async-upnp-client/default.nix index 2fa186a07d1..cc0e0513ed1 100644 --- a/pkgs/development/python-modules/async-upnp-client/default.nix +++ b/pkgs/development/python-modules/async-upnp-client/default.nix @@ -13,14 +13,14 @@ buildPythonPackage rec { pname = "async-upnp-client"; - version = "0.16.2"; + version = "0.17.0"; disabled = pythonOlder "3.5"; src = fetchFromGitHub { owner = "StevenLooman"; repo = "async_upnp_client"; rev = version; - sha256 = "0raq3jgh2aqllycvvi0x2j5f602vv8ggmyd3879jzqbz2znngsgb"; + sha256 = "sha256-k71fpwL999Qz/vOsmpxykMVKgASzHis/exY/8aDoAkg="; }; propagatedBuildInputs = [ From 6b60709aa51a45a7f83b7c5716d677c0a98c8fe8 Mon Sep 17 00:00:00 2001 From: pacien Date: Mon, 10 May 2021 00:44:53 +0200 Subject: [PATCH 055/163] perlPackages.PDFBuilder: 3.021 -> 3.022 --- pkgs/top-level/perl-packages.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/top-level/perl-packages.nix b/pkgs/top-level/perl-packages.nix index 10a6de27deb..539a06bf4a1 100644 --- a/pkgs/top-level/perl-packages.nix +++ b/pkgs/top-level/perl-packages.nix @@ -16705,10 +16705,10 @@ let PDFBuilder = buildPerlPackage { pname = "PDF-Builder"; - version = "3.021"; + version = "3.022"; src = fetchurl { - url = "mirror://cpan/authors/id/P/PM/PMPERRY/PDF-Builder-3.021.tar.gz"; - sha256 = "1hc22s5gdspr5nyfmix3cwdzcw7z66pcqxy422ksmbninbzv4z93"; + url = "mirror://cpan/authors/id/P/PM/PMPERRY/PDF-Builder-3.022.tar.gz"; + sha256 = "0cfafyci5xar567z82w0vcjrwa6inf1a9ydszgkz51bi1ilj8as8"; }; checkInputs = [ TestException TestMemoryCycle ]; propagatedBuildInputs = [ FontTTF ]; From 13b226745a14abfc5dbf44dcee620d6d0f6fc58c Mon Sep 17 00:00:00 2001 From: pacien Date: Mon, 10 May 2021 00:45:11 +0200 Subject: [PATCH 056/163] gscan2pdf: 2.11.1 -> 2.12.1 --- pkgs/applications/graphics/gscan2pdf/default.nix | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/graphics/gscan2pdf/default.nix b/pkgs/applications/graphics/gscan2pdf/default.nix index 67f624ce9c9..a44d4f6408c 100644 --- a/pkgs/applications/graphics/gscan2pdf/default.nix +++ b/pkgs/applications/graphics/gscan2pdf/default.nix @@ -10,11 +10,11 @@ with lib; perlPackages.buildPerlPackage rec { pname = "gscan2pdf"; - version = "2.11.1"; + version = "2.12.1"; src = fetchurl { url = "mirror://sourceforge/gscan2pdf/${version}/${pname}-${version}.tar.xz"; - sha256 = "0aigngfi5dbjihn43c6sg865i1ybfzj0w81zclzy8r9nqiqq0wma"; + sha256 = "0x20wpqqw6534rn73660zdfy4c3jpg2n31py566k0x2nd6g0mhg5"; }; nativeBuildInputs = [ wrapGAppsHook ]; @@ -112,6 +112,12 @@ perlPackages.buildPerlPackage rec { # t/169_import_scan.t ........................... Dubious, test returned 1 (wstat 256, 0x100) rm t/169_import_scan.t + # Disable a test which passes but reports an incorrect status + # t/0601_Dialog_Scan.t .......................... All 14 subtests passed + # t/0601_Dialog_Scan.t (Wstat: 139 Tests: 14 Failed: 0) + # Non-zero wait status: 139 + rm t/0601_Dialog_Scan.t + xvfb-run -s '-screen 0 800x600x24' \ make test ''; From 5bd24c378318e54ac9a698e8f93b3066ff9e82cf Mon Sep 17 00:00:00 2001 From: upkeep-bot Date: Mon, 10 May 2021 00:22:37 +0000 Subject: [PATCH 057/163] vscodium: 1.55.2 -> 1.56.0 --- pkgs/applications/editors/vscode/vscodium.nix | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pkgs/applications/editors/vscode/vscodium.nix b/pkgs/applications/editors/vscode/vscodium.nix index 4850a9cd7dd..9bd8e0f245b 100644 --- a/pkgs/applications/editors/vscode/vscodium.nix +++ b/pkgs/applications/editors/vscode/vscodium.nix @@ -13,10 +13,10 @@ let archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz"; sha256 = { - x86_64-linux = "12mdila9gspj6b9s6488j0ba264vm4a46546kplma7s6gkkpz4zx"; - x86_64-darwin = "15wdznihc2ra2fjy9p4j898vazjr4h5yighaxh7jk9kcvarg1658"; - aarch64-linux = "0plw1an1z3v333irbc53skrmq2klas21srriiqkvmkgkfvpx1rq2"; - armv7l-linux = "1ys82pa18qshpinaqqrskxvljzap20xwj5ncffn031yacg1y2qx2"; + x86_64-linux = "01bg6bjjbbdywd7r13safa5nxx1y9a8zia7q6z5anc60hfylvhd2"; + x86_64-darwin = "0xkzxlp45f9vl9yrrk8fynwpsv85yjmsp6ylm2fbmfddf9bqkjsb"; + aarch64-linux = "028g359jrbs1hbxwq4gqq1s08vv38i3x52vjalqrpc6b0wc5cc2w"; + armv7l-linux = "06w5h7q799b9kwagi6w3320yjdp66cwr6d0dd7sl4sirqnrap0i4"; }.${system}; sourceRoot = { @@ -33,7 +33,7 @@ in # Please backport all compatible updates to the stable release. # This is important for the extension ecosystem. - version = "1.55.2"; + version = "1.56.0"; pname = "vscodium"; executableName = "codium"; From 0c46a853eb54a094d4c6d5c0f4c2d9f0ea1e81f1 Mon Sep 17 00:00:00 2001 From: Arijit Basu Date: Mon, 10 May 2021 07:02:14 +0530 Subject: [PATCH 058/163] xplr: 0.7.2 -> 0.8.4 --- pkgs/applications/misc/xplr/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/misc/xplr/default.nix b/pkgs/applications/misc/xplr/default.nix index 8a8d2b071d0..1bc02e8952e 100644 --- a/pkgs/applications/misc/xplr/default.nix +++ b/pkgs/applications/misc/xplr/default.nix @@ -2,16 +2,16 @@ rustPlatform.buildRustPackage rec { pname = "xplr"; - version = "0.7.2"; + version = "0.8.4"; src = fetchFromGitHub { owner = "sayanarijit"; repo = pname; rev = "v${version}"; - sha256 = "1mqxnahhbf394niyc8i6gk2y3i7lj9cj71k460r58cmir5fch82m"; + sha256 = "00kmmdwwf9cll25bkszgin2021ggf9b28jlcpicin5kgw4iwlhkj"; }; - cargoSha256 = "1dfcmkfclkq5b103jl98yalcl3mnvsq8xpkdasf72d3wgzarih16"; + cargoSha256 = "1j43vwb885h355wdmjijz1qpkqn1dmb93hwi6vc035vkbbxs1g4r"; meta = with lib; { description = "A hackable, minimal, fast TUI file explorer"; From ec990c9c23e008024b7851395deff3868d179600 Mon Sep 17 00:00:00 2001 From: figsoda Date: Sun, 9 May 2021 22:40:00 -0400 Subject: [PATCH 059/163] gitoxide: 0.6.0 -> 0.7.0 --- .../version-management/gitoxide/default.nix | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/pkgs/applications/version-management/gitoxide/default.nix b/pkgs/applications/version-management/gitoxide/default.nix index 51fc538261d..6db7cbad6e9 100644 --- a/pkgs/applications/version-management/gitoxide/default.nix +++ b/pkgs/applications/version-management/gitoxide/default.nix @@ -1,19 +1,19 @@ -{ lib, stdenv, rustPlatform, fetchFromGitHub, pkg-config, openssl, Security }: +{ lib, stdenv, rustPlatform, cmake, fetchFromGitHub, pkg-config, openssl, Security }: rustPlatform.buildRustPackage rec { pname = "gitoxide"; - version = "0.6.0"; + version = "0.7.0"; src = fetchFromGitHub { owner = "Byron"; repo = "gitoxide"; rev = "v${version}"; - sha256 = "qt1IN/5+yw5lrQ00YsvXUcUXCxd97EtNf5JvxJVa7uc="; + sha256 = "12f5qrrfjfqp1aph2nmfi9nyzs1ndvgrb3y53mrszm9kf7fa6pyg"; }; - cargoSha256 = "mitUyf/z7EgjKzFy8ZER8Ceoe9tk6r0ctSYdDG87rIU="; + cargoSha256 = "0gw19zdxbkgnj1kcyqn1naj1dnhsx10j860m0xgs5z7bbvfg82p6"; - nativeBuildInputs = [ pkg-config ]; + nativeBuildInputs = [ cmake pkg-config ]; buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ Security ]; From 062526f732d3ddd45bf9df0682ca1cf54d31c8f0 Mon Sep 17 00:00:00 2001 From: Nicolas Berbiche Date: Sun, 9 May 2021 22:54:40 -0400 Subject: [PATCH 060/163] bottom: 0.5.7 -> 0.6.0 --- pkgs/tools/system/bottom/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/tools/system/bottom/default.nix b/pkgs/tools/system/bottom/default.nix index d96573325b8..1c097297041 100644 --- a/pkgs/tools/system/bottom/default.nix +++ b/pkgs/tools/system/bottom/default.nix @@ -2,13 +2,13 @@ rustPlatform.buildRustPackage rec { pname = "bottom"; - version = "0.5.7"; + version = "0.6.0"; src = fetchFromGitHub { owner = "ClementTsang"; repo = pname; rev = version; - sha256 = "sha256-9L7FtYIaWSOwNQ8zOLvxjt51o8A5MqqfF/iIyJs2TJA="; + sha256 = "sha256-z0WLD6XOlsM5UL9/nUU5Jk1F+UFLm4N42zAlgY3zEbM="; }; prePatch = '' @@ -19,7 +19,7 @@ rustPlatform.buildRustPackage rec { buildInputs = lib.optional stdenv.hostPlatform.isDarwin darwin.apple_sdk.frameworks.IOKit; - cargoSha256 = "sha256-4oH1A88Qn0c6hkE/1b6mTrEIph8xT98j+DkP9/5JALs="; + cargoSha256 = "sha256-m2UVpsVTEmf6fgE1CFRE6+3097bKnkrMKtY3fAOjS2E="; doCheck = false; From b56bd9afccf63152eb59f891863458049aa4a8e3 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Mon, 10 May 2021 08:13:19 +0200 Subject: [PATCH 061/163] python3Packages.pyjwt: disable failing test for 1.7.1 --- pkgs/development/python-modules/pyjwt/default.nix | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/pkgs/development/python-modules/pyjwt/default.nix b/pkgs/development/python-modules/pyjwt/default.nix index 4617869988f..104dadbd396 100644 --- a/pkgs/development/python-modules/pyjwt/default.nix +++ b/pkgs/development/python-modules/pyjwt/default.nix @@ -29,6 +29,11 @@ buildPythonPackage rec { pytestCheckHook ]; + disabledTests = lib.optionals (lib.versionOlder version "2.0") [ + # ecdsa changed internal behavior, required if one does 1.7.1 overriding + "ec_verify_should_return_false_if_signature_invalid" + ]; + pythonImportsCheck = [ "jwt" ]; meta = with lib; { From 58497175be8c3046186127064ec14fc62191282d Mon Sep 17 00:00:00 2001 From: Izorkin Date: Mon, 10 May 2021 09:57:52 +0300 Subject: [PATCH 062/163] nixos/netdata: cgroup-network: don't use AmbientCapabilities --- nixos/modules/services/monitoring/netdata.nix | 15 ++++++++++++--- pkgs/tools/system/netdata/default.nix | 2 ++ 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/nixos/modules/services/monitoring/netdata.nix b/nixos/modules/services/monitoring/netdata.nix index c2ee1c0df7f..ae3bfcbbb97 100644 --- a/nixos/modules/services/monitoring/netdata.nix +++ b/nixos/modules/services/monitoring/netdata.nix @@ -8,6 +8,7 @@ let wrappedPlugins = pkgs.runCommand "wrapped-plugins" { preferLocalBuild = true; } '' mkdir -p $out/libexec/netdata/plugins.d ln -s /run/wrappers/bin/apps.plugin $out/libexec/netdata/plugins.d/apps.plugin + ln -s /run/wrappers/bin/cgroup-network $out/libexec/netdata/plugins.d/cgroup-network ln -s /run/wrappers/bin/freeipmi.plugin $out/libexec/netdata/plugins.d/freeipmi.plugin ln -s /run/wrappers/bin/perf.plugin $out/libexec/netdata/plugins.d/perf.plugin ln -s /run/wrappers/bin/slabinfo.plugin $out/libexec/netdata/plugins.d/slabinfo.plugin @@ -26,6 +27,9 @@ let "web files owner" = "root"; "web files group" = "root"; }; + "plugin:cgroups" = { + "script to get cgroup network interfaces" = "${wrappedPlugins}/libexec/netdata/plugins.d/cgroup-network"; + }; }; mkConfig = generators.toINI {} (recursiveUpdate localConfig cfg.config); configFile = pkgs.writeText "netdata.conf" (if cfg.configText != null then cfg.configText else mkConfig); @@ -183,9 +187,6 @@ in { ConfigurationDirectory = "netdata"; ConfigurationDirectoryMode = "0755"; # Capabilities - AmbientCapabilities = [ - "CAP_SETUID" # is required for cgroups and cgroups-network plugins - ]; CapabilityBoundingSet = [ "CAP_DAC_OVERRIDE" # is required for freeipmi and slabinfo plugins "CAP_DAC_READ_SEARCH" # is required for apps plugin @@ -217,6 +218,14 @@ in { permissions = "u+rx,g+rx,o-rwx"; }; + security.wrappers."cgroup-network" = { + source = "${cfg.package}/libexec/netdata/plugins.d/cgroup-network.org"; + capabilities = "cap_setuid+ep"; + owner = cfg.user; + group = cfg.group; + permissions = "u+rx,g+rx,o-rwx"; + }; + security.wrappers."freeipmi.plugin" = { source = "${cfg.package}/libexec/netdata/plugins.d/freeipmi.plugin.org"; capabilities = "cap_dac_override,cap_fowner+ep"; diff --git a/pkgs/tools/system/netdata/default.nix b/pkgs/tools/system/netdata/default.nix index 5eb39c7f6d8..4dc0d80b3b5 100644 --- a/pkgs/tools/system/netdata/default.nix +++ b/pkgs/tools/system/netdata/default.nix @@ -56,6 +56,8 @@ in stdenv.mkDerivation rec { # rename this plugin so netdata will look for setuid wrapper mv $out/libexec/netdata/plugins.d/apps.plugin \ $out/libexec/netdata/plugins.d/apps.plugin.org + mv $out/libexec/netdata/plugins.d/cgroup-network \ + $out/libexec/netdata/plugins.d/cgroup-network.org mv $out/libexec/netdata/plugins.d/perf.plugin \ $out/libexec/netdata/plugins.d/perf.plugin.org mv $out/libexec/netdata/plugins.d/slabinfo.plugin \ From 859633ee4351835c0180427d34d188b489c3ca65 Mon Sep 17 00:00:00 2001 From: Izorkin Date: Mon, 10 May 2021 10:24:31 +0300 Subject: [PATCH 063/163] nixos/netdata: use cgroup v2 --- nixos/modules/services/monitoring/netdata.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/nixos/modules/services/monitoring/netdata.nix b/nixos/modules/services/monitoring/netdata.nix index ae3bfcbbb97..2028e3875f9 100644 --- a/nixos/modules/services/monitoring/netdata.nix +++ b/nixos/modules/services/monitoring/netdata.nix @@ -29,6 +29,7 @@ let }; "plugin:cgroups" = { "script to get cgroup network interfaces" = "${wrappedPlugins}/libexec/netdata/plugins.d/cgroup-network"; + "use unified cgroups" = "yes"; }; }; mkConfig = generators.toINI {} (recursiveUpdate localConfig cfg.config); From 85914bc01d7ba185158c0a8f3694ee81ceaf2a1b Mon Sep 17 00:00:00 2001 From: Izorkin Date: Mon, 10 May 2021 10:35:29 +0300 Subject: [PATCH 064/163] nixos/netdata: change wrappers permissions --- nixos/modules/services/monitoring/netdata.nix | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/nixos/modules/services/monitoring/netdata.nix b/nixos/modules/services/monitoring/netdata.nix index 2028e3875f9..561ce3eec62 100644 --- a/nixos/modules/services/monitoring/netdata.nix +++ b/nixos/modules/services/monitoring/netdata.nix @@ -216,7 +216,7 @@ in { capabilities = "cap_dac_read_search,cap_sys_ptrace+ep"; owner = cfg.user; group = cfg.group; - permissions = "u+rx,g+rx,o-rwx"; + permissions = "u+rx,g+x,o-rwx"; }; security.wrappers."cgroup-network" = { @@ -224,7 +224,7 @@ in { capabilities = "cap_setuid+ep"; owner = cfg.user; group = cfg.group; - permissions = "u+rx,g+rx,o-rwx"; + permissions = "u+rx,g+x,o-rwx"; }; security.wrappers."freeipmi.plugin" = { @@ -232,7 +232,7 @@ in { capabilities = "cap_dac_override,cap_fowner+ep"; owner = cfg.user; group = cfg.group; - permissions = "u+rx,g+rx,o-rwx"; + permissions = "u+rx,g+x,o-rwx"; }; security.wrappers."perf.plugin" = { @@ -240,7 +240,7 @@ in { capabilities = "cap_sys_admin+ep"; owner = cfg.user; group = cfg.group; - permissions = "u+rx,g+rx,o-rx"; + permissions = "u+rx,g+x,o-rwx"; }; security.wrappers."slabinfo.plugin" = { @@ -248,7 +248,7 @@ in { capabilities = "cap_dac_override+ep"; owner = cfg.user; group = cfg.group; - permissions = "u+rx,g+rx,o-rx"; + permissions = "u+rx,g+x,o-rwx"; }; security.pam.loginLimits = [ From cca0bdf46a7801fe294be11412970e058403d9c2 Mon Sep 17 00:00:00 2001 From: FliegendeWurst <2012gdwu+github@posteo.de> Date: Mon, 10 May 2021 10:06:42 +0200 Subject: [PATCH 065/163] gir-rs: 2019-10-16 -> 2021-05-05 --- pkgs/development/tools/gir/default.nix | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/pkgs/development/tools/gir/default.nix b/pkgs/development/tools/gir/default.nix index c88ffef4df1..856cd44e26c 100644 --- a/pkgs/development/tools/gir/default.nix +++ b/pkgs/development/tools/gir/default.nix @@ -2,16 +2,17 @@ rustPlatform.buildRustPackage rec { pname = "gir"; - version = "2019-10-16"; + version = "unstable-2021-05-05"; src = fetchFromGitHub { owner = "gtk-rs"; repo = "gir"; - rev = "241d790085a712db7436c5c25b210ccb7d1a08d5"; - sha256 = "1kn5kgdma9j6dwpmv6jmydak7ajlgdkw9sfkh3q7h8c2a8yikvxr"; + rev = "c148542ce89b0bf7cbb9f5ef4179c96a45d022df"; + sha256 = "0vy366ipwnn0cpp14l1v5g3dpnsr3hd8mjp3333lp0946igfqsy5"; + leaveDotGit = true; # required for build.rs }; - cargoSha256 = "048qhlc4f5khxi7dnakgqkhgww44r6h3mlx2fm7y2wqivr3rj8p1"; + cargoSha256 = "11as1v88zf0f7l2ngllg5zqycvd05nb4vrsyl1dlarjvbq7fhvv8"; meta = with lib; { description = "Tool to generate rust bindings and user API for glib-based libraries"; From 18a8eb9e41a65d52804c932aa572a81352a7cc07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20Sch=C3=BCtz?= Date: Mon, 10 May 2021 10:46:46 +0200 Subject: [PATCH 066/163] kdeltachat: enable WebP support See https://git.sr.ht/~link2xt/kdeltachat/commit/d0a05f9ca3e1db51aed0285cbf4fcc5d64d05833. --- .../networking/instant-messengers/kdeltachat/default.nix | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkgs/applications/networking/instant-messengers/kdeltachat/default.nix b/pkgs/applications/networking/instant-messengers/kdeltachat/default.nix index 84b6f7ecb37..ae567daec36 100644 --- a/pkgs/applications/networking/instant-messengers/kdeltachat/default.nix +++ b/pkgs/applications/networking/instant-messengers/kdeltachat/default.nix @@ -6,6 +6,7 @@ , pkg-config , kirigami2 , libdeltachat +, qtimageformats , qtmultimedia }: @@ -29,6 +30,7 @@ mkDerivation rec { buildInputs = [ kirigami2 libdeltachat + qtimageformats qtmultimedia ]; From b7148f87b571e12fb4ed920e6cb92df6604ec6b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Robert=20Sch=C3=BCtz?= Date: Mon, 10 May 2021 11:01:58 +0200 Subject: [PATCH 067/163] pythonPackages.isbnlib: 3.10.7 -> 3.10.8 https://github.com/xlcnd/isbnlib/releases/tag/v3.10.8 --- pkgs/development/python-modules/isbnlib/default.nix | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/pkgs/development/python-modules/isbnlib/default.nix b/pkgs/development/python-modules/isbnlib/default.nix index db05436d04e..746cd3ab8ad 100644 --- a/pkgs/development/python-modules/isbnlib/default.nix +++ b/pkgs/development/python-modules/isbnlib/default.nix @@ -7,11 +7,11 @@ buildPythonPackage rec { pname = "isbnlib"; - version = "3.10.7"; + version = "3.10.8"; src = fetchPypi { inherit pname version; - sha256 = "sha256-gbMxV9qOLCpIH3rUceG1ds9ZUpjwOv1gyYL3GLkS3Ik="; + sha256 = "sha256-6kBu8uFDiKs5ZJXw9gTS08lstaJWuWvAVW3Ycc19x7Q="; }; checkInputs = [ @@ -22,7 +22,13 @@ buildPythonPackage rec { # requires network connection doCheck = false; - pythonImportsCheck = [ "isbnlib" ]; + pythonImportsCheck = [ + "isbnlib" + "isbnlib.config" + "isbnlib.dev" + "isbnlib.dev.helpers" + "isbnlib.registry" + ]; meta = with lib; { description = "Extract, clean, transform, hyphenate and metadata for ISBNs"; From edec49cbb3fc37b8f1ece44d0ec7d8a30b9d9a42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Eduardo=20S=C3=A1nchez=20Mu=C3=B1oz?= Date: Mon, 10 May 2021 11:32:38 +0200 Subject: [PATCH 068/163] calibre: 5.16.1 -> 5.17.0 --- pkgs/applications/misc/calibre/default.nix | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/misc/calibre/default.nix b/pkgs/applications/misc/calibre/default.nix index de90e9d670c..aff203cce61 100644 --- a/pkgs/applications/misc/calibre/default.nix +++ b/pkgs/applications/misc/calibre/default.nix @@ -25,11 +25,11 @@ mkDerivation rec { pname = "calibre"; - version = "5.16.1"; + version = "5.17.0"; src = fetchurl { url = "https://download.calibre-ebook.com/${version}/${pname}-${version}.tar.xz"; - hash = "sha256-lTXCW0MGNOezecaGO9c2JGU4ylwpPmBaMXTY3nLNcrE="; + hash = "sha256-rdiBL3Y3q/0wFfWGE4jGkWakgV8hA9HjDcKXso6tVrs="; }; patches = [ @@ -114,7 +114,6 @@ mkDerivation rec { export FC_LIB_DIR=${fontconfig.lib}/lib export PODOFO_INC_DIR=${podofo.dev}/include/podofo export PODOFO_LIB_DIR=${podofo.lib}/lib - export SIP_BIN=${python3Packages.sip}/bin/sip export XDG_DATA_HOME=$out/share export XDG_UTILS_INSTALL_MODE="user" From c7703958948f46d5568672a4e67187f9da3fc526 Mon Sep 17 00:00:00 2001 From: Konstantin Alekseev Date: Mon, 10 May 2021 12:37:42 +0300 Subject: [PATCH 069/163] overmind: 2.2.0 -> 2.2.2 --- pkgs/applications/misc/overmind/default.nix | 11 +- pkgs/applications/misc/overmind/deps.nix | 129 -------------------- 2 files changed, 5 insertions(+), 135 deletions(-) delete mode 100644 pkgs/applications/misc/overmind/deps.nix diff --git a/pkgs/applications/misc/overmind/default.nix b/pkgs/applications/misc/overmind/default.nix index 537ae3741ef..80a423a3c83 100644 --- a/pkgs/applications/misc/overmind/default.nix +++ b/pkgs/applications/misc/overmind/default.nix @@ -1,9 +1,8 @@ -{ lib, buildGoPackage, fetchFromGitHub, tmux, which, makeWrapper }: +{ lib, buildGoModule, fetchFromGitHub, tmux, which, makeWrapper }: -buildGoPackage rec { +buildGoModule rec { pname = "overmind"; - version = "2.2.0"; - goPackagePath = "github.com/DarthSim/overmind"; + version = "2.2.2"; nativeBuildInputs = [ makeWrapper ]; @@ -15,10 +14,10 @@ buildGoPackage rec { owner = "DarthSim"; repo = pname; rev = "v${version}"; - sha256 = "00v6l4138vv32bqfkzrhk4hfl52a00rlg9ywhp4difgrnz7zj6xb"; + sha256 = "zDjIwnhDoUj+zTAhtBa94dx7QhYMCTxv2DNUpeP8CP0="; }; - goDeps = ./deps.nix; + vendorSha256 = "KDMzR6qAruscgS6/bHTN6RnHOlLKCm9lxkr9k3oLY+Y="; meta = with lib; { homepage = "https://github.com/DarthSim/overmind"; diff --git a/pkgs/applications/misc/overmind/deps.nix b/pkgs/applications/misc/overmind/deps.nix deleted file mode 100644 index b4c9211a24a..00000000000 --- a/pkgs/applications/misc/overmind/deps.nix +++ /dev/null @@ -1,129 +0,0 @@ -# file generated from go.mod using vgo2nix (https://github.com/adisbladis/vgo2nix) -[ - { - goPackagePath = "github.com/BurntSushi/toml"; - fetch = { - type = "git"; - url = "https://github.com/BurntSushi/toml"; - rev = "v0.3.1"; - sha256 = "1fjdwwfzyzllgiwydknf1pwjvy49qxfsczqx5gz3y0izs7as99j6"; - }; - } - { - goPackagePath = "github.com/DarthSim/godotenv"; - fetch = { - type = "git"; - url = "https://github.com/DarthSim/godotenv"; - rev = "v1.3.1"; - sha256 = "0fb9nl5qrnv7f9w0pgg00ak34afw9kjgcql0l38z22faz2bhgl1q"; - }; - } - { - goPackagePath = "github.com/cpuguy83/go-md2man"; - fetch = { - type = "git"; - url = "https://github.com/cpuguy83/go-md2man"; - rev = "f79a8a8ca69d"; - sha256 = "0r1f7v475dxxgzqci1mxfliwadcrk86ippflx9n411325l4g3ghv"; - }; - } - { - goPackagePath = "github.com/kardianos/osext"; - fetch = { - type = "git"; - url = "https://github.com/kardianos/osext"; - rev = "2bc1f35cddc0"; - sha256 = "1pvrbrvmrf4mx0fxbfaphbzgqgwn8v6lkfk2vyrs0znxrs1xyc5r"; - }; - } - { - goPackagePath = "github.com/matoous/go-nanoid"; - fetch = { - type = "git"; - url = "https://github.com/matoous/go-nanoid"; - rev = "eab626deece6"; - sha256 = "1a82lclk56y7c44jg7wn5vq733dmn0g20r5yqbchrxnpfl75dw89"; - }; - } - { - goPackagePath = "github.com/pmezard/go-difflib"; - fetch = { - type = "git"; - url = "https://github.com/pmezard/go-difflib"; - rev = "v1.0.0"; - sha256 = "0c1cn55m4rypmscgf0rrb88pn58j3ysvc2d0432dp3c6fqg6cnzw"; - }; - } - { - goPackagePath = "github.com/russross/blackfriday"; - fetch = { - type = "git"; - url = "https://github.com/russross/blackfriday"; - rev = "v2.0.1"; - sha256 = "0nlz7isdd4rgnwzs68499hlwicxz34j2k2a0b8jy0y7ycd2bcr5j"; - }; - } - { - goPackagePath = "github.com/sevlyar/go-daemon"; - fetch = { - type = "git"; - url = "https://github.com/sevlyar/go-daemon"; - rev = "v0.1.5"; - sha256 = "1y3gnxaifykcjcbzx91lz9bc93b95w3xj4rjxjbii26pm3j7gqyk"; - }; - } - { - goPackagePath = "github.com/shurcooL/sanitized_anchor_name"; - fetch = { - type = "git"; - url = "https://github.com/shurcooL/sanitized_anchor_name"; - rev = "v1.0.0"; - sha256 = "1gv9p2nr46z80dnfjsklc6zxbgk96349sdsxjz05f3z6wb6m5l8f"; - }; - } - { - goPackagePath = "github.com/urfave/cli"; - fetch = { - type = "git"; - url = "https://github.com/urfave/cli"; - rev = "v1.22.2"; - sha256 = "10mcnvi5qmn00vpyk6si8gjka7p654wr9hac4zc9w5h3ickhvbdc"; - }; - } - { - goPackagePath = "golang.org/x/crypto"; - fetch = { - type = "git"; - url = "https://go.googlesource.com/crypto"; - rev = "88737f569e3a"; - sha256 = "02vkqfd6kc28zm6lffagw8nr78sayv6jabfgk9dcifl7826vi3k7"; - }; - } - { - goPackagePath = "golang.org/x/sys"; - fetch = { - type = "git"; - url = "https://go.googlesource.com/sys"; - rev = "81d4e9dc473e"; - sha256 = "0074zjpkhclz5qbgjv0zmdwy6hmf5k2ri5yagnm6i12ahxaa48dr"; - }; - } - { - goPackagePath = "gopkg.in/check.v1"; - fetch = { - type = "git"; - url = "https://gopkg.in/check.v1"; - rev = "20d25e280405"; - sha256 = "0k1m83ji9l1a7ng8a7v40psbymxasmssbrrhpdv2wl4rhs0nc3np"; - }; - } - { - goPackagePath = "gopkg.in/yaml.v2"; - fetch = { - type = "git"; - url = "https://gopkg.in/yaml.v2"; - rev = "v2.2.2"; - sha256 = "01wj12jzsdqlnidpyjssmj0r4yavlqy7dwrg7adqd8dicjc4ncsa"; - }; - } -] From b6980c13491276822be1cef06357603c2cc20f9b Mon Sep 17 00:00:00 2001 From: Konstantin Alekseev Date: Mon, 10 May 2021 12:20:00 +0300 Subject: [PATCH 070/163] chamber: 2.9.0 -> 2.10.0 --- pkgs/tools/admin/chamber/default.nix | 21 ++++++--------------- 1 file changed, 6 insertions(+), 15 deletions(-) diff --git a/pkgs/tools/admin/chamber/default.nix b/pkgs/tools/admin/chamber/default.nix index c2126181f36..8396540cd27 100644 --- a/pkgs/tools/admin/chamber/default.nix +++ b/pkgs/tools/admin/chamber/default.nix @@ -1,30 +1,21 @@ -{ buildGoModule, lib, fetchFromGitHub, fetchpatch }: +{ buildGoModule, lib, fetchFromGitHub }: buildGoModule rec { pname = "chamber"; - version = "2.9.0"; + version = "2.10.0"; src = fetchFromGitHub { owner = "segmentio"; repo = pname; rev = "v${version}"; - sha256 = "eOMY9P/fCYvnl6KGNb6wohykLA0Sj9Ti0L18gx5dqUk="; + sha256 = "4G/QGoztpcLIspHxD5G+obG5h05SZek4keOJ5qS3/zg="; }; - patches = [ - (fetchpatch { - url = "https://github.com/segmentio/chamber/commit/3aeb416cdf4c232552b653262e37047fc13b1f02.patch"; - sha256 = "cyxNF9ZP4oG+1sfX9yWZCyntpAvwYUh5BzTirZQGejc="; - }) - ]; + CGO_ENABLED = 0; - vendorSha256 = null; + vendorSha256 = "XpLLolxWu9aMp1cyG4dUQk4YtknbIRMmBUdSeyY4PNk="; - # set the version. see: chamber's Makefile - buildFlagsArray = '' - -ldflags= - -X main.Version=v${version} - ''; + buildFlagsArray = [ "-ldflags=-s -w -X main.Version=v${version}" ]; meta = with lib; { description = From fcc68ce3a739e283db31fb615229ddf76fb0bae9 Mon Sep 17 00:00:00 2001 From: Felix Buehler Date: Mon, 10 May 2021 12:20:27 +0200 Subject: [PATCH 071/163] mediaelch: 2.8.10 -> 2.8.12 --- pkgs/applications/misc/mediaelch/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/misc/mediaelch/default.nix b/pkgs/applications/misc/mediaelch/default.nix index b0ceff85f81..f39b88f27d7 100644 --- a/pkgs/applications/misc/mediaelch/default.nix +++ b/pkgs/applications/misc/mediaelch/default.nix @@ -15,13 +15,13 @@ mkDerivation rec { pname = "mediaelch"; - version = "2.8.10"; + version = "2.8.12"; src = fetchFromGitHub { owner = "Komet"; repo = "MediaElch"; rev = "v${version}"; - sha256 = "1ay36q1151lvlkzmbibwv84ic90ih2hzgwx34dndxxs034vbxjv8"; + sha256 = "1gx4m9cf81d0b2nk2rlqm4misz67f5bpkjqx7d1l76rw2pwc6azf"; fetchSubmodules = true; }; From 9d31594235f370046eede6245b6e1d1dec7f2050 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Sun, 9 May 2021 13:27:12 +0200 Subject: [PATCH 072/163] hackage2nix: Mark failing builds broken This commit has been generated by maintainers/scripts/haskell/mark-broken.sh --- .../configuration-hackage2nix/broken.yaml | 5226 ++++++ .../transitive-broken.yaml | 3278 +++- .../haskell-modules/hackage-packages.nix | 13641 ++++++++++++++++ 3 files changed, 22143 insertions(+), 2 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 21593ab7ece..62b381f7bc4 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -1,2 +1,5228 @@ broken-packages: # These packages don't compile. + - 3dmodels + - AAI + - abcnotation + - abides + - abnf + - AbortT-transformers + - abstract-par-accelerate + - abt + - AC-BuildPlatform + - acc + - accelerate-fftw + - accelerate-llvm-native + - accelerate-random + - accelerate-utility + - accentuateus + - access-time + - AC-EasyRaster-GTK + - AC-HalfInteger + - achille + - acid-state-dist + - acid-state-tls + - ac-machine + - ACME + - acme-all-monad + - acme-comonad + - acme-dont + - acme-flipping-tables + - acme-hq9plus + - acme-http + - acme-inator + - acme-kitchen-sink + - acme-left-pad + - acme-miscorder + - acme-mutable-package + - acme-now + - acme-numbersystem + - acme-operators + - acme-schoenfinkel + - acme-strfry + - acme-stringly-typed + - acme-this + - acme-zero + - AC-MiniTest + - AC-Terminal + - ActionKid + - activehs-base + - activitypub + - activitystreams-aeson + - acts + - AC-VanillaArray + - AC-Vector + - Adaptive + - Adaptive-Blaisorblade + - adaptive-containers + - adaptive-tuple + - adb + - adjunction + - adobe-swatch-exchange + - ADPfusion + - adp-multi + - adtrees + - aern2-mp + - AERN-Basics + - aeson-applicative + - aeson-decode + - aeson-diff-generic + - aeson-filthy + - aeson-flowtyped + - aeson-match-qq + - aeson-options + - aeson-prefix + - aeson-schema + - aeson-schemas + - aeson-smart + - aeson-streams + - aeson-t + - aeson-tiled + - aeson-typescript + - aeson-utils + - aeson-via + - affection + - affine-invariant-ensemble-mcmc + - Agata + - agda-language-server + - agda-snippets + - AGI + - ag-pictgen + - AhoCorasick + - aig + - airbrake + - airtable-api + - air-th + - ajhc + - AlanDeniseEricLauren + - alerta + - alex-prelude + - alfred + - alga + - algebra-dag + - algebraic + - algebraic-prelude + - AlgorithmW + - algo-s + - align-text + - ally-invest + - alphachar + - alsa + - alsa-midi + - altcomposition + - alternative-extra + - alternative-io + - alto + - alure + - amazon-emailer + - amazon-products + - amby + - AMI + - amqp-conduit + - analyze + - anansi-pandoc + - android + - android-activity + - android-lint-summary + - angel + - angle + - Animas + - animascii + - animate + - annotated-fix + - anonymous-sums + - ansigraph + - antfarm + - antigate + - antimirov + - antiope-optparse-applicative + - antiquoter + - antisplice + - antlr-haskell + - anydbm + - aop-prelude + - aosd + - aos-signature + - apart + - apecs-stm + - api-builder + - api-rpc-factom + - apns-http2 + - appc + - app-lens + - AppleScript + - applicative-fail + - applicative-parsec + - applicative-quoters + - applicative-splice + - apply-unordered + - approveapi + - approx + - ApproxFun-hs + - arbb-vm + - arb-fft + - arbor-monad-counter + - arbor-monad-logger + - arbor-monad-metric + - arbor-postgres + - archiver + - archlinux + - archnews + - arch-web + - arena + - argon2 + - argparser + - arguedit + - arion + - armada + - arpa + - arpack + - arrayfire + - array-primops + - ArrayRef + - arrowapply-utils + - arrow-improve + - arrow-list + - arrowp + - arrowp-qq + - ArrowVHDL + - artery + - artifact + - asap + - ascii85-conduit + - ascii-flatten + - ascii-string + - ascii-vector-avc + - asil + - asn + - asn1-codec + - asn1-data + - assert + - assert4hs + - assert4hs-core + - assertions + - asset-map + - assumpta + - ast-monad + - astrds + - async-combinators + - async-dejafu + - asynchronous-exceptions + - async-manager + - async-timer + - aterm-utils + - atndapi + - atomic-modify + - atomic-primops-vector + - atom-msp430 + - atomo + - atp-haskell + - ats-setup + - ats-storable + - attempt + - attic-schedule + - AttoBencode + - atto-lisp + - attomail + - attoparsec-text + - attoparsec-trans + - attosplit + - Attrac + - augeas + - augur + - aur + - aur-api + - Aurochs + - authenticate-ldap + - authinfo-hs + - autom + - automata + - autonix-deps + - autopack + - avatar-generator + - avl-static + - avr-shake + - awesome-prelude + - awesomium-raw + - aws-cloudfront-signer + - aws-easy + - aws-ec2 + - aws-ec2-knownhosts + - aws-general + - aws-larpi + - aws-performance-tests + - aws-route53 + - aws-sdk-text-converter + - aws-simple + - axel + - azubi + - azure-acs + - azure-email + - azurify + - b9 + - backstop + - backtracking-exceptions + - backward-state + - bag + - Baggins + - bake + - Bang + - ban-instance + - bank-holiday-usa + - banwords + - barchart + - barcodes-code128 + - barecheck + - barrie + - barrier + - barrier-monad + - base16 + - base64-conduit + - base-compat-migrate + - base-encoding + - base-feature-macros + - base-generics + - base-io-access + - basex-client + - basic + - basic-sop + - baskell + - battlenet + - battleship-combinatorics + - bazel-coverage-report-renderer + - BCMtools + - bdd + - bdo + - beam + - beamable + - beam-core + - bech32 + - bed-and-breakfast + - beeminder-api + - Befunge93 + - BenchmarkHistory + - bench-show + - bencodex + - berkeleydb + - BerkeleyDBXML + - bert + - besout + - bet + - betacode + - betris + - bgmax + - bgzf + - bhoogle + - bibdb + - bidi-icu + - bidirectional + - bidirectionalization-combined + - bidispec + - bidispec-extras + - BiGUL + - billeksah-services + - binary-bits + - binary-communicator + - binary-derive + - binary-ext + - binary-indexed-tree + - binary-protocol + - binary-typed + - BinderAnn + - binding-gtk + - bindings-apr + - bindings-bfd + - bindings-cctools + - bindings-dc1394 + - bindings-eskit + - bindings-EsounD + - bindings-fann + - bindings-fluidsynth + - bindings-friso + - bindings-gsl + - bindings-hamlib + - bindings-hdf5 + - bindings-K8055 + - bindings-libftdi + - bindings-libg15 + - bindings-libpci + - bindings-librrd + - bindings-libstemmer + - bindings-libusb + - bindings-libv4l2 + - bindings-monetdb-mapi + - bindings-mpdecimal + - bindings-sc3 + - bindings-sipc + - bindings-wlc + - bind-marshal + - bindynamic + - binembed + - bio + - BiobaseNewick + - biocore + - biohazard + - bio-sequence + - birds-of-paradise + - bisect-binary + - bishbosh + - bitcoin-hs + - bitcoin-script + - bits-atomic + - bits-conduit + - bitset + - bits-extras + - bitspeak + - bit-stream + - BitStringRandomMonad + - bitx-bitcoin + - bizzlelude-js + - bkr + - blakesum + - blas + - blaze-html-contrib + - blaze-html-hexpat + - blaze-html-truncate + - blaze-json + - blazeT + - blaze-textual-native + - bliplib + - blockchain + - blockhash + - Blogdown + - bloodhound + - bloomfilter-redis + - blosum + - blubber-server + - Blueprint + - bluetileutils + - blunk-hask-tests + - bogocopy + - boilerplate + - bolt + - boltzmann-brain + - bond + - bookkeeper + - boolean-normal-forms + - boolexpr + - boombox + - boots-app + - boring-window-switcher + - bot + - botpp + - bottom + - bounded-array + - bound-extras + - braid + - brain-bleep + - Bravo + - brians-brain + - brick-dropdownmenu + - bricks-internal + - brillig + - broccoli + - brok + - broker-haskell + - bronyradiogermany-common + - brotli + - browscap + - bsd-sysctl + - bson + - bsparse + - btree-concurrent + - buffer + - buffer-builder-aeson + - BufferedSocket + - buffet + - buffon + - bugsnag-haskell + - bugzilla + - build + - buildable + - buildbox + - builder + - bullet + - bumper + - bunz + - burst-detection + - buster + - Buster + - butter + - bv-sized + - bytable + - bytearray-parsing + - bytestring-arbitrary + - bytestring-builder-varword + - bytestring-class + - bytestring-csv + - bytestringparser + - bytestringparser-temporary + - bytestring-plain + - bytestringreadp + - bytestring-rematch + - bytestring-show + - bytestring-substring + - bytestring-time + - bytestring-trie + - bytestring-typenats + - c0parser + - c10k + - c2ats + - cabal2doap + - cabal2ebuild + - cabal2ghci + - cabal-audit + - cabal-bundle-clib + - cabal-constraints + - cabal-db + - cabal-dependency-licenses + - cabal-dev + - cabal-dir + - cabal-edit + - cabal-file-th + - cabal-ghc-dynflags + - cabal-ghci + - cabalgraph + - cabal-graphdeps + - Cabal-ide-backend + - cabal-info + - cabal-install-bundle + - cabal-install-ghc72 + - cabal-install-ghc74 + - cabalish + - cabal-lenses + - cabal-meta + - cabal-mon + - cabal-nirvana + - cabal-progdeps + - cabalQuery + - CabalSearch + - cabal-setup + - cabal-sort + - cabal-src + - cabal-test-quickcheck + - cabal-upload + - cabalvchk + - cabin + - cabocha + - cached + - cache-polysemy + - caching + - cacophony + - cafeteria-prelude + - caffegraph + - cairo-core + - cake3 + - cal3d + - calamity + - caledon + - calenderweek + - call-alloy + - cal-layout + - call-haskell-from-anything + - canon + - canonical-filepath + - canonical-json + - canteven-listen-http + - canteven-log + - canteven-parsedate + - cantor + - Capabilities + - capnp + - capped-list + - capri + - caramia + - carbonara + - carettah + - CarneadesDSL + - carte + - Cartesian + - casa-abbreviations-and-acronyms + - casadi-bindings-internal + - Cascade + - cascading + - caseof + - Cassava + - cassava-conduit + - cassava-records + - cassette + - castle + - catamorphism + - Catana + - catch-fd + - category-traced + - catnplus + - cautious-file + - cautious-gen + - cayene-lpp + - cayley-client + - CCA + - CC-delcont-cxe + - CC-delcont-exc + - CC-delcont-ref + - CC-delcont-ref-tf + - cci + - ccnx + - c-dsl + - cedict + - cef + - cef3-raw + - cellrenderer-cairo + - cerberus + - cereal-derive + - cereal-ieee754 + - cereal-plus + - cf + - cfenv + - cg + - cgen + - cgi-utils + - chalkboard + - character-cases + - charter + - chart-histogram + - Chart-simple + - chatty-text + - chatwork + - checked + - Checked + - checkmate + - chell-quickcheck + - Chitra + - choose + - chorale + - chp + - chp-spec + - ChristmasTree + - chronograph + - chr-parse + - chunky + - church + - church-maybe + - cielo + - cil + - cinvoke + - c-io + - cio + - cipher-blowfish + - circlehs + - circular + - citeproc-hs + - cjk + - cj-token + - clang-compilation-database + - clang-pure + - clanki + - clarifai + - CLASE + - clash-prelude + - Clash-Royale-Hack-Cheats + - ClassLaws + - classy-influxdb-simple + - classy-parallel + - classyplate + - ClassyPrelude + - cld2 + - Clean + - clean-unions + - clevercss + - clexer + - CLI + - cli-builder + - clickhouse-haskell + - clif + - clifm + - clingo + - clippard + - clipper + - clisparkline + - clit + - clogparse + - clone-all + - closure + - cloudfront-signer + - clr-inline + - cluss + - clustering + - cmark-highlight + - cmark-patterns + - cmark-sections + - cmath + - cmd-item + - cmdlib + - cmdtheline + - cmf + - cmonad + - c-mosquitto + - cmph + - CMQ + - cmt + - coalpit + - cobot-io + - cobot-tools + - code-builder + - codec-beam + - codec-libevent + - codecov-haskell + - codepad + - codeworld-api + - codex + - codo-notation + - coin + - coinbase-pro + - coincident-root-loci + - colchis + - collada-output + - collapse-util + - collections + - collections-api + - co-log-polysemy + - co-log-sys + - colonnade + - colorless + - coltrane + - com + - comark-syntax + - combinat-diagrams + - combinatorial-problems + - combinator-interactive + - combobuffer + - Command + - commander + - Commando + - commodities + - commsec + - compactable + - Compactable + - compact-list + - compact-map + - compact-mutable-vector + - compact-socket + - compact-string + - compact-string-fix + - compdata-dags + - compdata-param + - competition + - compilation + - complex-generic + - compose-trans + - composite-opaleye + - composition-tree + - comprehensions-ghc + - compressed + - compstrat + - comptrans + - computational-geometry + - computations + - ConClusion + - concrete-relaxng-parser + - concrete-typerep + - concurrent-buffer + - Concurrent-Cache + - Concurrential + - concurrent-state + - condorcet + - conductive-base + - conduit-audio-lame + - conduit-audio-samplerate + - conduit-find + - conduit-iconv + - conduit-network-stream + - conduit-resumablesink + - conduit-throttle + - conduit-tokenize-attoparsec + - conduit-vfs + - conf + - conferer-provider-json + - conferer-snap + - conferer-source-json + - confide + - ConfigFileTH + - config-parser + - Configurable + - configuration + - config-value-getopt + - confsolve + - congruence-relation + - conjure + - conkin + - conlogger + - connection-string + - Conscript + - consistent + - console-program + - const-math-ghc-plugin + - constrained-categories + - constrained-category + - constrained-dynamic + - constrained-monads + - ConstraintKinds + - constraints-emerge + - constr-eq + - constructive-algebra + - consul-haskell + - Consumer + - containers-benchmark + - containers-verified + - ContArrow + - content-store + - ContextAlgebra + - context-free-grammar + - context-stack + - contiguous-checked + - continue + - Contract + - control-iso + - control-monad-failure + - control-monad-failure-mtl + - Control-Monad-ST2 + - contstuff-monads-tf + - contstuff-transformers + - convert-annotation + - copilot-sbv + - copr + - COrdering + - core + - corebot-bliki + - CoreDump + - CoreErlang + - core-haskell + - Coroutine + - coroutine-object + - CouchDB + - couchdb-conduit + - couch-hs + - counter + - courier + - court + - coverage + - cparsing + - cpio-conduit + - cplusplus-th + - cpuperf + - cpython + - cql-io + - cqrs-core + - cr + - crack + - Craft3e + - craftwerk + - crawlchain + - crc + - crc16 + - crdt-event-fold + - creatur + - credential-store + - critbit + - criterion-compare + - criterion-plus + - criterion-to-html + - criu-rpc-types + - crjdt-haskell + - crocodile + - cruncher-types + - crunghc + - crypto-cipher-benchmarks + - crypto-classical + - cryptocompare + - cryptoconditions + - cryptoids-types + - crypto-keys-ssh + - crypto-multihash + - crypto-pubkey-openssh + - crypto-random-effect + - crypto-simple + - cryptsy-api + - cse-ghc-plugin + - CSPM-FiringRules + - CSPM-Frontend + - cspretty + - css + - css-easings + - css-selectors + - csv-nptools + - ctemplate + - ctkl + - cubical + - cuboid + - cuckoo + - curl-runnings + - currency-convert + - CurryDB + - curryer-rpc + - curry-frontend + - curves + - custom-prelude + - CV + - d3js + - dag + - DAG-Tournament + - damnpacket + - danibot + - dao + - Dao + - darcs2dot + - darcs-buildpackage + - darcs-cabalized + - darcs-graph + - darcs-monitor + - darkplaces-rcon + - darkplaces-text + - data-accessor-monads-tf + - data-aviary + - data-base + - database-id-groundhog + - database-study + - data-check + - data-combinator-gen + - data-concurrent-queue + - data-construction + - data-dispersal + - data-diverse-lens + - datadog + - data-easy + - data-embed + - data-emoticons + - data-filepath + - data-fin + - data-fin-simple + - datafix + - data-flagset + - data-ivar + - data-kiln + - data-lens + - datalog + - data-map-multikey + - data-nat + - data-object + - datapacker + - data-pprint + - data-quotientref + - data-reify-cse + - data-repr + - data-rev + - data-rope + - Data-Rope + - data-r-tree + - data-size + - data-spacepart + - data-standards + - data-store + - data-stringmap + - data-sword + - DataTreeView + - data-type + - data-util + - data-validation + - data-variant + - DataVersion + - dates + - datetime + - datetime-sb + - dawdle + - dawg + - dbcleaner + - dbf + - DBFunctor + - DBlimited + - dbm + - dbmigrations-mysql + - dbmigrations-postgresql + - dbmigrations-sqlite + - d-bus + - DBus + - dbus-core + - dbus-qq + - dclabel + - dclabel-eci11 + - dcpu16 + - ddc-base + - ddc-code + - dead-code-detection + - Deadpan-DDP + - dead-simple-json + - debug-me + - debug-tracy + - decepticons + - decimal-literals + - DecisionTree + - decoder-conduit + - deepcontrol + - DeepDarkFantasy + - deepseq-bounded + - deepseq-magic + - deepseq-th + - deep-transformations + - deka + - Delta-Lambda + - delude + - demarcate + - denominate + - dense-int-set + - dependent-hashmap + - dependent-monoidal-map + - depends + - dep-t + - deptrack-core + - derangement + - derivation-trees + - derive + - derive-enumerable + - derive-gadt + - derive-monoid + - derive-trie + - derp-lib + - describe + - descript-lang + - deterministic-game-engine + - deunicode + - devil + - Dflow + - dfsbuild + - dgim + - dgs + - dhall-check + - dhall-fly + - dhall-text + - dhall-to-cabal + - dhrun + - dia-base + - diagrams-boolean + - diagrams-canvas + - diagrams-graphviz + - diagrams-gtk + - diagrams-pdf + - diagrams-qrcode + - diagrams-rasterific + - diagrams-tikz + - dib + - dice2tex + - dicom + - dictionaries + - dictparser + - diet + - diff + - diffcabal + - DifferentialEvolution + - diffmap + - difftodo + - digestive-bootstrap + - digestive-foundation-lucid + - digestive-functors-aeson + - digestive-functors-happstack + - DigitalOcean + - digitalocean-kzs + - digits + - DimensionalHash + - dimensional-tf + - diohsc + - diophantine + - direct-binary-files + - directed-cubical + - direct-fastcgi + - direct-http + - directory-contents + - direct-plugins + - direct-rocksdb + - direm + - discordian-calendar + - discord-types + - discrete + - DiscussionSupportSystem + - Dish + - disjoint-containers + - disjoint-set + - disjoint-set-stateful + - Dist + - distance + - distributed-fork-aws-lambda + - distributed-process + - distribution + - dist-upload + - djembe + - djinn-th + - dmcc + - dmenu + - dnscache + - dnsrbl + - dnssd + - dobutok + - doccheck + - docidx + - docker + - docker-build-cacher + - dockercook + - dockerfile-creator + - docopt + - docrecords + - doctest-discover-configurator + - doctest-prop + - docusign-example + - docvim + - domplate + - dotfs + - dot-linker + - doublify-toolkit + - downloader + - dozenal + - dozens + - dph-base + - dpkg + - DPM + - dpor + - dragen + - drawille + - drClickOn + - dresdner-verkehrsbetriebe + - DrIFT + - DrIFT-cabalized + - drifter-postgresql + - drmaa + - drone + - DSA + - dsc + - ds-kanren + - dsmc + - dson + - dson-parsec + - dstring + - DTC + - dtd-text + - dtw + - dualizer + - duet + - dump-core + - dunai-core + - Dung + - duplo + - dura + - Dust-crypto + - dvault + - dvdread + - dvi-processing + - dwarf + - dwarfadt + - dyckword + - dyepack + - dynamic-graphs + - dynamic-mvector + - dynamic-object + - dynamic-pp + - DynamicTimeWarp + - dynamodb-simple + - dynloader + - DysFRP + - dywapitchtrack + - dzen-dhall + - dzen-utils + - each + - earclipper + - early + - easy-api + - easy-bitcoin + - easyjson + - easyplot + - easytest + - ebeats + - ebnf-bff + - eccrypto + - ecma262 + - ecu + - eddie + - ede + - edenmodules + - edis + - edit + - edit-lenses + - editline + - effect-handlers + - effect-monad + - effect-stack + - effin + - egison-pattern-src + - ehaskell + - ehs + - eibd-client-simple + - eigen + - Eight-Ball-Pool-Hack-Cheats + - eio + - EitherT + - either-unwrap + - ejdb2-binding + - ekg-bosun + - ekg-carbon + - ekg-elastic + - ekg-elasticsearch + - ekg-log + - ekg-push + - ekg-rrd + - ekg-wai + - elevator + - elision + - elm-street + - elm-websocket + - emacs-module + - emailaddress + - email-header + - email-postmark + - embla + - emgm + - Emping + - Empty + - empty-monad + - enchant + - encoding + - encoding-io + - encryptable + - engine-io-snap + - engine-io-wai + - engine-io-yesod + - entwine + - EnumContainers + - enumerator + - enumfun + - EnumMap + - enummapmap + - enum-utf8 + - env-parser + - envstatus + - epanet-haskell + - epass + - epic + - epoll + - eprocess + - epubname + - Eq + - EqualitySolver + - equational-reasoning-induction + - equeue + - erlang + - erlang-ffi + - eros + - errata + - error-context + - error-continuations + - error-list + - error-loc + - error-util + - ersaconcat + - ersatz + - ert + - escape-artist + - escoger + - espial + - ess + - estimators + - EstProgress + - Etage + - eternal + - ethereum-rlp + - euphoria + - eurofxref + - evdev + - eve-cli + - event + - event-driven + - eventful-dynamodb + - eventful-sql-common + - eventlog2html + - eventloop + - eventstore + - ewe + - exact-cover + - exact-real-positional + - except-exceptions + - exceptional + - exceptionfree-readfile + - exchangerates + - execs + - executor + - exh + - exherbo-cabal + - exif + - exigo-schema + - exinst-deepseq + - exinst-hashable + - exists + - exitcode + - exp-extended + - explain + - explicit-constraint-lens + - explicit-determinant + - explicit-iomodes + - exposed-containers + - expression-parser + - expressions + - expresso + - extcore + - extended-categories + - extensible-effects-concurrent + - extensible-skeleton + - external-sort + - Extra + - extractelf + - extralife + - ez3 + - ez-couch + - Facebook-Password-Hacker-Online-Latest-Version + - faceted + - facts + - failable-list + - failure-detector + - fake-type + - faktory + - f-algebra-gen + - fastbayes + - fast-combinatorics + - fastedit + - fastly + - fast-nats + - fastpbkdf2 + - FastPush + - FastxPipe + - fathead-util + - fay-builder + - fay-hsx + - fay-simplejson + - fbmessenger-api + - fb-persistent + - fca + - fcache + - fcg + - fckeditor + - fclabels-monadlib + - fcm-client + - fdo-trash + - feature-flipper + - fedora-packages + - feed-cli + - feed-collect + - feed-crawl + - fenfire + - fernet + - FerryCore + - Feval + - fez-conf + - ffeed + - fficxx + - ffunctor + - fgl-extras-decompositions + - fibon + - fieldwise + - fig + - file-collection + - file-command-qq + - filediff + - file-embed-poly + - file-location + - FileManip + - FileManipCompat + - fileneglect + - Files + - FileSystem + - filesystem-abstractions + - filesystem-conduit + - filesystem-trees + - fillit + - final-pretty-printer + - Finance-Quote-Yahoo + - find-conduit + - find-source-files + - fingertree-psqueue + - fingertree-tf + - finitary-derive + - firefly-example + - first-and-last + - first-class-instances + - fit + - fitsio + - fits-parse + - fixed-point + - fixed-precision + - fixed-storable-array + - fixed-timestep + - fixed-vector-binary + - fixed-vector-cborg + - fixed-vector-cereal + - fixed-width + - fixer + - fixfile + - fixie + - fix-symbols-gitit + - fizzbuzz + - fizzbuzz-as-a-service + - flac + - flaccuraterip + - flamethrower + - flamingra + - flat-maybe + - flay + - flexible-time + - flickr + - flight-kml + - flink-statefulfun + - float-binstring + - floating-bits + - flowdock + - flowdock-rest + - flow-er + - flowlocks-framework + - flp + - fltkhs + - fluffy-parser + - fluidsynth + - flux-monoid + - fmark + - FModExRaw + - fn-extra + - foldl-incremental + - foldl-statistics + - foldl-transduce + - folds-common + - follow + - font-opengl-basic4x6 + - forbidden-fruit + - fordo + - forecast-io + - foreign-var + - forest + - forest-fire + - for-free + - forger + - ForkableT + - formatn + - formattable + - formura + - ForSyDe + - forsyde-deep + - Fortnite-Hack-Cheats-Free-V-Bucks-Generator + - fortran-src + - fortytwo + - foscam-filename + - fpco-api + - FPretty + - fptest + - Fractaler + - fractals + - fraction + - frag + - Frames-map-reduce + - Frames-streamly + - franchise + - fraxl + - freddy + - free-concurrent + - free-game + - f-ree-hack-cheats-free-v-bucks-generator + - free-http + - free-operational + - freer-effects + - freer-simple-catching + - freer-simple-http + - freer-simple-profiling + - freer-simple-random + - freer-simple-time + - freesect + - freesound + - free-theorems + - FreeTypeGL + - freetype-simple + - free-v-bucks-generator-no-survey + - free-v-bucks-generator-ps4-no-survey + - freq + - fresh + - friday-devil + - friday-scale-dct + - friendly + - frown + - frp-arduino + - frpnow + - fs-events + - fsh-csv + - fsmActions + - fst + - fsutils + - fswait + - fswatch + - ft-generator + - FTGL-bytestring + - ftp-client + - ftp-conduit + - ftphs + - full-sessions + - funbot-client + - funcons-values + - function-instances-algebra + - functor + - functor-combinators + - functor-friends + - functor-infix + - functorm + - functor-products + - functor-utils + - funflow + - Fungi + - funpat + - funspection + - fused-effects-exceptions + - fused-effects-resumable + - fusion + - futun + - future + - fuzzy-timings + - fwgl + - g4ip + - galois-field + - gameclock + - game-probability + - gamgee + - gamma + - Ganymede + - garepinoh + - gargoyle-postgresql-nix + - gas + - gather + - gc-monitoring-wai + - gconf + - gdiff-th + - gegl + - gelatin + - gemstone + - gencheck + - gender + - genders + - general-prelude + - GeneralTicTacToe + - generator + - generators + - generic-accessors + - generic-binary + - generic-church + - generic-enum + - generic-enumeration + - generic-labels + - generic-lens-labels + - generic-lucid-scaffold + - generic-maybe + - generic-optics + - generic-override-aeson + - generic-pretty + - genericserialize + - generic-server + - generics-mrsop + - generic-storable + - generic-tree + - generic-trie + - generic-xml + - generic-xmlpickler + - genetics + - gen-imports + - geniplate + - gen-passwd + - genprog + - gentlemark + - genvalidity-persistent + - GeocoderOpenCage + - geodetic-types + - geom2d + - GeomPredicates-SSE + - geo-resolver + - geos + - Get + - getflag + - GGg + - ggtsTC + - ghc-clippy-plugin + - ghc-core-smallstep + - ghc-datasize + - ghc-dump-tree + - ghc-dup + - ghc-events-analyze + - ghc-events-parallel + - ghc-generic-instances + - ghci-diagrams + - ghci-haskeline + - ghci-history-parser + - ghci-lib + - ghci-ng + - ghcjs-dom-jsffi + - ghcjs-fetch + - ghcjs-promise + - ghcjs-xhr + - ghc-justdoit + - ghclive + - ghc-man-completion + - ghc-parmake + - ghc-pkg-autofix + - ghc-pkg-lib + - ghc-plugs-out + - ghcprofview + - ghc-proofs + - ghc-session + - ghc-simple + - ghc-srcspan-plugin + - ghc-syb + - ghc-syb-utils + - ghc-tags-core + - ghc-time-alloc-prof + - ghc-usage + - gh-labeler + - giak + - Gifcurry + - gi-graphene + - gi-gsttag + - gi-gtkosxapplication + - gi-gtksheet + - gi-handy + - ginsu + - gipeda + - giphy-api + - gist + - GiST + - git + - git-all + - git-checklist + - git-config + - git-cuk + - git-date + - gitdo + - github-backup + - github-data + - github-tools + - github-utils + - github-webhook-handler + - githud + - gitignore + - git-jump + - gitlab-api + - gitlib-cmdline + - gitlib-utils + - git-repair + - git-sanity + - gitson + - gitter + - git-vogue + - gi-vips + - gi-wnck + - glade + - glapp + - Gleam + - GLFW + - GLFW-b-demo + - gli + - glider-nlp + - GLMatrix + - global-variables + - glob-posix + - GlomeTrace + - gloss-export + - gloss-game + - glpk-headers + - gltf-codec + - glue + - g-npm + - goa + - goal-core + - gochan + - godot-haskell + - gofer-prelude + - gooey + - google-cloud + - GoogleCodeJam + - google-html5-slide + - google-oauth2 + - google-oauth2-easy + - googlepolyline + - google-search + - google-translate + - gopherbot + - gopro-plus + - gore-and-ash + - GotoT-transformers + - gpah + - GPipe + - GPipe-Core + - gpx-conduit + - grab + - graceful + - grafana + - Grafos + - grakn + - grapefruit-frp + - Graph500 + - graphbuilder + - graphene + - graphics-drawingcombinators + - graphics-formats-collada + - graph-matchings + - graphmod-plugin + - graphql-api + - graphql-utils + - graphql-w-persistent + - graph-rewriting + - graph-serialize + - graphted + - graphula-core + - graph-utils + - graql + - grasp + - gray-code + - greencard + - greg-client + - gremlin-haskell + - Grempa + - grenade + - grm + - groot + - gross + - GroteTrap + - groundhog-converters + - groundhog-mysql + - grouped-list + - group-theory + - group-with + - growler + - grpc-api-etcd + - gsl-random + - gstreamer + - GTALib + - gtfs-realtime + - gtk2hs-hello + - gtk2hs-rpn + - gtk3-mac-integration + - gtkglext + - gtk-sni-tray + - gtksourceview2 + - gtksourceview3 + - gtk-toy + - gulcii + - gw + - gyah-bin + - gym-http-api + - h2048 + - h2c + - haar + - HABQT + - hack2-handler-warp + - hackage2hwn + - hackage-api + - hackage-diff + - hackage-mirror + - hackage-processing + - hackage-proxy + - hackager + - hackage-repo-tool + - hackage-whatsnew + - hackernews + - hack-frontend-happstack + - hack-handler-cgi + - hack-handler-happstack + - hack-handler-kibro + - HackMail + - hackport + - hactor + - hactors + - haddock-api + - haddock-cheatsheet + - haddock-leksah + - haddock-test + - hadoop-formats + - hadoop-rpc + - hafar + - Haggressive + - hahp + - haiji + - hailgun-send + - hairy + - hakaru + - hakismet + - hakka + - hako + - hakyll + - hakyll-shortcode + - HaLeX + - halfs + - halipeto + - halive + - halma + - halves + - hampp + - hamsql + - hamtmap + - hanabi-dealer + - handa-gdata + - handle-like + - HandlerSocketClient + - handsy + - Hangman + - hannahci + - hans + - hanspell + - haphviz + - happindicator + - happindicator3 + - happlets + - happraise + - happstack + - happstack-fay-ajax + - happstack-foundation + - happstack-hamlet + - happstack-heist + - happstack-hstringtemplate + - happstack-lite + - happstack-monad-peel + - happstack-server-tls-cryptonite + - happstack-util + - HAppS-Util + - happybara + - happybara-webkit-server + - happy-hour + - HappyTree + - hapstone + - HaPy + - haquery + - harchive + - haroonga + - harpy + - harvest-api + - has + - hasbolt-extras + - HasCacBDD + - hascard + - hascas + - Haschoo + - hash + - hashable-extras + - hashable-generics + - hashable-orphans + - hashabler + - hashed-storage + - hashring + - hashtables-plus + - hasim + - hask + - haskbot-core + - haskeline-class + - haskelisp + - haskell2010 + - haskell2020 + - haskell98 + - haskell98libraries + - HaskellAnalysisProgram + - haskell-awk + - haskell-bitmex-rest + - haskell-brainfuck + - haskell-ci + - haskell-cnc + - haskell-coffee + - haskell-compression + - haskell-conll + - haskell-course-preludes + - haskelldb + - haskelldb-wx + - haskell-disque + - haskell-formatter + - haskell-generate + - haskell-go-checkers + - haskell-holes-th + - haskell-igraph + - haskell-in-space + - haskell-kubernetes + - HaskellLM + - haskell-lsp-client + - haskell-ml + - haskell-mpfr + - haskell-mpi + - haskell-names + - haskell-neo4j-client + - HaskellNet-SSL + - HaskellNN + - Haskelloids + - haskell-openflow + - haskell-overridez + - haskell-packages + - haskell-player + - haskell-plot + - haskell-postal + - haskell-read-editor + - haskell-rules + - haskellscrabble + - haskellscript + - haskell-spacegoo + - haskell-src-exts-prisms + - haskell-src-exts-qq + - haskell-src-exts-sc + - haskell-src-match + - haskell-src-meta-mwotton + - haskell-stack-trace-plugin + - HaskellTorrent + - HaskellTutorials + - haskell-type-exts + - haskell-typescript + - haskell-tyrant + - haskelzinc + - haskeme + - haskey + - haskheap + - haskhol-core + - haskmon + - haskoin + - haskoin-util + - haskore + - hasktorch-codegen + - hasktorch-ffi-th + - hasktorch-signatures-partial + - hasktorch-signatures-support + - haskus-binary + - haskyapi + - hasmin + - hasql-backend + - hasql-class + - hasql-cursor-transaction + - hasql-dynamic-statements + - hasql-generic + - hasql-simple + - hastache + - haste + - haste-prim + - hatex-guide + - hats + - hatt + - haven + - haverer + - hax + - haxl-amazonka + - haxl-facebook + - haxparse + - haxr-th + - hayland + - hayoo-cli + - hBDD-CMUBDD + - hBDD-CUDD + - hbeanstalk + - hbeat + - hblas + - hblock + - h-booru + - hburg + - hcad + - HCard + - hcc + - hcg-minus + - hchesslib + - hcltest + - hcoap + - hcom + - hcount + - hcron + - hCsound + - hcube + - hdaemonize-buildfix + - hdbc-aeson + - HDBC-mysql + - hdbc-postgresql-hstore + - HDBC-postgresql-hstore + - hdevtools + - hDFA + - hdigest + - hdis86 + - hdiscount + - hdm + - hdo + - hdph-closure + - hdr-histogram + - HDRUtils + - headergen + - heap-console + - heapsort + - heart-core + - hebrew-time + - heckle + - hedgehog-checkers + - hedgehog-generic + - hedgehog-golden + - hedgehog-servant + - hedis-config + - hedis-namespace + - hedis-simple + - hedis-tags + - hedra + - hein + - heist-async + - helisp + - helix + - hell + - help-esb + - hemkay + - HERA + - herbalizer + - HerbiePlugin + - heredocs + - her-lexer + - Hermes + - herms + - hetero-dict + - heterogeneous-list-literals + - hetris + - heukarya + - hevm + - HExcel + - hexchat + - hexif + - hexmino + - hexml-lens + - hexpat-pickle-generic + - hexpr + - hexpress + - hexquote + - hexstring + - hext + - heyefi + - hF2 + - hfann + - HFitUI + - hfmt + - hfoil + - hfov + - hfractal + - HFrequencyQueue + - hfusion + - hg-buildpackage + - hgdbmi + - HGE2D + - hgearman + - hGelf + - hgeometric + - hgeometry-ipe + - hgettext + - hgis + - hgom + - hgopher + - h-gpgme + - HGraphStorage + - hgrep + - hgrib + - hharp + - HHDL + - hhwloc + - hi + - hi3status + - hichi + - hidden-char + - hid-examples + - hie-core + - hieraclus + - hierarchical-env + - hierarchical-exceptions + - hierarchy + - hiernotify + - higgledy + - higherorder + - highjson + - highlight-versions + - highWaterMark + - himg + - hindley-milner + - hinquire + - hinstaller + - hinter + - hinterface + - hipchat-hs + - hipe + - hipsql-api + - hircules + - Hish + - hissmetrics + - historian + - hist-pl-types + - hit-on + - HJavaScript + - hjcase + - hjs + - hjsonpointer + - hjson-query + - HJVM + - hkd-delta + - hkd-lens + - hkt + - hlbfgsb + - hledger-chart + - hledger-irr + - hledger-vty + - hlibBladeRF + - hlibev + - hlibfam + - HList + - hlivy + - hlogger + - HLogger + - hlongurl + - hls-exactprint-utils + - hlwm + - hmarkup + - hmatrix-banded + - hmatrix-mmap + - hmatrix-nipals + - hmatrix-sparse + - hmatrix-static + - hmatrix-svdlibc + - hmatrix-syntax + - hmatrix-tests + - hmenu + - hmk + - hmm + - HMM + - hmm-hmatrix + - hMollom + - hmp3 + - Hmpf + - hmumps + - hnetcdf + - hoauth + - hobbes + - hocilib + - hocker + - hodatime + - HODE + - hoe + - hog + - hogg + - hois + - hol + - hold-em + - hole + - holmes + - homeomorphic + - homoiconic + - homplexity + - honi + - hoobuddy + - hood2 + - hoodle-types + - hood-off + - hoogle-index + - hooks-dir + - hoop + - hoopl + - hopencc + - hopencl + - HOpenCV + - hopfield + - hops + - ho-rewriting + - horizon + - horname + - hosc-json + - hosts-server + - hothasktags + - hotswap + - hourglass-fuzzy-parsing + - houseman + - hp2any-core + - hpack-convert + - hpasteit + - HPath + - hpc-coveralls + - hpg + - HPi + - hpio + - hplaylist + - hpodder + - hpqtypes + - hprotoc + - hps-kmeans + - hPushover + - hpygments + - hpylos + - hpyrg + - hquantlib-time + - hR + - hreq-core + - h-reversi + - hricket + - Hricket + - hs2bf + - hs2ps + - hsaml2 + - hsay + - hsbc + - hsbencher + - hsc3 + - hsc3-rw + - hsc3-sf + - hscaffold + - hscamwire + - hs-carbon-examples + - hscd + - hs-cdb + - hsclock + - hScraper + - hscuid + - hs-di + - hsdif + - hsdip + - hsdns-cache + - hs-dotnet + - hsenv + - HSet + - hs-excelx + - hsfcsh + - HSFFIG + - hsfilt + - hs-fltk + - hsforce + - hs-gizapp + - hsgnutls + - hsgnutls-yj + - hsgsom + - HsHaruPDF + - HsHTSLib + - HsHyperEstraier + - hsI2C + - hSimpleDB + - hsimport + - hsinspect-lsp + - hs-java + - hs-json-rpc + - HsJudy + - hskeleton + - hslackbuilder + - hslibsvm + - hslinks + - hslogger-reader + - hslogger-template + - hs-logo + - hsluv-haskell + - hsmagick + - hsmodetweaks + - Hsmtlib + - hsmtpclient + - hs-nombre-generator + - hsns + - hsnsq + - hsntp + - hsoptions + - hsoz + - hsparql + - hs-pattrans + - hsp-cgi + - hspear + - hspec2 + - hspec-expectations-match + - hspec-experimental + - hspec-jenkins + - hspec-monad-control + - hspec-snap + - hspec-structured-formatter + - hspec-webdriver + - HsPerl5 + - hs-pgms + - hspkcs11 + - hs-pkg-config + - hspread + - hspresent + - hsql + - hs-re + - hsrelp + - hs-rqlite + - hs-rs-notify + - hs-scrape + - hsseccomp + - hs-snowtify + - hs-speedscope + - hsSqlite3 + - hssqlppp + - HsSVN + - hs-tags + - hstats + - hstatsd + - hstest + - hstidy + - hs-twitter + - hs-twitterarchiver + - hstyle + - hsudoku + - hs-vcard + - hs-watchman + - hsx + - hsXenCtrl + - hsyscall + - hsyslog-tcp + - hszephyr + - hTalos + - htar + - htdp-image + - hTensor + - htestu + - HTicTacToe + - htiled + - htlset + - html-charset + - html-kure + - html-rules + - html-tokenizer + - htsn + - htsn-import + - htssets + - http2-client + - http2-grpc-proto-lens + - http-attoparsec + - http-client-lens + - http-client-request-modifiers + - http-client-session + - http-client-streams + - http-client-websockets + - http-conduit-browser + - http-conduit-downloader + - http-directory + - http-dispatch + - http-grammar + - http-kinder + - http-listen + - http-monad + - http-pony + - http-pony-serve-wai + - http-proxy + - http-querystring + - http-response-decoder + - http-server + - http-shed + - http-wget + - htune + - htvm + - htzaar + - huck + - HueAPI + - huff + - huffman + - HulkImport + - human-parse + - human-text + - humble-prelude + - hums + - hunch + - HUnit-Diff + - hunit-rematch + - hunspell-hs + - hup + - hurriyet + - hutton + - huttons-razor + - hVOIDP + - hwall-auth-iitk + - hw-ci-assist + - hweblib + - hwhile + - hw-json-simd + - hworker + - hw-simd + - hwsl2 + - hx + - HXQ + - hxt-pickle-utils + - hyakko + - hydra-hs + - hydra-print + - hydrogen + - hydrogen-multimap + - hylide + - hylolib + - hyperdrive + - hyperfunctions + - hyperion + - hyperloglogplus + - hypher + - hzulip + - i18n + - I1M + - i3ipc + - iap-verifier + - iban + - ib-api + - ical + - icepeak + - IcoGrid + - iconv-typed + - ideas + - idempotent + - identifiers + - idiii + - idna2008 + - IDynamic + - ieee-utils + - iexcloud + - ifcxt + - IFS + - ig + - ige + - ignore + - igraph + - ihaskell-parsec + - ihaskell-widgets + - illuminate + - imagepaste + - imapget + - imgur + - imj-prelude + - immortal-worker + - imperative-edsl + - ImperativeHaskell + - impl + - implicit-logging + - implicit-params + - imports + - impossible + - imprint + - inchworm + - indentation-core + - index-core + - indextype + - indices + - infer-upstream + - infinity + - inf-interval + - infix + - inflist + - informative + - inilist + - ini-qq + - initialize + - inject-function + - inserts + - instana-haskell-trace-sdk + - instance-map + - instant-generics + - instinct + - intcode + - integer-pure + - integreat + - intel-aes + - intensional-datatys + - interlude-l + - internetmarke + - intero + - interpol + - interpolatedstring-qq2 + - interruptible + - interval + - IntFormats + - int-multimap + - intricacy + - introduction + - intro-prelude + - invert + - invertible-syntax + - io-capture + - io-choice + - ioctl + - IOR + - io-reactive + - iostring + - iothread + - iotransaction + - ip2location + - ip2proxy + - ipfs + - ipopt-hs + - ip-quoter + - iptables-helpers + - IPv6DB + - Irc + - irc-dcc + - irc-fun-types + - iridium + - iron-mq + - irt + - isdicom + - IsNull + - iso8601-duration + - isobmff + - isotope + - itcli + - itemfield + - iteratee + - iterIO + - it-has + - ivory + - ixdopp + - ixmonad + - ixshader + - j + - jack-bindings + - jackminimix + - JackMiniMix + - jacobi-roots + - jaeger-flamegraph + - jalla + - jarfind + - jarify + - jason + - java-bridge + - javascript-bridge + - javav + - Javav + - jbi + - jcdecaux-vls + - Jdh + - jdi + - jenga + - jenkinsPlugins2nix + - jespresso + - jinquantities + - jml-web-service + - jni + - jobqueue + - join-api + - joinlist + - jonathanscard + - jpeg + - jsaddle-hello + - jsaddle-wkwebview + - js-good-parts + - json2 + - json-alt + - json-assertions + - json-ast-quickcheck + - json-builder + - json-encoder + - jsonextfilter + - json-extra + - json-fu + - json-litobj + - jsonnet + - json-pointer-hasql + - json-pointy + - json-python + - jsonresume + - json-rpc-client + - json-schema + - jsonschema-gen + - jsonsql + - json-tools + - json-tracer + - jsontsv + - jsonxlsx + - judge + - judy + - JuicyPixels-blp + - JuicyPixels-canvas + - JunkDB + - jupyter + - JustParse + - jvm-binary + - jvm-parser + - JYU-Utils + - kademlia + - kafka-client + - kafka-client-sync + - kalman + - Kalman + - kangaroo + - karps + - katip-kafka + - katip-raven + - katip-scalyr-scribe + - katip-syslog + - katt + - katydid + - kawhi + - kdesrc-build-extra + - kd-tree + - keccak + - keera-hails-reactivevalues + - kempe + - kerry + - Ketchup + - keter + - keyed + - keyring + - khph + - kickass-torrents-dump-parser + - kickchan + - kmonad + - kmp-dfa + - koellner-phonetic + - kontra-config + - kparams + - kqueue + - kraken + - krapsh + - Kriens + - krpc + - KSP + - ktx + - ktx-codec + - kuifje + - kure-your-boilerplate + - KyotoCabinet + - labeled-graph + - lagrangian + - lambda2js + - lambdaBase + - lambdabot-utils + - lambda-bridge + - lambda-canvas + - lambdacms-core + - lambdacube-ir + - Lambdajudge + - LambdaNet + - lambdatex + - lambda-toolbox + - lambdatwit + - Lambdaya + - lame + - lame-tester + - language-asn + - language-c-comments + - language-c-inline + - language-conf + - language-csharp + - language-dart + - language-dockerfile + - language-elm + - language-gcl + - language-go + - language-guess + - language-hcl + - language-java-classfile + - language-lua2 + - language-lua-qq + - language-mixal + - language-objc + - language-ocaml + - language-openscad + - language-pig + - language-puppet + - language-rust + - language-sh + - language-sqlite + - language-sygus + - language-tl + - language-typescript + - language-vhdl + - language-webidl + - lapack-ffi + - large-hashable + - Lastik + - latest-npm-version + - latex-formulae-image + - latex-svg-image + - LATS + - launchpad-control + - lawless-concurrent-machines + - layers + - layout + - layout-bootstrap + - lazyarray + - lazyboy + - lazy-priority-queue + - lazyset + - LazyVault + - l-bfgs-b + - lda + - ldif + - ld-intervals + - leaf + - leapseconds + - learn + - Learning + - learn-physics-examples + - leb128 + - leetify + - lendingclub + - lens-filesystem + - lens-labels + - lens-prelude + - lens-process + - lensref + - lens-simple + - lens-text-encoding + - lens-th-rewrite + - lens-time + - lens-toml-parser + - lens-tutorial + - lens-typelevel + - Level0 + - level-monad + - lfst + - lhc + - lhs2TeX-hl + - lhslatex + - LibClang + - libexpect + - libfuse3 + - libGenI + - libhbb + - libinfluxdb + - libjenkins + - libjwt-typed + - libltdl + - libnix + - liboath-hs + - liboleg + - libpafe + - libpq + - librandomorg + - libssh2 + - libsystemd-daemon + - libtagc + - libxls + - libxslt + - lie + - life-sync + - lifted-protolude + - lifter + - ligature + - lilypond + - Limit + - limp-cbc + - linda + - linden + - linear-algebra-cblas + - linear-base + - linear-code + - linear-maps + - linear-opengl + - linearscan + - linear-vect + - line-drawing + - lines-of-action + - linkedhashmap + - linked-list-with-iterator + - linklater + - linode + - linode-v4 + - linux-blkid + - linux-cgroup + - linux-kmod + - linux-perf + - linx-gateway + - lio-simple + - lipsum-gen + - liquid + - liquidhaskell + - liquidhaskell-cabal + - Liquorice + - list-fusion-probe + - listlike-instances + - list-mux + - list-prompt + - list-remote-forwards + - ListT + - list-t-http-client + - list-t-text + - list-zip-def + - list-zipper + - liszt + - lit + - literals + - LiterateMarkdown + - ll-picosat + - llsd + - llvm-base + - llvm-ffi + - llvm-ffi-tools + - llvm-general-pure + - llvm-ht + - llvm-pkg-config + - llvm-pretty + - lmonad + - load-balancing + - load-font + - local-address + - located + - located-monad-logger + - loch + - log2json + - log4hs + - logentries + - logger + - logging-effect-extra-file + - logging-effect-extra-handler + - Logic + - logicst + - logict-state + - logplex-parse + - log-warper + - lojbanParser + - lojbanXiragan + - lol + - lol-calculus + - longboi + - lookup-tables + - loopbreaker + - looper + - loops + - loop-while + - loopy + - lord + - lorem + - loris + - loshadka + - lowgl + - lp-diagrams-svg + - LRU + - lscabal + - L-seed + - lsfrom + - ltext + - ltk + - LTS + - lua-bc + - luautils + - luis-client + - luka + - luminance + - lushtags + - luthor + - lvmlib + - lxc + - lxd-client + - lye + - lz4-frame-conduit + - lzip + - lzma-streams + - lzo + - maam + - mac + - macaroon-shop + - machinecell + - machines-bytestring + - machines-directory + - machines-encoding + - machines-zlib + - macho + - maclight + - macos-corelibs + - macrm + - madlang + - mage + - MagicHaskeller + - magic-tyfams + - magma + - mailchimp + - MailchimpSimple + - mailchimp-subscribe + - makedo + - makefile + - make-hard-links + - make-monofoldable-foldable + - make-package + - mallard + - mandrill + - mandulia + - mangopay + - Map + - mapalgebra + - map-exts + - Mapping + - mappy + - markdown-kate + - marked-pretty + - mars + - marvin-interpolate + - MASMGen + - massiv-persist + - massiv-serialise + - mathflow + - math-grads + - math-interpolate + - math-metric + - math-programming + - matrix-as-xyz + - matrix-market + - matrix-sized + - maude + - maxent-learner-hw + - maybench + - MaybeT + - MaybeT-monads-tf + - MazesOfMonad + - MBot + - mbox-tools + - mbug + - mcl + - mcm + - mcmaster-gloss-examples + - mcmc-synthesis + - mcpi + - mdapi + - mdcat + - mdp + - mealstrom + - MeanShift + - Measure + - mecab + - mech + - Mecha + - mechs + - Mechs + - mediabus + - mediawiki + - medium-sdk-haskell + - megalisp + - mega-sdist + - mellon-core + - melody + - memcached-binary + - memcache-haskell + - memis + - memoization-utils + - memo-ptr + - memorypool + - menoh + - menshen + - merkle-tree + - messagepack-rpc + - messente + - metadata + - MetaHDBC + - metaheuristics + - meta-misc + - meta-par + - metric + - metricsd-client + - mezzo + - mezzolens + - mgeneric + - MHask + - mi + - miconix-test + - microbase + - microgroove + - microlens-each + - micrologger + - micro-recursion-schemes + - microsoft-translator + - mida + - midi-music-box + - midisurface + - midi-utils + - migrant-hdbc + - migrant-postgresql-simple + - mikmod + - mikrokosmos + - miku + - milena + - mime-directory + - minilens + - minilight + - minions + - miniplex + - minirotate + - ministg + - minizinc-process + - minst-idx + - mios + - MIP + - mirror-tweet + - miso-action-logger + - miso-examples + - mit-3qvpPyAi6mH + - mix-arrows + - mixpanel-client + - ml-w + - mm2 + - mmark + - mmtf + - mmtl + - Mobile-Legends-Hack-Cheats + - modelicaparser + - modular-prelude + - module-management + - modulespection + - moe + - Moe + - MoeDict + - moesocks + - mohws + - monadacme + - monad-atom + - monad-atom-simple + - monad-bayes + - monad-branch + - MonadCatchIO-transformers + - MonadCompose + - monad-fork + - monad-http + - monadiccp + - monadic-recursion-schemes + - monad-interleave + - Monadius + - monad-levels + - monad-lgbt + - monadLib-compose + - monadloc-pp + - monad-log + - monadlog + - monad-lrs + - monad-mersenne-random + - monad-mock + - monad-open + - Monadoro + - monad-parallel-progressbar + - monad-param + - monad-persist + - monadplus + - monad-ran + - monad-recorder + - monads-fd + - MonadStack + - monad-statevar + - monad-ste + - monad-stlike-io + - monad-task + - monad-timing + - monad-tx + - monad-unify + - monad-wrap + - Monatron + - mondo + - money + - monitor + - mono-foldable + - monoid + - monoid-absorbing + - monoid-owns + - monoidplus + - monoids + - monopati + - months + - monus + - monzo + - morfette + - morfeusz + - morpheus-graphql-cli + - morphisms-functors + - morphisms-objects + - morte + - moto-postgresql + - motor-reflection + - mount + - movie-monad + - mpppc + - mpris + - mpvguihs + - mqtt + - mqtt-hs + - mrifk + - mrm + - ms + - msgpack + - msgpack-binary + - msh + - msi-kb-backlit + - MTGBuilder + - mtl-c + - mtl-evil-instances + - mtl-extras + - mtl-tf + - mtlx + - mtp + - MuCheck + - mud + - muesli + - mulang + - multext-east-msd + - multiaddr + - multiarg + - multihash + - multi-instance + - multilinear + - multipass + - multipath + - multiplate-simplified + - multipool-persistent-postgresql + - multirec + - multivariant + - Munkres-simple + - muon + - murmur + - murmur3 + - mushu + - musicScroll + - music-util + - musicxml + - mustache-haskell + - mvar-lock + - mvc + - mxnet + - mxnet-nnvm + - myanimelist-export + - myo + - my-package-testing + - MyPrimes + - mysnapsession + - mysql-effect + - mysql-simple-quasi + - mystem + - my-test-docs + - myxine-client + - mzv + - n2o-protocols + - nagios-plugin-ekg + - named-lock + - named-servant-server + - named-sop + - namelist + - nanocurses + - nano-hmac + - nano-md5 + - nanomsg + - nanomsg-haskell + - nanoparsec + - NanoProlog + - nanovg + - nanq + - naperian + - naqsha + - narc + - nationstates + - nats-client + - nat-sized-numbers + - natural + - NaturalLanguageAlphabets + - NaturalSort + - naver-translate + - nbt + - neat + - needle + - neet + - nehe-tuts + - neither + - neko-lib + - Neks + - neptune-backend + - nero + - nest + - NestedFunctor + - nestedmap + - nested-sequence + - netclock + - netease-fm + - netrium + - NetSNMP + - netspec + - net-spider + - netwire-input-javascript + - netwire-vinylglfw-examples + - network-address + - network-api-support + - network-attoparsec + - network-bitcoin + - network-builder + - network-bytestring + - network-dns + - networked-game + - network-house + - network-msgpack-rpc + - network-packet-linux + - network-server + - network-service + - network-simple-sockaddr + - network-simple-wss + - network-socket-options + - network-transport-amqp + - network-transport-inmemory + - network-uri-json + - network-voicetext + - network-wai-router + - neural + - neural-network-blashs + - neural-network-hmatrix + - newhope + - newports + - newsletter + - newt + - newtype-deriving + - newtype-th + - next-ref + - nextstep-plist + - nfc + - NGrams + - niagra + - nibblestring + - nice-html + - nicovideo-translator + - nitro + - nix-delegate + - nix-deploy + - nix-eval + - nix-freeze-tree + - nixfromnpm + - nixpkgs-update + - nkjp + - nlp-scores + - nm + - NMap + - nntp + - noether + - nofib-analyse + - nofib-analyze + - noise + - nom + - NonEmpty + - nonempty-lift + - non-empty-zipper + - no-role-annots + - notcpp + - not-gloss-examples + - notifications-tray-icon + - NoTrace + - now-haskell + - np-extras + - np-linear + - nptools + - ntp-control + - ntrip-client + - n-tuple + - nullary + - null-canvas + - nullpipe + - numbered-semigroups + - NumberSieves + - NumberTheory + - numerals + - numerals-base + - numeric-qq + - numeric-ranges + - numhask-array + - numhask-free + - numhask-prelude + - numhask-space + - Nutri + - NXTDSL + - nylas + - nyx-game + - oanda-rest-api + - oasis-xrd + - oauth2-jwt-bearer + - oauthenticated + - Object + - ObjectIO + - objective + - oblivious-transfer + - ocaml-export + - Octree + - odbc + - OddWord + - oden-go-packages + - oeis2 + - OGL + - ogmarkup + - oi + - oidc-client + - om-actor + - omaketex + - ombra + - om-doh + - omega + - Omega + - om-elm + - om-fail + - om-http-logging + - omnifmt + - on-a-horse + - onama + - ONC-RPC + - on-demand-ssh-tunnel + - oneormore + - onpartitions + - onu-course + - op + - opaleye-classy + - opaleye-sqlite + - open-adt + - OpenAFP + - openai-hs + - openapi3-code-generator + - openapi-petstore + - openapi-typed + - opench-meteo + - OpenCL + - OpenCLRaw + - OpenCLWrappers + - opencv-raw + - opendatatable + - opengles + - open-haddock + - openid-connect + - open-pandoc + - open-signals + - opensoundcontrol-ht + - openssh-protocol + - opentelemetry-http-client + - opentheory-char + - opentok + - opentype + - OpenVGRaw + - Operads + - operate-do + - operational-extra + - oplang + - opn + - optima + - optimization + - optional + - options-time + - optparse-applicative-simple + - optparse-helper + - orc + - orchestrate + - OrchestrateDB + - order-statistics + - ordinal + - Ordinary + - ordrea + - oref + - organize-imports + - org-mode + - orgmode + - origami + - orizentic + - OrPatterns + - osc + - oscpacking + - oset + - Oslo-Vectize + - osm-conduit + - oso2pdf + - osx-ar + - ot + - OTP + - ottparse-pretty + - overloaded + - overloaded-records + - overture + - pack + - package-description-remote + - package-o-tron + - package-vt + - packed + - packed-dawg + - packed-multikey-map + - packedstring + - packer-messagepack + - packman + - packunused + - pacman-memcache + - pads-haskell + - pagarme + - pagure-hook-receiver + - Paillier + - palette + - PandocAgda + - pandoc-citeproc + - pandoc-filter-graphviz + - pandoc-filter-indent + - pandoc-include + - pandoc-lens + - pandoc-markdown-ghci-filter + - pandoc-placetable + - pandoc-pyplot + - pandoc-unlit + - pandoc-utils + - pang-a-lambda + - pangraph + - panpipe + - pansite + - pantry-tmp + - papa-base-export + - papa-include + - papa-prelude + - papa-prelude-core + - papa-prelude-lens + - papa-prelude-semigroupoids + - papa-prelude-semigroups + - papa-semigroupoids-implement + - paphragen + - papillon + - pappy + - paragon + - parallel-tasks + - paranoia + - parco + - parcom-lib + - par-dual + - pareto + - Parry + - parseargs + - parsec2 + - parsec3 + - parsec-free + - parsec-parsers + - parsec-pratt + - parseerror-eq + - parsely + - parser241 + - parser-combinators-tests + - parsergen + - parser-helper + - parsers-megaparsec + - parsimony + - parsnip + - partage + - partial-records + - partly + - passage + - passman + - PasswordGenerator + - passwords + - pasta + - pastis + - pasty + - patat + - patches-vector + - Pathfinder + - pathfindingcore + - PathTree + - patronscraper + - paypal-adaptive-hoops + - paypal-api + - paypal-rest-client + - pb + - pbc4hs + - PBKDF2 + - pb-next + - pcd-loader + - pcf-font + - PCLT + - pcre-light-extra + - pdfname + - pdf-slave-template + - pdfsplit + - pdf-toolbox-viewer + - pdftotext + - pdynload + - PeanoWitnesses + - pecoff + - pedersen-commitment + - pedestrian-dag + - peg + - peggy + - pencil + - penntreebank-megaparsec + - percent-encoder + - perceptron + - peregrin + - perf + - PerfectHash + - perhaps + - periodic + - periodic-common + - permutation + - permutations + - permute + - persist2er + - Persistence + - persistent-cereal + - persistent-database-url + - persistent-discover + - persistent-equivalence + - persistent-migration + - persistent-mysql-haskell + - persistent-odbc + - persistent-protobuf + - persistent-ratelimit + - persistent-redis + - persistent-relational-record + - persistent-template-classy + - persistent-zookeeper + - persona + - pesca + - pez + - pgdl + - pg-extras + - pgf2 + - pg-harness + - pg-harness-server + - pg-recorder + - pg-store + - pgstream + - phasechange + - phaser + - phoityne + - phone-numbers + - phone-push + - phonetic-languages-properties + - phonetic-languages-simplified-properties-lists + - phonetic-languages-simplified-properties-lists-double + - phraskell + - Phsu + - phybin + - pia-forward + - pi-calculus + - picedit + - pickle + - picologic + - picoparsec + - pictikz + - pier-core + - piet + - pi-forall + - pig + - pi-hoole + - pinch + - pinchot + - Pipe + - pipes-async + - pipes-bgzf + - pipes-cereal + - pipes-core + - pipes-errors + - pipes-interleave + - pipes-io + - pipes-protolude + - pipes-rt + - pipes-s3 + - pipes-shell + - pipes-sqlite-simple + - pipes-transduce + - pipes-vector + - pipes-zeromq4 + - Piso + - pit + - pivotal-tracker + - pixelated-avatar-generator + - pixel-printer + - pkcs10 + - pkcs7 + - pkggraph + - plailude + - plan-applicative + - planar-graph + - plan-b + - planb-token-introspection + - planet-mitchell-test + - plankton + - plat + - platinum-parsing + - PlayingCards + - plist + - plist-buddy + - plot-gtk + - plot-gtk3 + - plot-gtk-ui + - plot-lab + - plugins-auto + - plugins-multistage + - plumbers + - plur + - plural + - plzwrk + - pngload-fixed + - pocket + - pointedalternative + - pointfree-fancy + - pointful + - pointless-haskell + - pokemon-go-protobuf-types + - poker-eval + - pokitdok + - polar-configfile + - polar-shader + - Pollutocracy + - poly-cont + - poly-control + - polydata-core + - polynomial + - polysemy-zoo + - polytypeable + - pomohoro + - ponder + - pong-server + - pool + - pool-conduit + - pop3-client + - popkey + - poppler + - portager + - porte + - PortFusion + - positron + - posix-acl + - posix-api + - posix-realtime + - posix-waitpid + - postcodes + - postgres-embedded + - postgresql-lo-stream + - postgresql-named + - postgresql-simple-bind + - postgresql-simple-named + - postgresql-simple-sop + - postgresql-simple-url + - postgresql-typed-lifted + - postgres-tmp + - postgrest-ws + - postgres-websockets + - postie + - postmark-streams + - postmaster + - potato-tool + - potoki-core + - powermate + - powerpc + - powerqueue-levelmem + - pprecord + - PPrinter + - pqc + - praglude + - preamble + - precursor + - predicate-class + - predicate-typed + - prednote + - prefork + - pregame + - preliminaries + - Prelude + - prelude-generalize + - prelude-plus + - preprocess-haskell + - preprocessor + - preql + - presburger + - present + - press + - pretty-ghci + - pretty-ncols + - prettyprinter-vty + - prim-array + - primes-type + - prim-instances + - PrimitiveArray-Pretty + - primitive-atomic + - primitive-checked + - primitive-convenience + - primitive-foreign + - primitive-indexed + - primitive-maybe + - primitive-simd + - primitive-stablename + - prim-ref + - pringletons + - printcess + - print-debugger + - prints + - PriorityChansConverger + - priority-queue + - probable + - process-conduit + - processing + - process-leksah + - process-listlike + - processmemory + - procrastinating-variable + - procstat + - prof2pretty + - prof-flamegraph + - profunctor-monad + - progress + - progression + - progressive + - progress-meter + - progress-reporting + - proj4-hs-bindings + - projectile + - prolog-graph + - promise + - pronounce + - proof-combinators + - Proper + - properties + - property-list + - prosidy + - prosper + - proteaaudio + - proteaaudio-sdl + - protocol + - protocol-buffers-fork + - proto-lens-arbitrary + - proto-lens-combinators + - proto-lens-optparse + - protolude-lifted + - proton-haskell + - prototype + - prove-everywhere-server + - provenience + - proxy-kindness + - proxy-mapping + - pseudo-trie + - PTQ + - ptr-poker + - publicsuffixlistcreate + - publish + - pubnub + - pubsub + - pugixml + - pugs-DrIFT + - PUH-Project + - Pup-Events-Server + - pure-io + - pure-priority-queue + - purescript-cst + - pure-zlib + - pusher-haskell + - pusher-ws + - pushme + - push-notifications + - putlenses + - pyffi + - pyfi + - python-pickle + - q4c12-twofinger + - qc-oi-testgenerator + - qd + - qed + - qhull-simple + - qif + - QIO + - QLearn + - qlinear + - qnap-decrypt + - qr-imager + - qsem + - QuadEdge + - QuadTree + - quantfin + - quantification + - quantum-arrow + - quarantimer + - qudb + - quenya-verb + - QuickAnnotate + - quickbooks + - quickcheck-property-comb + - quickcheck-property-monad + - quickcheck-rematch + - quickcheck-report + - QuickCheckVariant + - quickcheck-webdriver + - quickjs-hs + - QuickPlot + - quickpull + - quick-schema + - quickset + - Quickson + - quickspec + - quickwebapp + - quipper-core + - quipper-utils + - quiver + - quokka + - quoridor-hs + - RabbitMQ + - rad + - radian + - radium + - radium-formula-parser + - radix + - rados-haskell + - raft + - rakhana + - rakuten + - raml + - randfile + - rando + - random-access-list + - random-derive + - RandomDotOrg + - random-eff + - random-stream + - rand-vars + - Range + - rangemin + - range-set-list + - rapid + - rapid-term + - rascal + - Rasenschach + - rational-list + - rattle + - rattletrap + - raven-haskell-scotty + - raz + - rbst + - rclient + - react-flux + - react-haskell + - reaction-logic + - reactive-bacon + - reactive-banana + - reactive-thread + - react-tutorial-haskell-server + - readability + - read-bounded + - read-ctags + - read-io + - readline + - readme-lhs + - readshp + - really-simple-xml-parser + - reanimate-svg + - reasonable-lens + - record + - record-encode + - records + - recursors + - red-black-record + - redis-hs + - redis-simple + - redland + - Redmine + - reedsolomon + - reenact + - ref + - Ref + - refcount + - Referees + - references + - refined-http-api-data + - reflection-extras + - reflex-basic-host + - reflex-dom-retractable + - reflex-dom-svg + - reflex-dynamic-containers + - reflex-fsnotify + - reflex-gadt-api + - reflex-gi-gtk + - reflex-gloss + - reflex-libtelnet + - reflex-orphans + - reflex-sdl2 + - reflex-transformers + - reflex-vty + - ref-mtl + - reformat + - refractor + - refresht + - reg-alloc + - regex-dfa + - regex-generator + - regex-parsec + - regex-posix-unittest + - regexpr-symbolic + - regexqq + - regex-tdfa-pipes + - regex-tdfa-quasiquoter + - regex-tdfa-rc + - regex-tdfa-text + - regex-tdfa-unittest + - regex-tdfa-utf8 + - regex-tre + - regex-type + - regions + - register-machine-typelevel + - registry + - regress + - regression-simple + - regular + - rehoo + - rei + - reified-records + - reify + - relacion + - relapse + - relational-postgresql8 + - relational-query-postgresql-pure + - relevant-time + - reload + - remark + - remarks + - remote + - remote-debugger + - remote-monad + - reorder-expression + - repa-algorithms + - repa-bytestring + - repa-devil + - repa-eval + - repa-linear-algebra + - repa-scalar + - repa-series + - repl + - RepLib + - replica + - ReplicateEffects + - repo-based-blog + - representable-functors + - reproject + - reqcatcher + - req-conduit + - request-monad + - req-url-extra + - reserve + - reservoir + - resin + - resolve + - resolve-trivial-conflicts + - resource-effect + - resource-embed + - restartable + - restyle + - rethinkdb + - rethinkdb-client-driver + - rethinkdb-wereHamster + - retryer + - reverse-geocoding + - reversi + - ReviewBoard + - rewrite-inspector + - rfc-prelude + - rhbzquery + - ribbit + - RichConditional + - ridley + - riemann + - riff + - ring-buffer + - riscv-isa + - Ritt-Wu + - rivers + - rivet-migration + - rivet-simple-deploy + - RJson + - rlglue + - RLP + - rl-satton + - robin + - robots-txt + - roc-cluster + - roku-api + - rollbar + - rollbar-client + - rollbar-hs + - roller + - ron-rdt + - rope + - rosebud + - rose-trees + - rosmsg + - rosso + - rotating-log + - rounding + - roundtrip-aeson + - rowrecord + - R-pandoc + - rpc-framework + - rpm + - rpmbuild-order + - rrule + - rspp + - rss + - rss2irc + - rstream + - RtMidi + - rtnetlink + - rtorrent-rpc + - rts-loader + - ruby-marshal + - ruby-qq + - ruff + - ruin + - rungekutta + - runhs + - runmany + - rws + - RxHaskell + - SableCC2Hs + - safe-buffer-monad + - safe-coerce + - safecopy-migrate + - safecopy-store + - safe-freeze + - safe-globals + - safeint + - safe-lazy-io + - safe-length + - safepath + - safe-plugins + - safe-printf + - saferoute + - sajson + - salak-toml + - Salsa + - salvia-protocol + - sandlib + - sandman + - sarasvati + - sat + - satchmo + - Saturnin + - savage + - sax + - sbvPlugin + - sc2-proto + - scaleimage + - scalendar + - scanner-attoparsec + - scc + - scenegraph + - scgi + - schedevr + - schedule-planner + - schedyield + - schemas + - scholdoc-types + - SciBaseTypes + - scidb-hquery + - sci-ratio + - scons2dot + - scottish + - scotty-binding-play + - scotty-blaze + - scotty-fay + - scotty-form + - scotty-format + - scotty-params-parser + - scotty-resource + - scotty-rest + - scotty-session + - scotty-tls + - scotty-view + - scrapbook-core + - scrape-changes + - ScratchFs + - script-monad + - scrobble + - scythe + - scyther-proof + - sdl2-cairo-image + - sdl2-compositor + - sdl2-fps + - sdr + - seakale + - sec + - secdh + - seclib + - second-transfer + - secp256k1 + - secp256k1-haskell + - secp256k1-legacy + - secret-santa + - SecureHash-SHA3 + - secure-sockets + - secureUDP + - selectors + - selenium + - selinux + - semantic-source + - semdoc + - semialign-extras + - semibounded-lattices + - Semigroup + - semigroupoids-syntax + - semigroups-actions + - sendgrid-haskell + - sendgrid-v3 + - sensei + - sensu-run + - sentry + - SeqAlign + - sequent-core + - serialize-instances + - serialport + - serokell-util + - servant-aeson-specs + - servant-auth-cookie + - servant-auth-hmac + - servant-auth-token-api + - servant-avro + - servant-client-js + - servant-db + - servant-dhall + - servant-docs-simple + - servant-ekg + - servant-elm + - servant-fiat-content + - servant-generate + - servant-generic + - servant-github + - servant-haxl-client + - servant-hmac-auth + - servant-http-streams + - servant-jquery + - servant-js + - servant-JuicyPixels + - servant-kotlin + - servant-mock + - servant-namedargs + - servant-nix + - servant-pagination + - servant-pandoc + - servant-pool + - servant-proto-lens + - servant-purescript + - servant-pushbullet-client + - servant-py + - servant-quickcheck + - servant-reason + - servant-reflex + - servant-router + - servant-scotty + - servant-seo + - servant-smsc-ru + - servant-static-th + - servant-streaming + - servant-to-elm + - servant-yaml + - servant-zeppelin + - server-generic + - serversession-backend-persistent + - serversession-backend-redis + - serversession-frontend-yesod + - services + - ses-html-snaplet + - SessionLogger + - sessions + - sessiontypes + - Set + - setgame + - set-of + - setoid + - setters + - set-with + - sexp + - sexpr-parser + - sext + - SFML + - sfmt + - sfnt2woff + - SG + - sgd + - SGplus + - sh2md + - shade + - shadower + - shake-bindist + - shakebook + - shake-cabal-build + - shake-dhall + - shake-extras + - shake-minify + - shake-pack + - shake-path + - shake-persist + - shakespeare-babel + - shakespeare-sass + - shared-buffer + - shared-fields + - sha-streams + - she + - Shellac + - shellish + - shellmate + - shell-pipe + - shimmer + - shine-examples + - shivers-cfg + - shoap + - shopify + - shorten-strings + - show-prettyprint + - Shpadoinkle-backend-snabbdom + - Shpadoinkle-streaming + - shwifty + - sifflet + - sifflet-lib + - signed-multiset + - simd + - simple-actors + - simpleargs + - simple-atom + - simple-bluetooth + - simple-conduit + - simple-config + - simpleconfig + - simple-css + - simple-download + - simple-eval + - simple-genetic-algorithm + - simple-index + - simpleirc + - simple-logging + - simple-log-syslog + - simple-money + - simple-neural-networks + - simplenote + - simple-pipe + - simpleprelude + - simple-rope + - simple-server + - simplesmtpclient + - simple-sql-parser + - simple-stacked-vm + - simplest-sqlite + - simple-tabular + - simple-tar + - simple-ui + - simple-units + - simple-vec3 + - simple-zipper + - singleton-dict + - singletons-th + - singleton-typelits + - singnal + - singular-factory + - sink + - sitepipe + - sixfiguregroup + - sized-grid + - sized-types + - sized-vector + - sizes + - sjsp + - SJW + - skeletal-set + - skell + - skemmtun + - skews + - skulk + - skylighting-lucid + - skype4hs + - slack + - slack-notify-haskell + - slack-verify + - slave-thread + - sliceofpy + - Slides + - slim + - sloane + - sloth + - slot-lambda + - slug + - slugify + - smallarray + - smallcheck-kind-generics + - smallcheck-laws + - smallcheck-lens + - smallpt-hs + - smap + - smartcheck + - smartconstructor + - smartGroup + - sme + - smerdyakov + - smiles + - smsaero + - smt2-parser + - smt-lib + - SmtLib + - smtlib2 + - SMTPClient + - smtp-mail-ng + - smtps-gmail + - smuggler + - smuggler2 + - snake + - snake-game + - snap-accept + - snap-blaze-clay + - snap-configuration-utilities + - snap-error-collector + - snaplet-acid-state + - snaplet-amqp + - snaplet-css-min + - snaplet-customauth + - snaplet-fay + - snaplet-hslogger + - snaplet-influxdb + - snaplet-persistent + - snaplet-postgresql-simple + - snaplet-sass + - snaplet-scoped-session + - snaplet-ses-html + - snaplet-sqlite-simple + - snaplet-typed-sessions + - snappy-conduit + - snap-routes + - snap-stream + - snap-testing + - snap-web-routes + - sneakyterm + - SNet + - snipcheck + - snorkels + - snowtify + - socket-activation + - socketed + - socketio + - sockets-and-pipes + - socket-sctp + - socketson + - socket-unix + - sodium + - soegtk + - softfloat-hs + - solga + - sonic-visualiser + - Sonnex + - SoOSiM + - sorted + - sorting + - sorty + - souffle-haskell + - sound-collage + - sousit + - soyuz + - SpaceInvaders + - spacepart + - SpacePrivateers + - spake2 + - spanout + - spars + - sparse + - sparsecheck + - sparse-lin-alg + - special-functors + - special-keys + - speculation + - sphinx + - sphinxesc + - spiros + - spir-v + - splay + - splaytree + - splint + - split-morphism + - splitter + - Spock + - Spock-api-ghcjs + - spoonutil + - spoty + - Sprig + - spritz + - spsa + - spy + - sqlcipher + - sqlite + - sqlite-simple-errors + - sql-simple + - sqlvalue-list + - sqsd-local + - squeal-postgresql + - srcinst + - sscan + - ssh + - ssh-tunnel + - SSTG + - st2 + - stable-heap + - stable-maps + - stable-marriage + - stable-memo + - stack2cabal + - stack2nix + - stackage-cli + - stackage-curator + - stackage-metadata + - stackage-to-hackage + - stackage-types + - stack-bump + - stackcollapse-ghc + - stack-fix + - stack-lib + - stack-prism + - stack-run + - stack-type + - stack-wrapper + - staged-gg + - standalone-derive-topdown + - standalone-haddock + - starling + - stash + - Stasis + - state + - state-bag + - state-plus + - state-record + - static-canvas + - static-tensor + - statistics-dirichlet + - statistics-fusion + - statistics-hypergeometric-genvar + - stats + - statsd + - statvfs + - stb-image-redux + - stc-lang + - stdata + - stdf + - stdio + - steambrowser + - stego-uuid + - stemmer + - stemmer-german + - stepwise + - stern-brocot + - stgi + - STL + - stm-chunked-queues + - stm-firehose + - stm-promise + - stm-stats + - stochastic + - Stomp + - storable + - storable-static-array + - stp + - str + - Strafunski-ATermLib + - Strafunski-StrategyLib + - StrappedTemplates + - stratum-tool + - stratux-types + - stream + - streamdeck + - streamed + - stream-fusion + - streaming-conduit + - streaming-events + - streaming-lzma + - streaming-osm + - streaming-pcap + - streaming-png + - streaming-utils + - streaming-with + - streamly-fsnotify + - stream-monad + - streamproc + - StrictBench + - StrictCheck + - strict-ghc-plugin + - strictly + - strict-tuple-lens + - string-isos + - stringlike + - string-quote + - stringtable-atom + - stripe + - stripe-hs + - stripe-http-streams + - stripe-signature + - strongswan-sql + - structural-traversal + - structures + - stt + - stunclient + - stylish-cabal + - stylized + - subleq-toolchain + - submark + - subsample + - sub-state + - subwordgraph + - suffix-array + - suffixarray + - SuffixStructures + - sugarhaskell + - suitable + - summoner + - sunlight + - sunroof-compiler + - superbubbles + - superevent + - supermonad + - supernova + - supero + - super-user-spark + - supervisor + - supplemented + - surjective + - sv-core + - SVD2HS + - svfactor + - svg-builder-fork + - svgcairo + - svgutils + - svm-light-utils + - svm-simple + - svndump + - swagger-petstore + - swagger-test + - swf + - swift-lda + - swiss-ephemeris + - swisstable + - syb-extras + - SybWidget + - syb-with-class-instances-text + - syfco + - sym + - symantic + - symantic-cli + - symantic-http-test + - symantic-parser + - symantic-xml + - symbolic-link + - symengine + - symengine-hs + - sync + - sync-mht + - syntax-trees + - syntax-trees-fork-bairyn + - synthesizer + - Sysmon + - sys-process + - system-canonicalpath + - system-command + - system-extra + - system-inotify + - system-lifted + - system-linux-proc + - system-locale + - system-random-effect + - t3-server + - table + - tableaux + - table-layout + - tables + - Tables + - tablestorage + - table-tennis + - Tablify + - tabloid + - tabs + - tag-bits + - tagged-exception-core + - tagged-timers + - taglib-api + - tagsoup-ht + - tagsoup-megaparsec + - tagsoup-parsec + - tagsoup-selection + - tai + - tai64 + - takahashi + - Takusen + - takusen-oracle + - tamarin-prover-utils + - Tape + - tapioca + - TaskMonad + - tasty-auto + - tasty-fail-fast + - tasty-grading-system + - tasty-hedgehog-coverage + - tasty-mgolden + - tasty-stats + - tasty-test-vector + - TBC + - TBit + - tcache-AWS + - tcod-haskell + - tcp + - tcp-streams-openssl + - tds + - teams + - teeth + - telegram + - telegram-api + - teleport + - teleshell + - tellbot + - tempi + - template-default + - template-haskell-util + - template-hsml + - templateify + - templatepg + - template-yj + - tempodb + - temporal-csound + - tempus + - tensor + - tensorflow + - tensorflow-opgen + - tensor-safe + - termbox-bindings + - termination-combinators + - termplot + - term-rewriting + - terntup + - terraform-http-backend-pass + - tersmu + - testCom + - testcontainers + - test-fixture + - test-framework-doctest + - test-framework-quickcheck + - test-framework-skip + - test-framework-testing-feat + - test-framework-th-prime + - testloop + - testpack + - testpattern + - test-pkg + - testrunner + - test-sandbox + - test-shouldbe + - tex2txt + - texbuilder + - texrunner + - text1 + - text-all + - text-and-plots + - text-ascii + - text-containers + - text-format-heavy + - text-generic-pretty + - text-icu-normalized + - text-lens + - text-lips + - text-markup + - text-normal + - textocat-api + - text-offset + - text-position + - text-register-machine + - text-replace + - textual + - text-utf8 + - text-xml-qq + - text-zipper-monad + - tfp-th + - tftp + - tga + - thank-you-stars + - th-build + - th-dict-discovery + - thentos-cookie-session + - Theora + - theoremquest + - th-fold + - th-format + - thih + - Thingie + - th-instance-reification + - th-kinds + - th-kinds-fork + - th-lego + - thock + - thorn + - th-pprint + - threadmanager + - threepenny-editors + - threepenny-gui-contextmenu + - threepenny-gui-flexbox + - thrift + - throttled-io-loop + - th-sccs + - th-tc + - th-to-exp + - th-traced + - thumbnail-plus + - TicTacToe + - tictactoe3d + - tidal-midi + - tidal-vis + - tie-knot + - tiempo + - tiger + - tightrope + - timecalc + - time-extras + - time-machine + - timemap + - timeout + - timeout-with-results + - timeparsers + - TimePiece + - time-qq + - time-quote + - time-recurrence + - time-series + - timeseries + - time-series-lib + - timeutils + - time-w3c + - timezone-detect + - timezone-olson-th + - tini + - tintin + - TinyLaunchbury + - tiny-scheduler + - tinytemplate + - TinyURL + - tinyXml + - titan-debug-yampa + - titan-record-yampa + - Titim + - tkhs + - tkyprof + - tmp-postgres + - todo + - tofromxml + - to-haskell + - toilet + - tokenify + - tokenizer-streaming + - token-limiter + - token-search + - tokstyle + - tokyocabinet-haskell + - tokyotyrant-haskell + - tomato-rubato-openal + - toml + - tonatona-persistent-postgresql + - tonatona-persistent-sqlite + - tonatona-servant + - toodles + - Top + - torch + - TORCS + - to-string-class + - TotalMap + - touched + - Tournament + - toxiproxy-haskell + - tptp + - trace + - trace-call + - traced + - trace-function-call + - tracetree + - tracing-control + - tracked-files + - tracker + - trackit + - traction + - tracy + - traildb + - transactional-events + - TransformeR + - transformers-compose + - transformers-lift + - transformers-runnable + - TransformersStepByStep + - transient-universe + - translatable-intset + - translate + - translate-cli + - traversal-template + - travis + - travis-meta-yaml + - trawl + - traypoweroff + - treap + - treemap + - treemap-html + - tree-render-text + - TreeStructures + - tree-traversals + - t-regex + - tremulous-query + - TrendGraph + - trhsx + - trigger + - trim + - tripLL + - trivia + - tropical + - tropical-geometry + - true-name + - tsession + - tsparse + - tsp-viz + - tsuntsun + - tsvsql + - ttask + - tttool + - tubes + - tuntap + - tuple-gen + - tupleinstances + - tuple-lenses + - turing-machines + - turing-music + - turtle-options + - tweak + - twentefp-websockets + - twfy-api-client + - twhs + - twilio + - twine + - twirp + - twitter-feed + - tx + - txtblk + - TYB + - tyfam-witnesses + - typalyze + - typeable-th + - type-combinators + - typed-encoding + - typedflow + - typedquery + - typed-wire + - type-eq + - type-fun + - typehash + - type-indexed-queues + - type-int + - type-interpreter + - type-level-bst + - type-level-natural-number-induction + - type-level-natural-number-operations + - typelevel-tensor + - type-list + - TypeNat + - type-of-html-static + - typeparams + - type-prelude + - typesafe-precure + - types-compat + - type-settheory + - type-spine + - type-tree + - type-unary + - typograffiti + - tyro + - uberlast + - ucam-webauth-types + - ucd + - uconv + - udp-conduit + - udp-streaming + - uhexdump + - uhttpc + - ui-command + - unamb-custom + - unbounded-delays-units + - unboxed-containers + - unboxed-references + - unbreak + - unfix-binders + - unicode-prelude + - unicode-show + - unicode-symbols + - unicode-tricks + - uniform-fileio + - union-map + - uniprot-kb + - uniqueid + - uniquely-represented-sets + - uniqueness-periods-vector-properties + - units-attoparsec + - unittyped + - unitym-yesod + - uni-util + - universal-binary + - unix-handle + - unix-process-conduit + - unix-recursive + - unlifted-list + - unliftio-messagebox + - unm-hip + - unordered-containers-rematch + - unordered-graphs + - unordered-intmap + - unpacked-either + - unpacked-maybe + - unpack-funcs + - unroll-ghc-plugin + - unsafely + - unsequential + - unused + - uom-plugin + - Updater + - uploadcare + - upskirt + - uri + - uri-conduit + - uri-encoder + - uri-parse + - uri-template + - uri-templater + - URLb + - urlcheck + - urldecode + - url-decoders + - urldisp-happstack + - urlencoded + - url-generic + - urn + - urn-random + - urxml + - users-mysql-haskell + - users-persistent + - utf + - utf8-prelude + - utf8-validator + - UTFTConverter + - util-logict + - util-plus + - util-primitive + - util-universe + - uuagc-bootstrap + - uu-cco + - uuid-aeson + - uuid-orphans + - uvector + - uxadt + - vabal-lib + - vacuum + - validated-types + - Validation + - validations + - valid-names + - value-supply + - vampire + - var + - varan + - variables + - variadic + - variation + - vaultaire-common + - vault-tool-server + - vault-trans + - vcache + - vcatt + - vcf + - vcswrapper + - Vec-Boolean + - Vec-OpenGLRaw + - vect-floating + - vect-opengl + - vector-bytestring + - vector-clock + - vector-conduit + - vector-fftw + - vector-functorlazy + - vector-heterogenous + - vector-random + - vector-read-instances + - vector-space-map + - vector-space-opengl + - vector-space-points + - vector-static + - Vec-Transform + - Verba + - verbalexpressions + - verdict + - verify + - verilog + - verismith + - versioning + - vhd + - vhdl + - vicinity + - viewprof + - views + - Villefort + - vimus + - vintage-basic + - vinyl-json + - vinyl-named-sugar + - vinyl-plus + - vinyl-utils + - vinyl-vectors + - virthualenv + - visibility + - visualize-cbn + - visual-prof + - vitrea + - vk-aws-route53 + - VKHS + - vowpal-utils + - voyeur + - vpq + - VRML + - vte + - vtegtk3 + - vty-examples + - vty-menu + - vty-ui + - wacom-daemon + - waddle + - wai-git-http + - wai-graceful + - wai-handler-devel + - wai-handler-fastcgi + - wai-handler-scgi + - wai-handler-webkit + - wai-hmac-auth + - wai-lens + - wai-lite + - wai-logger-buffered + - wai-logger-prefork + - wai-make-assets + - wai-middleware-catch + - wai-middleware-crowd + - wai-middleware-delegate + - wai-middleware-etag + - wai-middleware-headers + - wai-middleware-hmac-client + - wai-middleware-preprocessor + - wai-middleware-static-caching + - wai-middleware-travisci + - wai-rate-limit-redis + - wai-request-spec + - wai-responsible + - wai-router + - wai-routes + - wai-routing + - wai-secure-cookies + - wai-session-alt + - wai-session-mysql + - wai-session-postgresql + - wai-session-redis + - wai-static-cache + - waitfree + - wai-throttler + - waitra + - wallpaper + - warc + - warp-dynamic + - warp-grpc + - warp-static + - warp-systemd + - wasm + - watchdog + - watcher + - watchit + - wavefront + - wavefront-obj + - weak-bag + - weather-api + - webapp + - WebBits + - webcloud + - webcrank + - webcrank-dispatch + - web-css + - webdriver-angular + - webdriver-snoy + - web-encodings + - WeberLogic + - webfinger-client + - webify + - webkit-javascriptcore + - webmention + - web-output + - web-push + - Webrexp + - web-routes-quasi + - web-routes-transformers + - webshow + - websockets-rpc + - webwire + - WEditor + - weekdaze + - weighted-regexp + - welshy + - werewolf + - Wheb + - while-lang-parser + - whim + - whiskers + - whois + - why3 + - wide-word + - WikimediaParser + - windns + - winerror + - Wired + - wires + - wiring + - witty + - wkt + - wkt-geom + - WL500gPLib + - wl-pprint-extras + - WMSigner + - woe + - woffex + - wol + - word2vec-model + - wordify + - wordlist + - WordNet + - WordNet-ghc74 + - wordpass + - wordpress-auth + - wordsearch + - workdays + - Workflow + - workflow-osx + - workflow-windows + - work-time + - wp-archivebot + - wreq-patchable + - wreq-sb + - writer-cps-lens + - writer-cps-monads-tf + - writer-cps-morph + - wsdl + - wsedit + - wsjtx-udp + - wtk + - wumpus-core + - wxdirect + - X11-extras + - X11-rm + - X11-xdamage + - X11-xfixes + - xchat-plugin + - xcp + - x-dsp + - Xec + - xenstore + - xfconf + - xformat + - xhaskell-library + - xhb + - xilinx-lava + - xine + - xing-api + - xkbcommon + - xkcd + - xleb + - xls + - xlsior + - xlsx-templater + - xml2json + - xml-conduit-decode + - xml-conduit-selectors + - xml-conduit-stylist + - xml-html-conduit-lens + - XmlHtmlWriter + - xml-parsec + - xml-prettify + - xml-query + - xml-tydom-core + - XMMS + - xmonad-bluetilebranch + - xmonad-contrib-gpl + - xmonad-dbus + - xmonad-eval + - xmonad-vanessa + - xmonad-windownames + - xor + - Xorshift128Plus + - xorshift-plus + - xournal-types + - xrefcheck + - xsact + - xsd + - xslt + - xxhash + - y0l0bot + - yabi-muno + - yackage + - yahoo-finance-api + - yahoo-finance-conduit + - yahoo-prices + - yahoo-web-search + - yajl + - yall + - yam-config + - yaml-pretty-extras + - YamlReference + - yaml-rpc + - yampa2048 + - yampa-glfw + - yampa-gloss + - yampa-glut + - yampa-sdl2 + - YampaSynth + - yam-servant + - yandex-translate + - yaop + - yap + - yarr + - yaya-test + - yaya-unsafe-test + - yeller + - yeshql-hdbc + - yeshql-postgresql-simple + - yesod-angular + - yesod-angular-ui + - yesod-auth-account + - yesod-auth-account-fork + - yesod-auth-bcrypt + - yesod-auth-bcryptdb + - yesod-auth-deskcom + - yesod-auth-hmac-keccak + - yesod-auth-kerberos + - yesod-auth-ldap-mediocre + - yesod-auth-ldap-native + - yesod-auth-nopassword + - yesod-auth-pam + - yesod-auth-smbclient + - yesod-auth-zendesk + - yesod-bootstrap + - yesod-comments + - yesod-content-pdf + - yesod-crud + - yesod-crud-persist + - yesod-datatables + - yesod-dsl + - yesod-fast-devel + - yesod-filter + - yesod-form-richtext + - yesod-gitrev + - yesod-goodies + - yesod-job-queue + - yesod-links + - yesod-lucid + - yesod-paginate + - yesod-pagination + - yesod-pnotify + - yesod-pure + - yesod-raml + - yesod-recaptcha + - yesod-routes + - yesod-routes-flow + - yesod-rst + - yesod-s3 + - yesod-sass + - yesod-static-angular + - yesod-static-remote + - yesod-test-json + - yesod-tls + - yesod-vend + - yesod-worker + - YFrob + - yggdrasil + - yhccore + - yhseq + - yices + - yi-contrib + - yi-monokai + - yi-solarized + - yi-spolsky + - yoda + - yst + - yxdb-utils + - z3-encoding + - z85 + - zabt + - zampolit + - Z-Data + - ZEBEDDE + - zendesk-api + - zenhack-prelude + - zeno + - zeromq4-conduit + - zeromq-haskell + - zettelkast + - ZFS + - zifter + - zigbee-znet25 + - zip-conduit + - zipedit + - zipkin + - ziptastic-core + - zm + - ZMachine + - zmidi-score + - zoneinfo + - zoom + - zoom-refs + - zsdd + - zsh-battery + - zsyntax + - ztar + - Zwaluw + - zxcvbn-dvorak diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 2fc79af79b6..7c92552682f 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -3,30 +3,3304 @@ # It is supposed to list all haskellPackages that cannot evaluate because they # depend on a dependency marked as broken. dont-distribute-packages: + + - 4Blocks + - a50 + - abcBridge + - abeson + - AbortT-monadstf + - AbortT-mtl + - accelerate-arithmetic + - accelerate-fourier + - accelerate-typelits + - access-token-provider + - ac-machine-conduit + - acme-php + - acme-safe + - acousticbrainz-client + - activehs + - actor + - AC-Vector-Fancy + - addy + - adhoc-network + - adict + - ADPfusionForest + - ADPfusionSet + - adp-multi-monadiccp + - Advgame + - Advise-me + - aern2-real + - AERN-Net + - AERN-Real + - AERN-Real-Double + - AERN-Real-Interval + - AERN-RnToRm + - AERN-RnToRm-Plot + - aeson-bson + - AesonBson + - aeson-native + - afv + - agda-server + - agda-snippets-hakyll + - agentx + - aip + - airship + - aivika-distributed + - algebra-checkers + - algebra-driven-design + - algebra-sql + - algolia + - AlgoRhythm + - AlignmentAlgorithms + - alms + - alpha + - alsa-gui + - alsa-pcm-tests + - alsa-seq-tests + - amazon-emailer-client-snap + - ampersand + - amqp-streamly + - analyze-client + - anatomy + - AndroidViewHierarchyImporter + - animate-example + - animate-frames + - animate-preview + - animate-sdl2 + - annah + - Annotations + - anonymous-sums-tests + - antagonist + - anticiv + - antlrc + - apelsin + - apiary + - apiary-authenticate + - apiary-clientsession + - apiary-cookie + - apiary-eventsource + - apiary-helics + - apiary-http-client + - apiary-logger + - apiary-memcached + - apiary-mongoDB + - apiary-persistent + - apiary-purescript + - apiary-redis + - apiary-session + - apiary-websockets + - api-rpc-pegnet + - apis + - api-yoti + - apotiki + - ApplePush + - approx-rand-test + - arbor-monad-metric-datadog + - arch-hs + - archlinux-web + - arduino-copilot + - arff + - arghwxhaskell + - argon + - ariadne + - arithmetic-circuits + - array-forth + - arraylist + - ascii-table + - asic - ASN1 - - XML + - assert4hs-hspec + - assert4hs-tasty + - assimp + - ast-monad-json + - astview + - atlassian-connect-core + - atmos-dimensional-tf + - atomic-primops-foreign + - atp + - AttoJson + - attoparsec-enumerator + - attoparsec-ip + - attoparsec-iteratee + - attoparsec-text-enumerator + - attoparsec-uri + - atuin + - audiovisual + - aura + - authoring + - AutoForms + - autonix-deps-kf5 + - avers + - avers-api + - avers-api-docs + - avers-server + - AvlTree + - avro-piper + - awesomium + - awesomium-glut + - aws-configuration-tools + - aws-dynamodb-conduit + - aws-dynamodb-streams + - aws-elastic-transcoder + - aws-kinesis + - aws-kinesis-client + - aws-kinesis-reshard + - aws-lambda + - aws-mfa-credentials + - aws-sdk + - aws-sdk-xml-unordered + - aws-sign4 + - aws-sns + - axiom + - azimuth-hs + - azure-functions-worker + - azure-service-api + - azure-servicebus + - babylon + - backblaze-b2-hs + - backdropper + - ballast + - bamboo + - bamboo-launcher + - bamboo-plugin-highlight + - bamboo-plugin-photo + - bamboo-theme-blueprint + - bamboo-theme-mini-html5 + - bamse + - bamstats + - Barracuda + - base16-lens + - base32-bytestring + - base62 + - base64-bytes + - baserock-schema + - BASIC + - batchd + - battlenet-yesod + - battleships + - bayes-stack + - bbi + - bdcs + - bdcs-api + - beam-automigrate + - beam-migrate + - beam-mysql + - beam-newtype-field + - beam-postgres + - beam-sqlite + - beam-th + - beautifHOL + - bech32-th + - bein + - belka + - BerlekampAlgorithm + - berp + - bff + - bglib + - billboard-parser + - billeksah-forms + - billeksah-main + - billeksah-pane + - binary-file + - binary-protocol-zmq + - binary-streams + - bindings-apr-util + - bindings-linux-videodev2 + - bindings-ppdev + - binding-wx + - binembed-example + - bioace + - bioalign + - Biobase + - BiobaseBlast + - BiobaseDotP + - BiobaseENA + - BiobaseEnsembl + - BiobaseFasta + - BiobaseFR3D + - BiobaseHTTP + - BiobaseHTTPTools + - BiobaseInfernal + - BiobaseMAF + - BiobaseTrainingData + - BiobaseTurner + - BiobaseTypes + - BiobaseVienna + - BiobaseXNA + - biofasta + - biofastq + - BioHMM + - bioinformatics-toolkit + - biophd + - biopsl + - biosff + - biostockholm + - bip32 + - birch-beer + - bird + - BirdPP + - bit-array + - bitcoin-address + - bitcoin-api + - bitcoin-api-extra + - bitcoin-block + - bitcoin-compact-filters + - bitcoind-regtest + - bitcoind-rpc + - bitcoin-keys + - bitcoin-rpc + - bitcoin-scripting + - bitcoin-tx + - bitcoin-types + - Bitly + - bitly-cli + - bitmaps + - bittorrent + - bla + - blakesum-demo + - BlastHTTP + - blastxml + - blatex + - blaze-builder-enumerator + - blaze-colonnade + - ble + - blink1 + - blip + - Blobs + - blogination + - BlogLiterately + - BlogLiterately-diagrams + - bloodhound-amazonka-auth + - bloxorz + - blubber + - bluetile + - blunt + - bno055-haskell + - bogre-banana + - bond-haskell + - bond-haskell-compiler + - bookkeeper-permissions + - Bookshelf + - boomslang + - boopadoop + - boots-cloud + - boots-web + - borel + - bowntz + - box + - box-csv + - box-socket + - breakout + - bricks + - bricks-internal-test + - bricks-parsec + - bricks-rendering + - bricks-syntax + - bronyradiogermany-streaming + - brotli-conduit + - brotli-streams + - bson-generic + - bson-generics + - bson-lens + - bson-mapping + - b-tree + - btree + - buchhaltung + - buildbox-tools + - buildwrapper + - bulletproofs + - burnt-explorer + - bus-pirate + - buster-gtk + - buster-network + - butterflies + - bv-sized-lens + - bytebuild + - bytehash + - bytelog + - bytesmith + - bytestring-read + - c0check + - cabal2arch + - cabal-bounds + - cabal-cache + - cabal-cargs + - cabalmdvrpm + - cabal-query + - cabalrpmdeps + - cabal-test + - cake + - cakyrespa + - cal3d-examples + - cal3d-opengl + - calc + - calculator + - caldims + - call + - camfort + - campfire + - candid + - canteven-http + - cao + - cap + - carboncopy + - CarneadesIntoDung + - car-pool + - cartel + - casadi-bindings + - casadi-bindings-control + - casadi-bindings-core + - casadi-bindings-ipopt-interface + - casadi-bindings-snopt-interface + - cash + - cassandra-cql + - cassy + - casui + - categorical-algebra + - category-extras + - CBOR + - CC-delcont-alt + - cctools-workqueue + - cef3-simple + - ceilometer-common + - celtchar + - cereal-enumerator + - cereal-io-streams + - cereal-streams + - certificate + - cfipu + - cflp + - cfopu + - cgrep + - chainweb-mining-client + - chakra + - chalkboard-viewer + - charade + - chart-cli + - Chart-fltkhs + - chart-svg + - chart-svg-various + - chart-unit + - cheapskate-terminal + - check-pvp + - chevalier-common + - chitauri + - choose-exe + - chorale-geo + - chp-mtl + - chp-plus + - chp-transformers + - chr-core + - chr-lang + - chu2 + - chunks + - ciphersaber2 + - citation-resolve + - citeproc-hs-pandoc-filter + - clac + - clafer + - claferIG + - claferwiki + - clash + - clash-ghc + - clash-ghc_1_4_1 + - clash-lib + - clash-lib_1_4_1 + - clash-multisignal + - clash-prelude-quickcheck + - clash-systemverilog + - clash-verilog + - clash-vhdl + - classify-frog + - classy-miso + - clckwrks + - clckwrks-cli + - clckwrks-dot-com + - clckwrks-plugin-bugs + - clckwrks-plugin-ircbot + - clckwrks-plugin-mailinglist + - clckwrks-plugin-media + - clckwrks-plugin-page + - clckwrks-plugin-redirect + - clckwrks-theme-bootstrap + - clckwrks-theme-clckwrks + - clckwrks-theme-geo-bootstrap + - cless + - click-clack + - clifford + - clippings + - clocked + - cloud-haskell + - cloud-seeder + - cloudyfs + - clua + - ClustalParser + - clustertools + - clutterhs + - cmathml3 + - CMCompare + - cmptype + - cmv + - cnc-spec-compiler + - Coadjute + - codec + - codec-rpm + - codemonitor + - cognimeta-utils + - coinbase-exchange + - colada + - collapse-duplication + - collection-json + - collections-base-instances + - co-log-polysemy-formatting + - color-counter + - colorless-http-client + - colorless-scotty + - colour-space + - columbia - comark + - Combinatorrent + - comic + - commsec-keyexchange + - comonad-random + - ComonadSheet + - compact-mutable + - complexity + - computational-algebra + - concraft + - concraft-hr + - concraft-pl + - concrete-haskell + - concrete-haskell-autogen + - condor + - Condor + - conductive-hsc3 + - conductive-song + - conduit-vfs-zip + - confcrypt + - conferer-provider-dhall + - conferer-provider-yaml + - conferer-source-dhall + - conferer-source-yaml + - conffmt + - Configger + - configifier + - config-select + - configurator-ng + - constraint-manip + - constructible + - consumers + - container + - containers-accelerate + - continuum + - continuum-client + - control + - control-monad-attempt + - control-monad-exception-monadsfd + - Control-Monad-MultiPass + - conversions + - convert + - convertible-ascii + - convertible-text + - coordinate + - copilot + - copilot-c99 + - copilot-cbmc + - copilot-language + - copilot-libraries + - copilot-theorem + - CoreFoundation + - coroutine-enumerator + - coroutine-iteratee + - couchdb-enumerator + - couch-simple + - CPBrainfuck + - CPL + - cprng-aes-effect + - cql-io-tinylog + - cqrs-example + - cqrs-memory + - cqrs-postgresql + - cqrs-sqlite3 + - cqrs-test + - cqrs-testkit + - craft + - craftwerk-cairo + - craftwerk-gtk + - craze + - crf-chain1 + - crf-chain1-constrained + - crf-chain2-generic + - crf-chain2-tiers + - criu-rpc + - crockford + - cron-compat + - cryptocipher + - crypto-conduit + - cryptoids + - cryptoids-class + - cryptol + - crystalfontz + - csg + - cspmchecker + - CSPM-cspm + - CSPM-Interpreter + - CSPM-ToProlog + - csv-enumerator + - ctpl + - cube + - currency-codes + - cursedcsv + - cv-combinators + - cypher + - Dangerous + - dapi + - darcs-benchmark + - darcs-beta + - darcsden + - darcs-fastconvert + - DarcsHelpers + - darcswatch + - darkplaces-demo + - darkplaces-rcon-util + - dash-haskell + - data-accessor-monads-fd + - data-basic + - data-cycle + - datadog-tracing + - data-elf + - dataflow + - data-layer + - data-lens-fd + - data-lens-ixset + - data-lens-template + - data-object-json + - data-object-yaml + - data-result + - data-rtuple + - data-structure-inferrer + - date-conversions + - dbjava + - dbus-client + - ddate + - ddc-build + - ddc-core + - ddc-core-babel + - ddc-core-eval + - ddc-core-flow + - ddc-core-llvm + - ddc-core-salt + - ddc-core-simpl + - ddc-core-tetra + - ddc-driver + - ddci-core + - ddc-interface + - ddc-source-tetra + - ddc-tools + - ddc-war + - debug + - debug-trace-var + - decidable + - decimal-arithmetic + - dedukti + - deeplearning-hs + - deepzoom + - defargs + - DefendTheKing + - definitive-graphics + - deka-tests + - delaunay + - delicious + - delimited-text + - delimiter-separated + - delta + - delta-h + - dependent-state + - dephd + - dep-t-advice + - deptrack-devops + - deptrack-dot + - dequeue + - derive-IG + - detour-via-uom + - devtools + - dewdrop + - dfinity-radix-tree + - dhall-docs + - dhcp-lease-parser + - dia-functions + - diagrams-braille + - diagrams-builder + - diagrams-haddock + - diagrams-html5 + - diagrams-pandoc + - diagrams-pgf + - diagrams-wx + - DifferenceLogic + - difference-monoid + - digestive-functors-hsp + - dingo-core + - dingo-example + - dingo-widgets + - diplomacy + - diplomacy-server + - dirfiles + - discogs-haskell + - discord-gateway + - discord-hs + - discord-register + - discord-rest + - DisTract + - distributed-process-async + - distributed-process-azure + - distributed-process-client-server + - distributed-process-ekg + - distributed-process-execution + - distributed-process-extras + - distributed-process-fsm + - distributed-process-lifted + - distributed-process-monad-control + - distributed-process-p2p + - distributed-process-platform + - distributed-process-registry + - distributed-process-simplelocalnet + - distributed-process-supervisor + - distributed-process-systest + - distributed-process-task + - distributed-process-tests + - distributed-process-zookeeper + - distribution-plot + - dixi + - dl-fedora + - dmenu-pkill + - dmenu-pmount + - dmenu-search + - DMuCheck + - DnaProteinAlignment + - doc-review + - DocTest + - doi + - DOM + - domain + - domain-core + - domain-optics + - dow + - download-media-content + - DP + - dph-examples + - dph-lifted-base + - dph-lifted-copy + - dph-lifted-vseg + - dph-prim-interface + - dph-prim-par + - dph-prim-seq + - DrHylo + - dropbox-sdk + - dropsolve + - DSH + - dsh-sql + - dsmc-tools + - DSTM + - dtd + - dumb-cas + - Dust + - Dust-tools + - Dust-tools-pcap + - dvda + - dynamic-cabal + - dynamic-plot + - dynobud + - DysFRP-Cairo + - DysFRP-Craftwerk + - eccrypto-ed25519-bindings + - ecdsa + - edenskel + - edentv + - edge + - edges + - editable + - EditTimeReport + - effective-aspects-mzv + - egison + - egison-pattern-src-haskell-mode + - egison-pattern-src-th-mode + - egison-quote + - egison-tutorial + - elerea-examples + - eliminators_0_8 + - elliptic-curve + - elsa + - emacs-keys + - email + - emailparse + - embeddock + - embeddock-example + - embroidery + - engine-io-growler + - entangle + - EntrezHTTP + - enumerate + - enumerate-function + - enumerator-fd + - enumerator-tf + - ephemeral + - erf-native + - eros-client + - eros-http + - error-message + - errors-ext + - ersatz-toysat + - esotericbot + - EsounD + - estreps + - Etage-Graph + - EtaMOO + - Eternal10Seconds + - eternity + - eternity-timestamped + - ether + - Etherbunny + - ethereum-analyzer + - ethereum-analyzer-cli + - ethereum-analyzer-webui + - ethereum-client-haskell + - ethereum-merkle-patricia-db + - evdev-streamly + - eventful-postgresql + - eventful-sqlite + - event-monad + - EventSocket + - eventsource-geteventstore-store + - every-bit-counts + - exception-monads-fd + - exference + - expand + - expat-enumerator + - expiring-containers + - explicit-iomodes-bytestring + - explicit-iomodes-text + - explicit-sharing + - explore + - expressions-z3 + - extemp + - extensible-data + - extract-dependencies + - Facts + - factual-api + - fadno-braids + - FailureT + - fallingblocks + - falling-turnip + - family-tree + - fast-digits + - fastirc + - fault-tree + - fbrnch + - fcd + - FComp + - feature-flipper-postgres + - fedora-img-dl + - feed2lj + - feed2twitter + - feed-gipeda + - feed-translator + - fei-base + - fei-cocoapi + - fei-dataiter + - fei-datasets + - fei-examples + - fei-modelzoo + - fei-nn + - feldspar-compiler + - feldspar-language + - FermatsLastMargin + - festung + - ffmpeg-tutorials + - ficketed + - fields + - FieldTrip + - filepath-crypto + - filepather + - FilePather + - filepath-io-access + - filesystem-enumerator + - Finance-Treasury + - find-clumpiness + - findhttp + - FiniteMap + - firstify + - FirstOrderTheory + - fixed-point-vector + - fixed-point-vector-space + - fixhs + - fix-parser-simple + - flac-picture + - flashblast + - flatbuffers + - flexiwrap + - flexiwrap-smallcheck + - Flippi + - flite + - flowdock-api + - flower + - flowsim + - fltkhs-demos + - fltkhs-fluid-demos + - fltkhs-fluid-examples + - fltkhs-hello-world + - fltkhs-themes + - fluent-logger + - fluent-logger-conduit + - FM-SBLEX + - foldl-transduce-attoparsec + - follower + - foo + - Forestry + - forex2ledger + - formal + - FormalGrammars + - format + - format-status + - forml + - formlets + - formlets-hsp + - forth-hll + - fortran-src-extras + - foscam-directory + - foscam-sort + - Foster + - fp-ieee + - fplll + - fpnla-examples - frame-markdown + - Frames-beam + - Frames-dsv + - Frank + - freekick2 + - freelude + - freer-converse + - free-theorems-counterexamples + - free-theorems-seq + - free-theorems-seq-webui + - free-theorems-webui + - frpnow-gloss + - frpnow-gtk + - frpnow-gtk3 + - frpnow-vty + - ftdi + - ftp-client-conduit + - FTPLine + - ftree + - ftshell + - funbot + - funbot-git-hook + - funcons-lambda-cbv-mp + - funcons-simple + - funcons-tools + - functional-arrow + - function-combine + - functor-combo + - funflow-nix + - funion + - funnyprint + - funsat + - fused-effects-squeal + - fwgl-glfw + - fwgl-javascript + - fxpak + - g2 + - g2q + - gact + - galois-fft + - Gamgine + - gargoyle-postgresql-connect + - gbu + - gdax + - gdiff-ig + - GeBoP + - gedcom + - geek + - geek-server + - gelatin-freetype2 + - gelatin-fruity + - gelatin-gl + - gelatin-sdl2 + - gelatin-shaders + - Genbank + - Gene-CluEDO + - generics-mrsop-gdiff + - genesis + - genesis-test + - geniconvert + - geni-gui + - GenSmsPdu + - GenussFold + - geodetic + - geojson-types + - geolite-csv + - getemx + - ghc-imported-from + - ghc-instances + - ghci-pretty + - ghcjs-hplay + - ghc-mod + - ghc-tags-plugin + - ghcup + - ghc-vis + - ght + - gi-cairo-again + - gi-gsk + - gi-gstpbutils + - gi-gtk_4_0_4 + - git-fmt + - git-gpush + - github-webhook-handler-snap + - gitlib-cross + - gitlib-s3 + - git-object - git-remote-ipfs + - givegif + - gladexml-accessor + - glazier + - glazier-pipes + - glazier-react + - glazier-react-examples + - glazier-react-widget + - GLFW-OGL + - GLFW-task + - global + - global-config + - glome-hs + - GlomeView + - gloss-banana + - gloss-devil + - gloss-examples + - gloss-sodium + - gmap + - gmndl + - gnome-desktop + - gnomevfs + - gnss-converters + - gnuidn + - goal-geometry + - goal-probability + - goal-simulation + - goat + - GoogleDirections + - google-drive + - google-mail-filters + - google-maps-geocoding + - googleplus + - GoogleSB + - google-static-maps + - GoogleTranslate + - gore-and-ash-actor + - gore-and-ash-async + - gore-and-ash-demo + - gore-and-ash-glfw + - gore-and-ash-lambdacube + - gore-and-ash-logging + - gore-and-ash-network + - gore-and-ash-sdl + - gore-and-ash-sync + - GPipe-Collada + - GPipe-Examples + - GPipe-GLFW + - GPipe-GLFW4 + - GPipe-TextureLoad + - gps + - gps2htmlReport + - GPX + - grab-form + - graflog + - grammar-combinators + - GrammarProducts + - grapefruit-examples + - grapefruit-records + - grapefruit-ui + - grapefruit-ui-gtk + - GraphHammer + - GraphHammer-examples + - graphicsFormats + - graphicstools + - graphql-client + - graph-rewriting-cl + - graph-rewriting-gl + - graph-rewriting-lambdascope + - graph-rewriting-layout + - graph-rewriting-ski + - graph-rewriting-strategies + - graph-rewriting-trs + - graph-rewriting-ww + - graphtype + - graph-visit + - greencard-lib + - gridbounds + - gridfs + - gridland + - grid-proto + - GrowlNotify + - grpc-etcd-client + - grpc-haskell + - grpc-haskell-core + - gruff + - gruff-examples + - gscholar-rss + - gsl-random-fu - gsmenu + - gstorable + - gtfs + - gtk2hs-cast-glade + - gtk2hs-cast-gnomevfs + - gtk2hs-cast-gtkglext + - gtk2hs-cast-gtksourceview2 + - Gtk2hsGenerics + - GtkGLTV + - gtkimageview + - gtkrsync + - gtk-serialized-event + - guarded-rewriting + - guess-combinator + - GuiHaskell + - GuiTV + - habit + - hablo + - hablog + - Hach + - hack2-handler-happstack-server + - hack2-handler-mongrel2-http + - hack2-handler-snap-server + - hackage2twitter + - hackage-server + - hack-contrib + - hack-contrib-press + - hack-handler-epoll + - hack-handler-evhttp + - hack-handler-fastcgi + - hack-handler-hyena + - hack-handler-simpleserver + - hackmanager + - hack-middleware-cleanpath + - hack-middleware-clientsession + - hack-middleware-jsonp + - haddock + - haddock_2_23_1 + - haddocset + - hadoop-tools + - haggis - hails-bin + - hakyll-agda + - hakyll-alectryon + - hakyll-blaze-templates + - hakyll-contrib + - hakyll-contrib-csv + - hakyll-contrib-elm + - hakyll-contrib-hyphenation + - hakyll-contrib-i18n + - hakyll-contrib-links + - hakyll-dhall + - hakyll-dir-list - hakyll-elm + - hakyll-favicon + - hakyll-filestore + - hakyll-images + - hakyll-ogmarkup + - hakyll-process + - hakyll-R + - hakyll-sass + - hakyll-series + - hakyll-shakespeare + - hakyll-shortcut-links + - hakyll-typescript + - halberd + - hall-symbols + - halma-gui + - halma-telegram-bot + - ham + - HaMinitel + - hamusic + - hans-pcap + - happlets-lib-gtk + - HAppS-Data + - happs-hsp + - happs-hsp-template + - HAppS-IxSet + - HAppS-Server + - HAppS-State + - happstack-auth + - happstack-authenticate + - happstack-contrib + - happstack-data + - happstack-dlg + - happstack-facebook + - happstack-fay + - happstack-helpers + - happstack-ixset + - happstack-jmacro + - happstack-plugins + - happstack-state + - happstack-yui + - happs-tutorial + - happybara-webkit + - haquil + - hArduino + - hardware-edsl + - HaRe + - harg + - hark + - harmony + - HarmTrace + - haroonga-httpd + - hascat + - hascat-lib + - hascat-setup + - hascat-system + - HasGP + - Hashell + - hashflare + - haskarrow + - haskdeep + - haskeem + - haskell-abci + - haskell-aliyun + - haskell-bitmex-client + - haskelldb-connect-hdbc + - haskelldb-connect-hdbc-catchio-mtl + - haskelldb-connect-hdbc-catchio-tf + - haskelldb-connect-hdbc-catchio-transformers + - haskelldb-connect-hdbc-lifted + - haskelldb-dynamic + - haskelldb-flat + - haskelldb-hdbc + - haskelldb-hdbc-mysql + - haskelldb-hdbc-odbc + - haskelldb-hdbc-postgresql + - haskelldb-hdbc-sqlite3 + - haskelldb-hsql + - haskelldb-hsql-mysql + - haskelldb-hsql-odbc + - haskelldb-hsql-postgresql + - haskelldb-hsql-sqlite3 + - haskelldb-th + - haskell-docs + - haskell-eigen-util + - haskell-ftp + - haskell-pdf-presenter + - haskell-platform-test + - haskell-reflect + - haskell-src-exts-observe + - haskell-token-utils + - haskell-tools-ast + - haskell-tools-ast-fromghc + - haskell-tools-ast-gen + - haskell-tools-ast-trf + - haskell-tools-backend-ghc + - haskell-tools-builtin-refactorings + - haskell-tools-cli + - haskell-tools-daemon + - haskell-tools-debug + - haskell-tools-demo + - haskell-tools-experimental-refactorings + - haskell-tools-prettyprint + - haskell-tools-refactor + - haskell-tools-rewrite + - haskell-tor - haskelm + - haskey-mtl + - haskgame + - hask-home + - haskoin-bitcoind + - haskoin-core + - haskoin-crypto + - haskoin-node + - haskoin-protocol + - haskoin-script + - haskoin-store + - haskoin-store-data + - haskoin-wallet + - haskoon + - haskoon-httpspec + - haskoon-salvia + - haskore-realtime + - haskore-supercollider + - haskore-synthesizer + - HaskRel + - hasktorch + - hasktorch-ffi-thc + - hasktorch-indef + - hasktorch-signatures + - hasktorch-zoo + - haskus-utils-compat + - haskus-web + - haslo + - hasloGUI + - hasparql-client + - hasql-cursor-query + - hasql-postgres + - hasql-postgres-options + - hasql-queue + - hastache-aeson + - haste-app - haste-gapi + - haste-lib + - haste-markup - haste-perch + - has-th + - Hate + - HaTeX-meta + - hatexmpp3 + - HaTeX-qq + - HaVSA + - hawitter + - Hawk + - haxy + - Hayoo + - hback + - hbayes + - hbb + - hbcd + - hbf + - hcg-minus-cairo + - hcheat + - hcheckers + - hdbi + - hdbi-conduit + - hdbi-postgresql + - hdbi-sqlite + - hdbi-tests + - hdf + - hdiff + - hdirect + - hdocs + - hdph + - heart-app + - heatitup + - heavy-logger + - heavy-logger-amazon + - heavy-logger-instances + - heavy-log-shortcuts + - hecc + - hedgehog-checkers-lens + - hedgehog-gen-json + - Hedi + - hedis-pile + - heidi + - heist-aeson + - helics + - helics-wai + - helium + - hellage + - hellnet + - hemokit + - hen + - henet + - hepevt + - her-lexer-parsec + - hermit + - hermit-syb + - herringbone + - herringbone-embed + - herringbone-wai + - hesh + - hesql + - heterolist + - hevolisa + - hevolisa-dph + - hexpat-iteratee + - hfd + - hfiar + - hgalib + - HGamer3D-API + - HGamer3D-CAudio-Binding + - HGamer3D-OIS-Binding + - hgen + - hgeometry-svg + - hgithub + - hiccup + - hierarchical-spectral-clustering + - Hieroglyph + - HiggsSet + - highjson-swagger + - highjson-th + - himpy + - hinduce-classifier + - hinduce-classifier-decisiontree + - hinduce-examples + - hint-server + - hinvaders + - hinze-streams + - hipbot + - HipmunkPlayground + - hipsql-client + - hipsql-server + - hirt + - hist-pl + - hist-pl-dawg + - hist-pl-fusion + - hist-pl-lexicon + - hist-pl-lmf + - hit + - hit-graph + - HJScript + - hjsonschema + - hjugement-cli + - hlcm + - HLearn-algebra + - HLearn-approximation + - HLearn-classification + - HLearn-datastructures + - HLearn-distributions + - hledger-api + - hls + - hly + - hmark + - hmatrix-sundials + - hmeap + - hmeap-utils + - hmep + - hmm-lapack + - hmt + - hmt-diagrams + - HNM + - hnormalise + - hob + - Hoed + - hOff-display + - hogre + - hogre-examples + - Holumbus-Distribution + - Holumbus-MapReduce + - Holumbus-Storage + - holy-project + - hommage + - HongoDB + - hood + - hoodie + - hoodle + - hoodle-builder + - hoodle-core + - hoodle-extra + - hoodle-parser + - hoodle-publish + - hoodle-render + - hoovie + - hoq + - hp2any-graph + - hp2any-manager + - hpaco + - hpaco-lib + - hpage + - hpaste + - hpc-tracer + - hPDB + - hPDB-examples - hplayground + - HPlot + - HPong + - hpqtypes-extras + - hprotoc-fork + - hps + - hps-cairo + - hpython + - hquantlib + - hranker + - HRay + - hreader + - hreader-lens + - hreq-client + - hreq-conduit + - HROOT + - HROOT-core + - HROOT-graf + - HROOT-hist + - HROOT-io + - HROOT-math + - HROOT-tree + - hs2dot + - Hs2lib + - hsautogui + - hsbackup + - hsbencher-codespeed + - hsbencher-fusion + - hs-blake2 + - hs-brotli + - hsc3-auditor + - hsc3-cairo + - hsc3-data + - hsc3-db + - hsc3-dot + - hsc3-forth + - hsc3-graphs + - hsc3-lang + - hsc3-lisp + - hsc3-plot + - hsc3-process + - hsc3-rec + - hsc3-server + - hsc3-sf-hsndfile + - hsc3-unsafe + - hsc3-utils + - hscope + - hsdev + - Hsed + - hset + - hsfacter + - hs-ffmpeg + - hs-gen-iface + - HSGEP + - HSHHelpers + - hslogstash + - hsnock + - HSoundFile + - HsParrot + - hspec-expectations-pretty + - hspec-pg-transact + - hspec-setup + - hspec-shouldbe + - hspec-test-sandbox + - hspecVariant + - hs-pkpass + - hsprocess + - hsql-mysql + - hsql-odbc + - hsql-postgresql + - hsql-sqlite3 + - hsqml-datamodel-vinyl + - hsqml-demo-morris + - hsqml-morris + - hsreadability + - hssqlppp-th + - hs-swisstable-hashtables-class + - hstar + - hstox + - hstradeking + - HStringTemplateHelpers + - hstzaar + - hsubconvert + - HsWebots + - hswip + - hsx-jmacro + - hsx-xhtml + - HTab + - hts + - http2-client-exe + - http2-client-grpc + - http-client-auth + - http-enumerator + - http-io-streams + - https-everywhere-rules + - https-everywhere-rules-raw + - httpspec + - hubris + - hugs2yc + - hulk + - hunit-gui + - hunp + - hunt-searchengine + - hunt-server + - hurdle + - husky + - huzzy + - hw-all + - hw-dsv + - hw-json + - hw-json-lens + - hw-json-simple-cursor + - hw-json-standard-cursor + - hw-kafka-avro + - hworker-ses + - hwormhole + - hws + - hw-simd-cli + - hwsl2-bytevector + - hwsl2-reducers + - hw-uri + - HXMPP + - hxmppc + - hxournal + - hxt-binary + - hxt-filter + - hxthelper + - hxweb + - hybrid + - Hydrogen + - hydrogen-cli + - hydrogen-cli-args + - hydrogen-data + - hydrogen-parsing + - hydrogen-prelude + - hydrogen-prelude-parsec + - hydrogen-syntax + - hydrogen-util + - hyena + - hylotab + - hyloutils + - hyperpublic + - ice40-prim + - ideas-math + - ideas-math-types + - ideas-statistics + - ide-backend + - ide-backend-common + - ide-backend-server + - ige-mac-integration + - ihaskell-rlangqq + - ihttp + - imap + - imbib + - imgurder + - imj-animation + - imj-base + - imj-game-hamazed + - imj-measure-stdout + - imm + - imparse + - imperative-edsl-vhdl + - importify - imprevu-happstack + - improve + - INblobs + - inch + - incremental-computing + - incremental-maps + - increments + - indentation + - indentation-parsec + - indentation-trifecta + - indexation + - IndexedList + - indieweb-algorithms + - infernu + - InfixApplicative + - inline-java + - inspector-wrecker + - instant-aeson + - instant-bytes + - instant-deepseq + - instant-hashable + - instant-zipper + - instapaper-sender + - interpolatedstring-qq + - interpolatedstring-qq-mwotton + - introduction-test + - intset + - invertible-hlist + - ion + - IORefCAS + - ip + - ipatch + - ipc - ipld-cid + - ipprint + - iptadmin + - irc-fun-bot + - irc-fun-client + - irc-fun-color + - irc-fun-messages + - iri + - ironforge + - isevaluated + - ismtp + - isobmff-builder + - isohunt + - iteratee-compress + - iteratee-mtl + - iteratee-parsec + - iteratee-stm + - iterio-server + - iterm-show-diagrams + - iter-stats + - ivor + - ivory-avr-atmega328p-registers + - ivory-backend-c + - ivory-bitdata + - ivory-eval + - ivory-examples + - ivory-hw + - ivory-opts + - ivory-quickcheck + - ivory-serialize + - ivory-stdlib + - ivy-web + - iyql + - j2hs + - jail + - java-bridge-extras + - java-character + - javaclass + - java-reflect + - javasf + - Javasf + - jmacro + - jmacro-rpc + - jmacro-rpc-happstack + - jmacro-rpc-snap + - jmonkey + - jobs-ui + - join + - jot + - JsContracts + - jsmw + - json2-hdbc + - json-ast-json-encoder + - json-autotype + - json-b + - JSONb + - JSON-Combinator + - JSON-Combinator-Examples + - json-enumerator + - JsonGrammar + - jsonifier + - json-incremental-decoder + - json-query + - jsons-to-schema + - json-syntax + - json-togo + - json-tokens + - jspath + - JunkDB-driver-gdbm + - JunkDB-driver-hashtables + - JuPyTer-notebook + - jvm + - jvm-batching + - jvm-streaming + - kafka-device + - kafka-device-glut + - kafka-device-joystick + - kafka-device-leap + - kafka-device-spacenav + - kafka-device-vrpn + - kaleidoscope + - kansas-lava + - kansas-lava-cores + - kansas-lava-papilio + - kansas-lava-shake + - karakuri + - katip-elasticsearch + - katip-rollbar + - kawaii + - keera-hails-i18n + - keera-hails-mvc-environment-gtk + - keera-hails-mvc-model-lightmodel + - keera-hails-mvc-model-protectedmodel + - keera-hails-mvc-solutions-gtk + - keera-hails-reactive-cbmvar + - keera-hails-reactive-fs + - keera-hails-reactive-gtk + - keera-hails-reactive-htmldom + - keera-hails-reactivelenses + - keera-hails-reactive-network + - keera-hails-reactive-polling + - keera-hails-reactive-wx + - keera-hails-reactive-yampa + - keera-posture + - kevin + - keysafe + - keyvaluehash + - keyword-args + - kicad-data + - KiCS + - KiCS-debugger + - KiCS-prophecy + - kif-parser + - kit + - kleene + - kmeans-par + - kmeans-vector + - knead + - knead-arithmetic + - knit-haskell + - knots + - korfu + - ks-test + - kubernetes-client + - kurita + - laborantin-hs + - labsat + - labyrinth + - labyrinth-server + - laika + - lambdabot-zulip + - lambda-calculator + - lambdacms-media + - lambdacube + - lambdacube-bullet + - lambdacube-compiler + - lambdacube-core + - lambdacube-edsl + - lambdacube-engine + - lambdacube-examples + - lambdacube-gl + - lambdacube-samples + - LambdaDesigner + - lambda-devs + - lambdaFeed + - LambdaINet + - lambdaLit + - lambda-options + - LambdaPrettyQuote + - LambdaShell + - lambdaya-bus + - lambdiff + - lang + - language-boogie + - language-eiffel + - language-kort + - language-Modula2 + - language-ninja + - language-oberon + - language-python-colour + - language-qux + - language-spelling + - lapack + - lapack-carray + - lapack-comfort-array + - lat + - latex-formulae-hakyll + - latex-formulae-pandoc + - latex-svg-hakyll + - latex-svg-pandoc + - layered-state + - layers-game + - layouting + - lazy-hash + - lazy-hash-cache + - ldapply + - LDAPv3 + - leaky + - lean + - legion + - legion-discovery + - legion-discovery-client + - legion-extra + - leksah + - leksah-server + - lens-utils + - lex-applicative + - lgtk + - lha + - lhae + - lhe + - libconfig + - libcspm + - liblastfm + - liblawless + - liblinear-enumerator + - libmolude + - libraft + - librato + - libssh2-conduit + - libxml-enumerator + - lifetimes + - lifted-base-tf + - lightning-haskell + - lightstep-haskell + - lighttpd-conf + - lighttpd-conf-qq + - linear-circuit + - linearmap-category + - linearscan-hoopl + - LinearSplit + - LinkChecker + - linkchk + - linkcore + - linux-ptrace + - lio-eci11 + - lion + - liquid-base + - liquid-bytestring + - liquid-containers + - liquid-ghc-prim + - liquidhaskell-cabal-demo + - liquid-parallel + - liquid-platform + - liquid-prelude + - liquid-vector + - listenbrainz-client + - list-t-attoparsec + - list-t-html-parser + - list-witnesses + - live-sequencer + - llvm + - llvm-analysis + - llvm-base-types + - llvm-base-util + - llvm-data-interop + - llvm-dsl + - llvm-extension + - llvm-extra + - llvm-general + - llvm-general-quote + - llvm-pretty-bc-parser + - llvm-tf + - llvm-tools + - lmonad-yesod + - localize + - local-search + - locked-poll + - log + - logging-effect-extra + - logic-classes + - LogicGrowsOnTrees + - LogicGrowsOnTrees-MPI + - LogicGrowsOnTrees-network + - LogicGrowsOnTrees-processes + - log-postgres + - log-utils + - lojban + - lojysamban + - lol-apps + - lol-benches + - lol-cpp + - loli + - lol-repa + - lol-tests + - lol-typing + - longshot + - loop-effin + - lorentz + - lostcities + - loup + - LslPlus + - ls-usb + - lsystem + - lti13 + - luachunk + - lucid-colonnade + - lucienne + - Lucu + - luhn + - lui + - luminance-samples + - lvish + - Lykah + - lz4-conduit + - lzma-enumerator + - macbeth-lib + - machines-amazonka + - macosx-make-standalone + - magicbane + - magico + - magic-wormhole + - mahoro + - maid + - mailgun + - mail-pool + - majordomo + - majority + - manatee + - manatee-anything + - manatee-core + - manatee-curl + - manatee-editor + - manatee-filemanager + - manatee-imageviewer + - manatee-ircclient + - manatee-mplayer + - manatee-pdfviewer + - manatee-processmanager + - manatee-template + - manatee-terminal + - manatee-welcome + - manifold-random + - manifolds + - marionetta + - markdown2svg + - markdown-pap + - markov-processes + - markup + - marmalade-upload + - marquise + - marvin + - masakazu-bot + - master-plan + - matchers + - mathblog + - mathlink + - math-programming-glpk + - math-programming-tests + - matsuri + - maxent + - maxent-learner-hw-gui + - maxsharing + - MaybeT-transformers + - MC-Fold-DP + - mcmc + - mcmc-samplers + - mealy + - mediabus-fdk-aac + - mediabus-rtp + - mellon-gpio + - mellon-web + - memcache-conduit + - mergeful-persistent + - mergeless-persistent + - merkle-patricia-db + - MetaObject + - meta-par-accelerate + - metaplug + - metar + - metar-http + - Metrics + - metronome + - MFlow + - Mhailist + - Michelangelo + - microformats2-parser + - microformats2-types + - micro-gateway + - MicrosoftTranslator + - midimory + - mighttpd + - minecraft-data + - minesweeper + - mini-egison + - miniforth + - minilight-lua + - minimung + - minioperational + - MIP-glpk + - miss + - MissingPy + - missing-py2 + - miss-porcelain + - mixed-strategies + - mkbndl + - mkcabal + - mlist + - mmark-cli + - mmark-ext + - mmtl-base + - moan + - modify-fasta + - modsplit + - modularity + - modular-prelude-classy + - modulo + - mole + - mollie-api-haskell + - MonadCatchIO-mtl + - MonadCatchIO-mtl-foreign + - MonadCatchIO-transformers-foreign + - monad-exception + - monadiccp-gecode + - MonadLab + - monad-state + - monad-stlike-stm + - monarch + - Monaris + - Monatron-IO + - monetdb-mapi + - mongoDB + - mongodb-queue + - mongrel2-handler + - monky + - Monocle + - monte-carlo + - moo + - morley + - morloc + - morphisms-functors-inventory + - mosaico-lib + - motor-diagrams + - mp + - mp3decoder + - mpdmate + - mprelude + - mpretty + - mprover + - mps + - mptcp-pm + - msgpack-aeson + - msgpack-idl + - msgpack-rpc + - msgpack-rpc-conduit + - MSQueue + - mtgoxapi + - MuCheck-Hspec + - MuCheck-HUnit + - MuCheck-QuickCheck + - MuCheck-SmallCheck + - mu-grpc-client + - mu-grpc-server - multibase + - multi-cabal + - multifocal - multihash-serialise + - multilinear-io + - multiplicity + - multirec-alt-deriver + - multirec-binary + - multisetrewrite + - murder + - murmurhash3 + - music-graphics + - music-parts + - music-pitch + - music-preludes + - music-score + - music-sibelius + - music-suite + - musicxml2 + - mutable-iter + - MutationOrder + - mute-unmute + - mu-tracing + - mvclient + - mvc-updates + - mxnet-dataiter + - mxnet-examples + - mxnet-nn + - mysnapsession-example + - mysql-haskell-openssl + - mysql-simple-typed + - myTestlll + - mywatch + - n2o-web + - nakadi-client + - nanovg-simple + - NaperianNetCDF + - nats-queue + - natural-number + - NearContextAlgebra + - nemesis-titan + - nerf + - nero-wai + - nero-warp + - nested-routes + - netcore + - netlines + - net-spider-cli + - net-spider-pangraph + - net-spider-rpl + - net-spider-rpl-cli + - netstring-enumerator + - nettle-frp + - nettle-netkit + - nettle-openflow + - network-anonymous-i2p + - network-anonymous-tor + - network-connection + - network-enumerator + - network-hans + - network-interfacerequest + - network-messagepack-rpc-websocket + - network-minihttp + - network-netpacket + - network-pgi + - network-protocol-xmpp + - network-rpca + - network-stream + - network-topic-models + - network-websocket + - newsletter-mailgun + - ngrams-loader + - ngx-export-tools-extra + - nikepub + - Ninjas + - nirum + - nlp-scores-scripts + - Nomyx - nomyx-api - nomyx-core + - Nomyx-Core - nomyx-language + - Nomyx-Language - nomyx-library + - Nomyx-Rules - nomyx-server + - Nomyx-Web + - NonEmptyList + - NoSlow + - notmuch-haskell + - notmuch-web + - numerical + - numeric-ode + - numhask-hedgehog + - numhask-histogram + - numhask-range + - numhask-test + - Nussinov78 + - NXT + - nymphaea + - obd + - obdd + - oberon0 + - obj + - objectid + - ochan + - octane + - octohat + - octopus + - oculus + - odd-jobs + - off-simple + - ohloh-hs + - ois-input-manager + - olwrapper + - one-liner_2_0 + - online + - online-csv + - OnRmt + - open-adt-tutorial + - OpenAFP-Utils + - OpenGLCheck + - openpgp-crypto-api + - OpenSCAD + - openssh-github-keys + - opentracing-jaeger + - opentracing-zipkin-v1 + - open-union + - OpenVG + - optima-for-hasql + - optimal-blocks + - optimusprime + - orchid + - orchid-demo + - order-maintenance + - org-mode-lucid + - OSM + - osm-download + - otp-authenticator + - padKONTROL + - PageIO + - pairing + - panda + - pandoc-japanese-filters + - pan-os-syslog + - papa + - papa-base + - papa-base-implement + - papa-export + - papa-implement + - papa-semigroupoids + - paprika + - Paraiso + - Parallel-Arrows-Eden + - parco-attoparsec + - parconc-examples + - parco-parsec + - parquet-hs + - parse-help + - parsestar + - partial-lens + - patch-image + - patterns + - pcap-enumerator + - pcapng + - pcf + - pcf-font-embed + - PCLT-DB + - pdf-slave + - peakachu + - pec + - pell + - penny + - penny-bin + - penny-lib + - penrose + - peparser + - perdure + - perf-analysis + - perfecthash + - periodic-client + - periodic-client-exe + - periodic-server + - perm + - PermuteEffects + - persistent-audit + - persistent-hssqlppp + - persistent-map + - persistent-mongoDB + - persona-idp + - peyotls + - peyotls-codec + - pgsql-simple + - pg-transact + - phonetic-languages-examples + - phonetic-languages-simplified-lists-examples + - phooey + - photoname + - pianola + - pier + - ping + - pinpon + - pipe-enumerator + - pipes-attoparsec-streaming + - pipes-brotli + - pipes-cacophony + - pipes-cereal-plus + - pipes-conduit + - pipes-courier + - pipes-extra + - pipes-files + - pipes-illumina + - pipes-key-value-csv + - pipes-mongodb + - pipes-p2p + - pipes-p2p-examples + - pisigma + - pitchtrack + - pkgtreediff + - planet-mitchell + - plocketed + - Plot-ho-matic + - PlslTools + - png-file + - pngload + - pocket-dns + - pointless-lenses + - pointless-rewrite + - point-octree + - poke + - polh-lexicon + - polydata + - polysemy-extra + - polysemy-fskvstore + - polysemy-kvstore-jsonfile + - polysemy-log-co + - polysemy-methodology + - polysemy-methodology-composite + - polysemy-optics + - polysemy-path + - polysemy-RandomFu + - polysemy-vinyl + - polyseq + - polytypeable-utils + - pomodoro + - pontarius-mediaserver + - popenhs + - porcupine-core + - porcupine-http + - porcupine-s3 + - ports + - poseidon + - poseidon-postgis + - postgresql-query + - postgresql-simple-queue + - postgresql-simple-typed + - postgresql-tx-query + - postgresql-tx-squeal + - postgresql-tx-squeal-compat-simple + - postmark + - potoki + - potoki-cereal + - potoki-conduit + - potoki-hasql + - potoki-zlib + - powerqueue-sqs + - pqueue-mtl + - practice-room + - prednote-test + - pred-set + - pred-trie + - presto-hdbc + - preview + - primula-board + - primula-bot + - Printf-TH + - ProbabilityMonads + - proc + - process-iterio + - process-progress + - process-qq + - process-streaming + - procrastinating-structure + - producer + - prof2dot + - progressbar + - project-m36 + - prologue + - prolude + - prometheus-effect + - propane + - proplang + - prosidyc + - proto3-suite + - protobuf-native + - protocol-buffers-descriptor-fork + - proto-lens-descriptors + - proton + - psc-ide + - puffytools + - Pugs + - pugs-compat + - pugs-hsregex + - punkt + - Pup-Events + - Pup-Events-Demo + - puppetresources + - pure-cdb + - pure-priority-queue-tests + - purescript + - purescript-iso + - purescript-tsd-gen + - push-notify + - push-notify-apn + - push-notify-ccs + - push-notify-general + - puzzle-draw + - puzzle-draw-cmdline + - pvd + - qd-vec + - qhs + - qr-repa + - quantum-random + - Quelea + - queryparser + - queryparser-demo + - queryparser-hive + - queryparser-presto + - queryparser-vertica + - questioner + - queuelike + - quickbench + - quickcheck-poly + - quickcheck-regex + - quickcheck-relaxng + - quickcheck-state-machine + - quickcheck-state-machine-distributed + - quicktest + - quipper + - quipper-algorithms + - quipper-all + - quipper-cabal + - quipper-demos + - quipper-language + - quipper-libraries + - quipper-rendering + - quipper-tools + - quiver-binary + - quiver-bytestring + - quiver-cell + - quiver-csv + - quiver-enumerator + - quiver-groups + - quiver-http + - quiver-instances + - quiver-interleave + - quiver-sort + - qux + - rail-compiler-editor + - rails-session + - rainbow-tests + - raketka + - rallod + - random-effin + - random-hypergeometric + - range-space + - Ranka + - rasa + - rasa-example-config + - rasa-ext-bufs + - rasa-ext-cmd + - rasa-ext-cursors + - rasa-ext-files + - rasa-ext-logger + - rasa-ext-slate + - rasa-ext-status-bar + - rasa-ext-style + - rasa-ext-views + - rasa-ext-vim + - rating-chgk-info + - raw-feldspar + - rawr + - razom-text-util + - rbr + - rc + - rdioh + - react-flux-servant + - reactive + - reactive-balsa + - reactive-banana-automation + - reactive-banana-bunch + - reactive-banana-gi-gtk + - reactive-banana-sdl + - reactive-banana-sdl2 + - reactive-banana-threepenny + - reactive-banana-wx + - reactive-fieldtrip + - reactive-glut + - reactive-jack + - reactive-midyim + - reactor + - readline-statevar + - readpyc + - reanimate + - record-aeson + - record-gl + - record-preprocessor + - records-th + - record-syntax + - reddit + - redHandlers + - reduce-equations + - refh + - reflex-animation + - reflex-backend-socket + - reflex-backend-wai + - reflex-dom-colonnade + - reflex-ghci + - reflex-gloss-scene + - reflex-process + - refurb + - reg-alloc-graph-color + - regex-deriv + - regex-genex + - regex-pcre-text + - regex-pderiv + - regexp-tries + - regex-xmlschema + - regional-pointers + - regions-monadsfd + - regions-monadstf + - regions-mtl + - registry-hedgehog + - regular-extras + - regular-web + - regular-xmlpickler + - reheat + - relative-date + - remote-json + - remote-json-client + - remote-json-server + - remotion + - repa-array + - repa-convert + - repa-examples + - repa-flow + - repa-plugin + - repa-stream + - repa-v4l2 + - replicant + - repr + - representable-tries + - req-oauth2 + - resistor-cube + - resource-pool-catchio + - resource-simple + - respond + - rest-client + - rest-core + - rest-example + - restful-snap + - rest-gen + - rest-happstack + - RESTng + - restricted-workers + - rest-snap + - rest-stringmap + - rest-types + - rest-wai + - rethinkdb-model + - rewrite + - rewriting + - rezoom + - rfc + - rfc-env + - rfc-http-client + - rfc-psql + - rfc-redis + - rfc-servant + - rhythm-game-tutorial + - rib + - ridley-extras + - rio-process-pool + - riot + - ripple + - risc-v + - rivet + - Rlang-QQ + - rlwe-challenges + - rmonad + - RMP + - RNAdesign + - RNAdraw + - RNAFold + - RNAFoldProgs + - RNAlien + - RNAwolf + - rncryptor + - rob + - robot + - roc-cluster-demo + - rock + - roguestar-engine + - roguestar-gl + - roguestar-glut + - rollbar-cli + - rollbar-wai + - rollbar-yesod + - RollingDirectory + - ron-schema + - ron-storage + - rose-trie + - roshask + - rosmsg-bin + - rounded-hw + - roundtrip-xml + - route-generator + - route-planning + - rpc + - rpf + - rsagl + - rsagl-frp + - rsagl-math + - rtcm + - ruler + - ruler-core + - runtime-arbitrary + - S3 + - safe-numeric + - safer-file-handles + - safer-file-handles-bytestring + - safer-file-handles-text + - sai-shape-syb + - sak + - saltine-quickcheck + - salvia + - salvia-demo + - salvia-extras + - salvia-sessions + - salvia-websocket + - samtools + - samtools-conduit + - samtools-enumerator + - samtools-iteratee + - sarsi + - sasl + - satchmo-backends + - satchmo-examples + - satchmo-funsat + - satchmo-minisat + - satchmo-toysat + - sat-micro-hs + - SBench + - sc2hs + - sc2-lowlevel + - sc2-support + - sc3-rdu + - scalable-server + - SCalendar + - scalpel-search + - scalp-webhooks + - scan-vector-machine + - schema + - schematic + - scholdoc + - scholdoc-citeproc + - scholdoc-texmath + - scientific-notation + - SciFlow + - SciFlow-drmaa + - scion + - scion-browser + - scope + - scope-cairo + - scotty-hastache + - scp-streams + - scrabble-bot + - scrapbook + - SCRIPTWriter + - Scurry + - sde-solver + - seakale-postgresql + - seakale-tests + - secrm + - sednaDBXML + - seitz-symbol + - SelectSequencesFromMSA + - selenium-server + - self-extract + - Semantique + - semi-iso + - semiring + - semiring-num + - sensenet + - sentence-jp + - seonbi + - seqaid + - seqloc + - seqloc-datafiles + - sequor + - serpentine + - serv + - servant-auth-token + - servant-auth-token-acid + - servant-auth-token-leveldb + - servant-auth-token-persistent + - servant-auth-token-rocksdb + - servant-auth-wordpress + - servant-cli + - servant-client-namedargs + - servant-csharp + - servant-db-postgresql + - servant-ede + - servant-event-stream + - servant-examples + - servant-http2-client + - servant-matrix-param + - servant-polysemy + - servant-postgresql + - servant-server-namedargs + - servant-snap + - servant-streaming-client + - servant-streaming-docs + - servant-streaming-server + - servant-swagger-tags + - servant-waargonaut + - servant-zeppelin-client + - servant-zeppelin-server + - servant-zeppelin-swagger + - serv-wai + - sessiontypes-distributed + - setdown + - s-expression + - SFML-control + - SFont + - SGdemo + - sgf + - sgrep + - sha1 + - shake-minify-css + - shaker + - shapefile + - shapely-data + - shelduck + - Shellac-compatline + - Shellac-editline + - Shellac-haskeline + - Shellac-readline + - shellmate-extras - shine-varying + - ShortestPathProblems + - showdown + - Shpadoinkle-backend-pardiff + - Shpadoinkle-backend-static + - Shpadoinkle-developer-tools + - Shpadoinkle-disembodied + - Shpadoinkle-examples + - Shpadoinkle-html + - Shpadoinkle-router + - Shpadoinkle-template + - Shpadoinkle-widgets + - shpider + - shuffle + - sibe + - si-clock + - sigma-ij + - signable + - signals + - signature + - signify-hs + - silvi + - simgi + - simple-c-value + - simple-firewire + - SimpleGL + - simpleirc-lens + - SimpleLog + - simple-nix + - simple-pascal + - SimpleServer + - simseq + - singleton-nats_0_4_6 + - singletons-base + - siphon + - siren-json + - sirkel + - skeleton + - skeletons + - skylark-client + - slidemews + - slip32 + - small-bytearray-builder + - smallstring + - smartword + - smcdel + - smith + - smith-cli + - smith-client + - Smooth + - smtlib2-debug + - smtlib2-pipe + - smtlib2-quickcheck + - smtlib2-timing + - smtp2mta + - snap-auth-cli - snap-elm + - snap-extras + - snaplet-actionlog + - snaplet-auth-acid + - snaplet-coffee + - snaplet-environments + - snaplet-hasql + - snaplet-haxl + - snaplet-hdbc - snaplet-lss + - snaplet-mandrill + - snaplet-mongoDB + - snaplet-mongodb-minimalistic + - snaplet-mysql-simple + - snaplet-oauth + - snaplet-postmark + - snaplet-recaptcha + - snaplet-redson + - snaplet-rest + - snaplet-riak + - snaplet-sedna + - snaplet-sqlite-simple-jwt-auth + - snaplet-stripe + - snaplet-tasks + - snaplet-wordpress + - snappy-iteratee + - snap-utils + - sndfile-enumerators - sneathlane-haste + - snm + - snmp + - snowflake-core + - snowflake-server + - snow-white + - Snusmumrik + - SoccerFun + - SoccerFunGL + - sock2stream + - sockets + - solga-swagger + - solr + - souffle-dsl + - sounddelay + - soundgen + - source-code-server + - sparkle + - sparrow + - sparsebit + - sparser + - spata + - specialize-th + - species + - spectral-clustering + - speculation-transformers + - speechmatics + - spelling-suggest + - sphero + - sphinx-cli + - spice + - SpinCounter + - spline3 + - splines + - Spock-auth + - Spock-lucid + - Spock-worker + - sprinkles + - sproxy + - sproxy2 + - sproxy-web + - sqlite-simple-typed + - sql-simple-mysql + - sql-simple-pool + - sql-simple-postgresql + - sql-simple-sqlite + - sr-extra + - sscgi + - sshd-lint + - sssp + - sstable + - stable-tree + - stackage + - stackage2nix + - stackage-build-plan + - stackage-cabal + - stackage-query + - stackage-sandbox + - stackage-setup + - stackage-upload + - stack-hpc-coveralls + - stack-network + - stack-run-auto + - starrover2 + - stateful-mtl + - static-closure + - statsdi + - STLinkUSB + - STM32-Zombie + - stmcontrol + - StockholmAlignment + - storablevector-streamfusion + - Strafunski-Sdf2Haskell + - stratux + - stratux-demo + - stratux-http + - stratux-websockets + - streaming-base64 + - streaming-brotli + - streaming-concurrency + - streaming-fft + - streaming-process + - streaming-sort + - strelka + - strict-data + - string-typelits + - stripe-scotty + - structural-induction + - structured-mongoDB + - stunts + - stutter + - subhask + - substring-parser + - summoner-tui + - sump + - sunroof-examples + - sunroof-server + - supercollider-ht + - supercollider-midi + - superconstraints + - sv + - sv-cassava + - svg2q + - SVG2Q + - svgone + - sv-svfactor + - swapper + - swearjure + - sweet-egison + - switch + - sylvia + - symantic-atom + - symantic-lib + - symbiote + - symmetry-operations-symbols + - sym-plot + - syncthing-hs + - syntax + - syntax-attoparsec + - syntax-example + - syntax-example-json + - SyntaxMacros + - syntaxnet-haskell + - syntax-pretty + - syntax-printer + - synthesizer-llvm + - systemstats + - t3-client + - ta + - taffybar + - tagged-list + - tagged-th + - tagsoup-navigate + - tagstew + - tag-stream + - tal + - tamarin-prover + - tamarin-prover-term + - tamarin-prover-theory + - target + - task + - task-distribution + - tasty-bdd + - tasty-groundhog-converters + - tasty-integrate + - tasty-jenkins-xml + - tasty-laws + - tasty-lens + - tateti-tateti + - Taxonomy + - TaxonomyTools + - tbox + - tccli + - tdd-util + - tdlib + - tdlib-gen + - tdlib-types + - TeaHS + - techlab + - telegram-bot + - telegram-raw-api + - telegram-types + - tensorflow-core-ops + - tensorflow-logging + - tensorflow-ops + - termbox-banana + - terminal-text + - terrahs + - testbench + - test-framework-sandbox + - test-sandbox-compose + - test-sandbox-hunit + - test-sandbox-quickcheck + - test-simple + - TeX-my-math + - textmatetags + - text-plus + - text-trie + - text-xml-generic + - th-alpha + - th-context + - theatre + - theoremquest-client + - thimk + - th-instances + - th-typegraph + - thumbnail-polish + - tickle + - tic-tac-toe + - tidal-serial + - tighttp + - timberc + - time-exts + - time-http + - time-io-access + - timeprint + - time-warp + - timezone-unix + - tinyMesh + - tip-haskell-frontend + - tip-lib + - titan + - tls-extra + - tn + - toboggan + - todos + - toktok + - too-many-cells + - top + - topkata + - to-string-instances + - total-map + - toxcore + - toxcore-c + - toysolver + - tpar + - tpb + - trajectory + - transf + - transfer-db + - transformations + - transformers-convert + - transient-universe-tls + - trasa + - trasa-client + - trasa-extra + - trasa-form + - trasa-reflex + - trasa-server + - trasa-th + - TreeCounter + - treemap-html-tools - treersec - + - Treiber + - trek-app + - trek-db + - triangulation + - TrieMap + - tries + - trimpolya + - truelevel + - trurl + - tsession-happstack + - tsweb + - tuntap-simple + - tup-functor + - tuple-hlist + - tuple-morph + - tuple-ops + - turingMachine + - twentefp-eventloop-graphics + - twentefp-eventloop-trees + - twentefp-graphs + - twentefp-rosetree + - twentefp-trees + - twentyseven + - twidge + - twilight-stm + - twill + - twitter + - twitter-enumerator + - type-assertions + - type-cache + - type-cereal + - TypeClass + - type-combinators-quote + - type-combinators-singletons + - typed-encoding-encoding + - type-digits + - typed-spreadsheet + - typed-streams + - TypeIlluminator + - typelevel + - typelevel-rewrite-rules + - type-ord + - type-ord-spine-cereal + - typescript-docs + - type-sets + - type-structure + - type-sub-th + - typson-beam + - typson-esqueleto + - typson-selda + - u2f + - uber + - ucam-webauth + - uhc-light + - uhc-util + - UMM + - unagi-bloomfilter + - unbound + - unicode-normalization + - uni-events + - uniformBase + - uniform-io + - uni-graphs + - uni-htk + - uni-posixutil + - uniqueness-periods-vector-examples + - uni-reactor + - uni-uDrawGraph + - universe-th + - unix-fcntl + - unix-simple + - unpacked-maybe-numeric + - unpacked-these + - unpacked-validation + - unparse-attoparsec + - unscramble + - up + - urbit-airlock + - urbit-api + - urbit-hob + - ureader + - urembed + - uri-enumerator + - uri-enumerator-file + - url-bytes + - UrlDisp + - urlpath + - URLT + - usb + - usb-enumerator + - usb-hid + - usb-id-database + - usb-iteratee + - usb-safe + - util-exception + - util-primitive-control + - uu-cco-examples + - uu-cco-hut-parsing + - uu-cco-uu-parsinglib + - uuid-bytes + - uuid-crypto + - uvector-algorithms + - v4l2 + - v4l2-examples + - vabal + - vacuum-cairo + - vacuum-graphviz + - vacuum-opengl + - vacuum-ubigraph + - variable-precision + - vcache-trie + - vcard + - vcsgui + - vect-floating-accelerate + - vector-endian + - vector-instances-collections + - vector-text + - venzone + - verdict-json + - versioning-servant + - vflow-types + - vfr-waypoints + - ViennaRNA-extras + - vigilance + - vinyl-operational + - vision + - visual-graphrewrite + - vocoder + - vocoder-audio + - vocoder-conduit + - vocoder-dunai + - voicebase + - vty-ui-extras + - waargonaut + - wahsp + - wai-cli + - wai-devel + - wai-dispatch + - wai-handler-snap + - wai-hastache + - wai-middleware-brotli + - wai-middleware-cache + - wai-middleware-cache-redis + - wai-middleware-consul + - wai-middleware-content-type + - wai-middleware-rollbar + - wai-middleware-route + - wai-session-tokyocabinet + - wai-thrift + - waldo + - warped + - WashNGo + - WAVE + - WaveFront + - wavesurfer + - wavy + - web3 + - webapi + - WebBits-Html + - WebBits-multiplate + - WebCont + - webcrank-wai + - webdriver-w3c + - web-mongrel2 + - web-page + - web-rep + - web-routes-regular + - web-routing + - webserver + - WEditorBrick + - WEditorHyphen + - weighted + - werewolf-slack + - what4 + - wheb-mongo + - wheb-redis + - wheb-strapped + - whitespace + - wide-word-instances + - wikipedia4epub + - windowslive + - winio + - WL500gPControl + - wlc-hs + - wl-pprint-ansiterm + - wl-pprint-terminfo + - wobsurv + - wolf + - WordAlignment + - workflow-extra + - workflow-pure + - workflow-types + - wraxml + - wrecker + - wrecker-ui + - wright + - writer-cps-full + - ws + - wss-client + - wtk-gtk + - wumpus-basic + - wumpus-drawing + - wumpus-microprint + - wumpus-tree + - WURFL + - wu-wei + - wx + - wxAsteroids + - wxc + - wxcore + - WXDiffCtrl + - wxFruit + - WxGeneric + - wxhnotepad + - wxSimpleCanvas + - wxturtle + - wyvern + - xdcc + - xhb-atom-cache + - xhb-ewmh + - XML + - xml2x + - xml-catalog + - xml-enumerator + - xml-enumerator-combinators + - xml-monad + - xml-pipe + - xml-push + - xml-query-xml-conduit + - xml-query-xml-types + - xmltv + - xml-tydom-conduit + - xmms2-client + - xmms2-client-glib + - xmonad-contrib-bluetilebranch + - xmpipe + - XMPP + - xournal-builder + - xournal-convert + - xournal-parser + - xournal-render + - XSaiga + - xtc + - Yablog + - YACPong + - yajl-enumerator + - yam + - yam-datasource + - yam-logger + - yaml-rpc-scotty + - yaml-rpc-snap + - yaml-unscrambler + - yam-redis + - yam-transaction + - yam-transaction-odbc + - yam-web + - yarr-image-io + - yavie + - ycextra + - yeamer + - yeshql + - yesod-articles + - yesod-auth-ldap + - yesod-auth-lti13 + - yesod-colonnade + - yesod-continuations + - yesod-examples + - yesod-ip + - yesod-mangopay + - yesod-paypal-rest + - yesod-platform + - yesod-purescript + - yesod-raml-bin + - yesod-raml-docs + - yesod-raml-mock + - yesod-routes-typescript + - yesod-session-redis + - yjftp + - yjftp-libs + - Yogurt + - Yogurt-Standalone + - yoko + - york-lava + - yql + - yu-auth + - yu-core + - yu-launch + - yu-tool + - yuuko + - yu-utils + - zasni-gerna + - zephyr + - zerobin + - zeromq3-conduit + - zeromq3-haskell + - zeroth + - zifter-cabal + - zifter-git + - zifter-google-java-format + - zifter-hindent + - zifter-hlint + - zifter-stack + - Z-IO + - zipper + - zippo + - ziptastic-client + - zlib-enum + - zmcat + - Z-MessagePack + - zoom-cache + - zoom-cache-pcm + - zoom-cache-sndfile + - zoovisitor + - zuramaru + - Z-YAML diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 4dd57eb6edf..a7f5d975a6c 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -28,6 +28,8 @@ self: { ]; description = "3D model parsers"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "4Blocks" = callPackage @@ -43,6 +45,7 @@ self: { ]; description = "A tetris-like game (works with GHC 6.8.3 and Gtk2hs 0.9.13)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AAI" = callPackage @@ -54,6 +57,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Abstract Application Interface"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ABList" = callPackage @@ -104,6 +109,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Detect which OS you're running on"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AC-Colour" = callPackage @@ -126,6 +133,8 @@ self: { libraryHaskellDepends = [ array base gtk ]; description = "GTK+ pixel plotting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AC-HalfInteger" = callPackage @@ -139,6 +148,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Efficient half-integer type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AC-MiniTest" = callPackage @@ -152,6 +163,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A simple test framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AC-PPM" = callPackage @@ -187,6 +200,8 @@ self: { libraryHaskellDepends = [ ansi-terminal base ]; description = "Trivial wrapper over ansi-terminal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AC-VanillaArray" = callPackage @@ -198,6 +213,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Immutable arrays with plain integer indicies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AC-Vector" = callPackage @@ -211,6 +228,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Efficient geometric vectors and transformations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AC-Vector-Fancy" = callPackage @@ -222,6 +241,7 @@ self: { libraryHaskellDepends = [ AC-Angle AC-Vector base ]; description = "Fancy type-system stuff for AC-Vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ACME" = callPackage @@ -237,6 +257,8 @@ self: { ]; description = "Essential features"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ADPfusion" = callPackage @@ -264,6 +286,8 @@ self: { ]; description = "Efficient, high-level dynamic programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ADPfusionForest" = callPackage @@ -290,6 +314,7 @@ self: { benchmarkHaskellDepends = [ base criterion ForestStructures ]; description = "Dynamic programming on tree and forest structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ADPfusionSet" = callPackage @@ -314,6 +339,7 @@ self: { ]; description = "Dynamic programming for Set data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AERN-Basics" = callPackage @@ -333,6 +359,8 @@ self: { executableHaskellDepends = [ base containers directory ]; description = "foundational type classes for approximating exact real numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AERN-Net" = callPackage @@ -348,6 +376,7 @@ self: { ]; description = "Compositional lazy dataflow networks for exact real number computation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AERN-Real" = callPackage @@ -364,6 +393,7 @@ self: { ]; description = "arbitrary precision real interval arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AERN-Real-Double" = callPackage @@ -387,6 +417,7 @@ self: { ]; description = "arbitrary precision real interval arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AERN-Real-Interval" = callPackage @@ -403,6 +434,7 @@ self: { ]; description = "arbitrary precision real interval arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AERN-RnToRm" = callPackage @@ -419,6 +451,7 @@ self: { ]; description = "polynomial function enclosures (PFEs) approximating exact real functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AERN-RnToRm-Plot" = callPackage @@ -436,6 +469,7 @@ self: { ]; description = "GL plotting of polynomial function enclosures (PFEs)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AES" = callPackage @@ -477,6 +511,8 @@ self: { ]; description = "A library for writing AGI scripts for Asterisk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ALUT" = callPackage @@ -506,6 +542,8 @@ self: { ]; description = "Low-level bindings for Asterisk Manager Interface (AMI)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ANum" = callPackage @@ -568,6 +606,7 @@ self: { libraryHaskellDepends = [ AbortT-transformers base monads-tf ]; description = "Monads-tf instances for the AbortT monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AbortT-mtl" = callPackage @@ -579,6 +618,7 @@ self: { libraryHaskellDepends = [ AbortT-transformers base mtl ]; description = "mtl instances for the AbortT monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AbortT-transformers" = callPackage @@ -596,6 +636,8 @@ self: { ]; description = "A monad and monadic transformer providing \"abort\" functionality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ActionKid" = callPackage @@ -619,6 +661,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "An easy-to-use video game framework for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Adaptive" = callPackage @@ -634,6 +678,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Library for incremental computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Adaptive-Blaisorblade" = callPackage @@ -648,6 +694,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Library for incremental computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Advgame" = callPackage @@ -661,6 +709,7 @@ self: { executableHaskellDepends = [ base haskell98 mtl ]; description = "Lisperati's adventure game in Lisp translated to Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Advise-me" = callPackage @@ -690,6 +739,7 @@ self: { ]; description = "Assessment services for the Advise-Me project"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "AesonBson" = callPackage @@ -726,6 +776,8 @@ self: { ]; description = "Generator-generator for QuickCheck"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Agda" = callPackage @@ -788,6 +840,8 @@ self: { ]; description = "Aho-Corasick string matching algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AlanDeniseEricLauren" = callPackage @@ -809,6 +863,8 @@ self: { benchmarkHaskellDepends = [ base containers criterion ]; description = "Find the minimal subset/submap satisfying some property"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AlgoRhythm" = callPackage @@ -837,6 +893,7 @@ self: { ]; description = "Algorithmic music composition"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AlgorithmW" = callPackage @@ -850,6 +907,8 @@ self: { executableHaskellDepends = [ base containers mtl pretty ]; description = "Example implementation of Algorithm W for Hindley-Milner type inference"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AlignmentAlgorithms" = callPackage @@ -866,6 +925,7 @@ self: { ]; description = "Collection of alignment algorithms"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Allure" = callPackage @@ -913,6 +973,7 @@ self: { ]; description = "Android view hierarchy importer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Animas" = callPackage @@ -924,6 +985,8 @@ self: { libraryHaskellDepends = [ base random ]; description = "Updated version of Yampa: a library for programming hybrid systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Annotations" = callPackage @@ -936,6 +999,7 @@ self: { testHaskellDepends = [ base mtl multirec parsec ]; description = "Constructing, analyzing and destructing annotated trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Ansi2Html" = callPackage @@ -981,6 +1045,7 @@ self: { executableHaskellDepends = [ base ]; description = "Library for Apple Push Notification Service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "AppleScript" = callPackage @@ -992,6 +1057,8 @@ self: { doHaddock = false; description = "Call AppleScript from Haskell, and then call back into Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ApproxFun-hs" = callPackage @@ -1003,6 +1070,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Function approximation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ArrayRef" = callPackage @@ -1014,6 +1083,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Unboxed references, dynamic arrays and more"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ArrowVHDL" = callPackage @@ -1025,6 +1096,8 @@ self: { libraryHaskellDepends = [ base process ]; description = "A library to generate Netlist code from Arrow descriptions"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AspectAG" = callPackage @@ -1060,6 +1133,8 @@ self: { ]; description = "Fast Bencode encoding and parsing library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AttoJson" = callPackage @@ -1076,6 +1151,7 @@ self: { ]; description = "Simple lightweight JSON parser, generator & manipulator based on ByteString"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Attrac" = callPackage @@ -1091,6 +1167,8 @@ self: { ]; description = "Visualisation of Strange Attractors in 3-Dimensions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Aurochs" = callPackage @@ -1104,6 +1182,8 @@ self: { executableHaskellDepends = [ base containers parsec pretty ]; description = "Yet another parser generator for C/C++"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "AutoForms" = callPackage @@ -1119,6 +1199,7 @@ self: { ]; description = "GUI library based upon generic programming (SYB3)"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "AvlTree" = callPackage @@ -1130,6 +1211,7 @@ self: { libraryHaskellDepends = [ base COrdering ]; description = "Balanced binary trees using the AVL algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BASIC" = callPackage @@ -1141,6 +1223,7 @@ self: { libraryHaskellDepends = [ base containers llvm random timeit ]; description = "Embedded BASIC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BCMtools" = callPackage @@ -1167,6 +1250,8 @@ self: { ]; description = "Big Contact Map Tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BNFC" = callPackage @@ -1226,6 +1311,8 @@ self: { libraryHaskellDepends = [ base cairo containers mtl ]; description = "Tools for self-assembly"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Bang" = callPackage @@ -1241,6 +1328,8 @@ self: { ]; description = "A Drum Machine DSL for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Barracuda" = callPackage @@ -1269,6 +1358,7 @@ self: { ]; description = "An ad-hoc P2P chat program"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Befunge93" = callPackage @@ -1282,6 +1372,8 @@ self: { executableHaskellDepends = [ array base mtl random ]; description = "An interpreter for the Befunge-93 Programming Language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BenchmarkHistory" = callPackage @@ -1299,6 +1391,8 @@ self: { ]; description = "Benchmark functions with history"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BerkeleyDB" = callPackage @@ -1325,6 +1419,8 @@ self: { librarySystemDepends = [ db dbxml xercesc xqilla ]; description = "Berkeley DB XML binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) db; inherit (pkgs) dbxml; inherit (pkgs) xercesc; inherit (pkgs) xqilla;}; @@ -1337,6 +1433,7 @@ self: { libraryHaskellDepends = [ base besout ]; description = "Factorization of polynomials over finite field"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BiGUL" = callPackage @@ -1351,6 +1448,8 @@ self: { ]; description = "The Bidirectional Generic Update Language"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BigPixel" = callPackage @@ -1382,6 +1481,8 @@ self: { ]; description = "Source-to-source plugin for enhancing EDSLs with static annotations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Binpack" = callPackage @@ -1410,6 +1511,7 @@ self: { ]; description = "Libary for Hidden Markov Models in HMMER3 format"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Biobase" = callPackage @@ -1431,6 +1533,7 @@ self: { ]; description = "Base library for bioinformatics"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseBlast" = callPackage @@ -1457,6 +1560,7 @@ self: { ]; description = "BLAST-related tools"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseDotP" = callPackage @@ -1468,6 +1572,7 @@ self: { libraryHaskellDepends = [ base bytestring iteratee ]; description = "Vienna / DotBracket / ExtSS parsers"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseENA" = callPackage @@ -1490,6 +1595,7 @@ self: { ]; description = "European Nucleotide Archive data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseEnsembl" = callPackage @@ -1507,6 +1613,7 @@ self: { ]; description = "Ensembl related datastructures and functions"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseFR3D" = callPackage @@ -1522,6 +1629,7 @@ self: { ]; description = "Importer for FR3D resources"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseFasta" = callPackage @@ -1546,6 +1654,7 @@ self: { ]; description = "streaming FASTA parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseHTTP" = callPackage @@ -1563,6 +1672,7 @@ self: { ]; description = "Libary to interface with the Bioinformatics HTTP services - Entrez Ensembl"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseHTTPTools" = callPackage @@ -1583,6 +1693,7 @@ self: { ]; description = "Tools to query Bioinformatics HTTP services e.g. Entrez, Ensembl."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseInfernal" = callPackage @@ -1621,6 +1732,7 @@ self: { ]; description = "Infernal data structures and tools"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseMAF" = callPackage @@ -1632,6 +1744,7 @@ self: { libraryHaskellDepends = [ base bytestring containers iteratee ]; description = "Multiple Alignment Format"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseNewick" = callPackage @@ -1659,6 +1772,8 @@ self: { ]; description = "Newick file format parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BiobaseTrainingData" = callPackage @@ -1678,6 +1793,7 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "RNA folding training data"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseTurner" = callPackage @@ -1695,6 +1811,7 @@ self: { ]; description = "Import Turner RNA parameters"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseTypes" = callPackage @@ -1727,6 +1844,7 @@ self: { ]; description = "Collection of types for bioinformatics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseVienna" = callPackage @@ -1742,6 +1860,7 @@ self: { ]; description = "Import Vienna energy parameters"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BiobaseXNA" = callPackage @@ -1783,6 +1902,7 @@ self: { ]; description = "Efficient RNA/DNA/Protein Primary/Secondary Structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BirdPP" = callPackage @@ -1796,6 +1916,7 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "A preprocessor for Bird-style Literate Haskell comments with Haddock markup"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "BitStringRandomMonad" = callPackage @@ -1815,6 +1936,8 @@ self: { transformers vector ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BitSyntax" = callPackage @@ -1839,6 +1962,7 @@ self: { libraryHaskellDepends = [ base HTTP json2 ]; description = "A library to access bit.ly URL shortener."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "BlastHTTP" = callPackage @@ -1856,6 +1980,7 @@ self: { ]; description = "Libary to interface with the NCBI blast REST interface"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Blobs" = callPackage @@ -1877,6 +2002,7 @@ self: { ]; description = "Diagram editor"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "BlogLiterately" = callPackage @@ -1901,6 +2027,7 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "A tool for posting Haskelly articles to blogs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "BlogLiterately-diagrams" = callPackage @@ -1922,6 +2049,7 @@ self: { executableHaskellDepends = [ base BlogLiterately ]; description = "Include images in blog posts with inline diagrams code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Blogdown" = callPackage @@ -1950,6 +2078,8 @@ self: { ]; description = "A markdown-like markup language designed for blog posts"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BluePrintCSS" = callPackage @@ -1972,6 +2102,8 @@ self: { doHaddock = false; description = "Preview of a new build system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Bookshelf" = callPackage @@ -1992,6 +2124,7 @@ self: { testHaskellDepends = [ base process ]; description = "A simple document organizer with some wiki functionality"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Boolean" = callPackage @@ -2030,6 +2163,8 @@ self: { ]; description = "Static text template generation library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "BufferedSocket" = callPackage @@ -2041,6 +2176,8 @@ self: { libraryHaskellDepends = [ base bytestring network text ]; description = "A socker wrapper that makes the IO of sockets much cleaner"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Buster" = callPackage @@ -2065,6 +2202,8 @@ self: { ]; description = "Hits a set of urls periodically to bust caches"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "C-structs" = callPackage @@ -2103,6 +2242,7 @@ self: { ]; description = "Encode/Decode values to/from CBOR"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "CC-delcont" = callPackage @@ -2132,6 +2272,7 @@ self: { doHaddock = false; description = "Three new monad transformers for multi-prompt delimited control"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "CC-delcont-cxe" = callPackage @@ -2143,6 +2284,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformers for multi-prompt delimited control"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CC-delcont-exc" = callPackage @@ -2154,6 +2297,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformers for multi-prompt delimited control"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CC-delcont-ref" = callPackage @@ -2165,6 +2310,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformers for multi-prompt delimited control using refercence cells"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CC-delcont-ref-tf" = callPackage @@ -2176,6 +2323,8 @@ self: { libraryHaskellDepends = [ base ref-tf transformers ]; description = "A monad transformers for multi-prompt delimited control using refercence cells"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CCA" = callPackage @@ -2193,6 +2342,8 @@ self: { executableToolDepends = [ happy ]; description = "preprocessor and library for Causal Commutative Arrows (CCA)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CHXHtml" = callPackage @@ -2222,6 +2373,8 @@ self: { ]; description = "Cursor Library for A Structured Editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CLI" = callPackage @@ -2234,6 +2387,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "CLI tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CMCompare" = callPackage @@ -2252,6 +2407,7 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "Infernal covariance model comparison"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "CMQ" = callPackage @@ -2268,6 +2424,8 @@ self: { ]; description = "cwmwl udp message queue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "COrdering" = callPackage @@ -2279,6 +2437,8 @@ self: { libraryHaskellDepends = [ base ]; description = "An algebraic data type similar to Prelude Ordering"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CPBrainfuck" = callPackage @@ -2293,6 +2453,7 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "A simple Brainfuck interpretter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "CPL" = callPackage @@ -2308,6 +2469,7 @@ self: { ]; description = "An interpreter of Hagino's Categorical Programming Language (CPL)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "CSPM-CoreLanguage" = callPackage @@ -2335,6 +2497,8 @@ self: { ]; description = "Firing rules semantic of CSPM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CSPM-Frontend" = callPackage @@ -2352,6 +2516,8 @@ self: { libraryToolDepends = [ alex ]; description = "A CSP-M parser compatible with FDR-2.91"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CSPM-Interpreter" = callPackage @@ -2368,6 +2534,7 @@ self: { ]; description = "An interpreter for CSPM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "CSPM-ToProlog" = callPackage @@ -2381,6 +2548,7 @@ self: { ]; description = "some modules specific for the ProB tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "CSPM-cspm" = callPackage @@ -2406,6 +2574,7 @@ self: { ]; description = "cspm command line tool for analyzing CSPM specifications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "CTRex" = callPackage @@ -2450,6 +2619,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "OpenCV based machine vision library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {opencv_calib3d = null; opencv_contrib = null; opencv_core = null; opencv_features2d = null; opencv_flann = null; opencv_gpu = null; opencv_highgui = null; opencv_imgproc = null; @@ -2599,6 +2770,8 @@ self: { ]; description = "A framework for packaging Haskell software"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CabalSearch" = callPackage @@ -2616,6 +2789,8 @@ self: { ]; description = "Search cabal packages by name"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Capabilities" = callPackage @@ -2627,6 +2802,8 @@ self: { libraryHaskellDepends = [ base compdata directory free unix ]; description = "Separate and contain effects of IO monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Cardinality" = callPackage @@ -2649,6 +2826,8 @@ self: { libraryHaskellDepends = [ base containers fgl parsec ]; description = "An implementation and DSL for the Carneades argumentation model"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CarneadesIntoDung" = callPackage @@ -2665,6 +2844,7 @@ self: { ]; description = "A translation from the Carneades argumentation model into Dung's AFs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Cartesian" = callPackage @@ -2676,6 +2856,8 @@ self: { libraryHaskellDepends = [ base lens linear template-haskell ]; description = "Coordinate systems"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Cascade" = callPackage @@ -2687,6 +2869,8 @@ self: { libraryHaskellDepends = [ base comonad ghc-prim mtl void ]; description = "Playing with reified categorical composition"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Cassava" = callPackage @@ -2713,6 +2897,8 @@ self: { ]; description = "A CSV parsing and encoding library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Catana" = callPackage @@ -2724,6 +2910,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad for complex manipulation of a stream"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ChannelT" = callPackage @@ -2812,6 +3000,7 @@ self: { ]; description = "A backend for the Chart library for FLTKHS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Chart-gtk" = callPackage @@ -2860,6 +3049,8 @@ self: { ]; description = "A wrapper for the chart library to assist with basic plots (Deprecated - use the Easy module instead)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Chart-tests" = callPackage @@ -2929,6 +3120,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Inbuilt checking for ultra reliable computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Chitra" = callPackage @@ -2942,6 +3135,8 @@ self: { executableHaskellDepends = [ base binary bytestring mtl network ]; description = "A platform independent mechanism to render graphics using vnc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ChristmasTree" = callPackage @@ -2957,6 +3152,8 @@ self: { ]; description = "Alternative approach of 'read' that composes grammars instead of parsers"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CirruParser" = callPackage @@ -2990,6 +3187,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ClassLaws" = callPackage @@ -3001,6 +3200,8 @@ self: { libraryHaskellDepends = [ base ChasingBottoms mtl QuickCheck ]; description = "Stating and checking laws for type class methods"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ClassyPrelude" = callPackage @@ -3012,6 +3213,8 @@ self: { libraryHaskellDepends = [ base strict ]; description = "Prelude replacement using classes instead of concrete types where reasonable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Clean" = callPackage @@ -3023,6 +3226,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A light, clean and powerful utility library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Clipboard" = callPackage @@ -3054,6 +3259,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Libary for parsing Clustal tools output"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Coadjute" = callPackage @@ -3071,6 +3277,7 @@ self: { ]; description = "A generic build tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Codec-Compression-LZF" = callPackage @@ -3138,6 +3345,7 @@ self: { ]; description = "A concurrent bittorrent client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Command" = callPackage @@ -3149,6 +3357,8 @@ self: { libraryHaskellDepends = [ base directory process ]; description = "A replacement for System.Exit and System.Process"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Commando" = callPackage @@ -3171,6 +3381,8 @@ self: { ]; description = "Watch some files; Rerun a command"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ComonadSheet" = callPackage @@ -3188,6 +3400,7 @@ self: { ]; description = "A library for expressing spreadsheet-like computations as the fixed-points of comonads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Compactable" = callPackage @@ -3199,6 +3412,8 @@ self: { libraryHaskellDepends = [ base containers transformers vector ]; description = "A generalization for containers that can be stripped of Nothing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ConClusion" = callPackage @@ -3221,6 +3436,8 @@ self: { ]; description = "Cluster algorithms, PCA, and chemical conformere analysis"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Concurrent-Cache" = callPackage @@ -3232,6 +3449,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A Cached variable for IO functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Concurrential" = callPackage @@ -3243,6 +3462,8 @@ self: { libraryHaskellDepends = [ async base ]; description = "Mix concurrent and sequential computation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Condor" = callPackage @@ -3264,6 +3485,7 @@ self: { ]; description = "Information retrieval library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ConfigFile" = callPackage @@ -3290,6 +3512,8 @@ self: { ]; description = "Template haskell for reading ConfigFiles"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Configger" = callPackage @@ -3301,6 +3525,7 @@ self: { libraryHaskellDepends = [ base Dangerous MissingH mtl parsec ]; description = "Parse config files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Configurable" = callPackage @@ -3312,6 +3537,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Declare types as Configurable then specialize them all in one place"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ConsStream" = callPackage @@ -3336,6 +3563,8 @@ self: { executableHaskellDepends = [ base process ]; description = "Restart a command on STDIN activity"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ConstraintKinds" = callPackage @@ -3347,6 +3576,8 @@ self: { libraryHaskellDepends = [ base dlist ghc-prim vector ]; description = "Repackages standard type classes with the ConstraintKinds extension"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Consumer" = callPackage @@ -3358,6 +3589,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad and monad transformer for consuming streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ContArrow" = callPackage @@ -3369,6 +3602,8 @@ self: { libraryHaskellDepends = [ arrows base ]; description = "Control.Arrow.Transformer.Cont"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ContextAlgebra" = callPackage @@ -3386,6 +3621,8 @@ self: { ]; description = "Implementation of the context algebra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Contract" = callPackage @@ -3397,6 +3634,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Practical typed lazy contracts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Control-Engine" = callPackage @@ -3428,6 +3667,7 @@ self: { ]; description = "A Library for Writing Multi-Pass Algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Control-Monad-ST2" = callPackage @@ -3445,6 +3685,8 @@ self: { ]; description = "A variation on the ST monad with two type parameters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CoreDump" = callPackage @@ -3456,6 +3698,8 @@ self: { libraryHaskellDepends = [ base ghc pretty pretty-show ]; description = "A GHC plugin for printing GHC's internal Core data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CoreErlang" = callPackage @@ -3467,6 +3711,8 @@ self: { libraryHaskellDepends = [ base parsec pretty ]; description = "Manipulating Core Erlang source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CoreFoundation" = callPackage @@ -3485,6 +3731,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to Mac OSX's CoreFoundation framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Coroutine" = callPackage @@ -3496,6 +3743,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Type-safe coroutines using lightweight session types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "CouchDB" = callPackage @@ -3516,6 +3765,8 @@ self: { ]; description = "CouchDB interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Craft3e" = callPackage @@ -3532,6 +3783,8 @@ self: { doHaddock = false; description = "Code for Haskell: the Craft of Functional Programming, 3rd ed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Crypto" = callPackage @@ -3586,6 +3839,8 @@ self: { ]; description = "CurryDB: In-memory Key/Value Database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DAG-Tournament" = callPackage @@ -3603,6 +3858,8 @@ self: { ]; description = "Real-Time Game Tournament Evaluator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DAV" = callPackage @@ -3659,6 +3916,8 @@ self: { ]; description = "DBFunctor - Functional Data Management => ETL/ELT Data Processing in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DBlimited" = callPackage @@ -3672,6 +3931,8 @@ self: { executableHaskellDepends = [ base containers parsec ]; description = "A command-line SQL interface for flat files (tdf,csv,etc.)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DBus" = callPackage @@ -3683,6 +3944,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "D-Bus bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DCFL" = callPackage @@ -3707,6 +3970,7 @@ self: { executableHaskellDepends = [ base MuCheck ]; description = "Distributed Mutation Analysis framework for MuCheck"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "DOH" = callPackage @@ -3743,6 +4007,7 @@ self: { libraryHaskellDepends = [ base mtl WebBits ]; description = "DOM Level 2 bindings for the WebBits package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "DP" = callPackage @@ -3758,6 +4023,7 @@ self: { ]; description = "Pragmatic framework for dynamic programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "DPM" = callPackage @@ -3781,6 +4047,8 @@ self: { executableHaskellDepends = [ base ]; description = "Darcs Patch Manager"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DPutils" = callPackage @@ -3865,6 +4133,8 @@ self: { ]; description = "Implementation of DSA, based on the description of FIPS 186-4"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DSH" = callPackage @@ -3893,6 +4163,7 @@ self: { ]; description = "Database Supported Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "DSTM" = callPackage @@ -3914,6 +4185,7 @@ self: { ]; description = "A framework for using STM within distributed systems"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "DTC" = callPackage @@ -3925,6 +4197,8 @@ self: { libraryHaskellDepends = [ base haskell-src-exts ]; description = "Data To Class transformation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Dangerous" = callPackage @@ -3936,6 +4210,7 @@ self: { libraryHaskellDepends = [ base MaybeT mtl ]; description = "Monads for operations that can exit early and produce warnings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Dao" = callPackage @@ -3966,6 +4241,8 @@ self: { ]; description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DarcsHelpers" = callPackage @@ -3977,6 +4254,7 @@ self: { libraryHaskellDepends = [ base HaXml mtl parsec safe xml-parsec ]; description = "Code used by Patch-Shack that seemed sensible to open for reusability"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Data-Angle" = callPackage @@ -4014,6 +4292,8 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "Ropes, an alternative to (Byte)Strings"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DataIndex" = callPackage @@ -4047,6 +4327,8 @@ self: { ]; description = "A GTK widget for displaying arbitrary Data.Data.Data instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DataVersion" = callPackage @@ -4060,6 +4342,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Type safe data migrations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Deadpan-DDP" = callPackage @@ -4088,6 +4372,8 @@ self: { testHaskellDepends = [ base doctest filemanip QuickCheck ]; description = "Write clients for Meteor's DDP Protocol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DebugTraceHelpers" = callPackage @@ -4127,6 +4413,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A very simple implementation of decision trees for discrete attributes"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DeepArrow" = callPackage @@ -4155,6 +4443,8 @@ self: { testHaskellDepends = [ base constraints mtl QuickCheck random ]; description = "A DSL for creating neural network"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DefendTheKing" = callPackage @@ -4174,6 +4464,7 @@ self: { ]; description = "A simple RTS game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Delta-Lambda" = callPackage @@ -4196,6 +4487,8 @@ self: { ]; description = "A demonstration interpreter for type system delta-lambda (of N.G. De-bruijn)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DescriptiveKeys" = callPackage @@ -4224,6 +4517,8 @@ self: { ]; description = "Processing Real-time event streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Diff_0_3_4" = callPackage @@ -4272,6 +4567,7 @@ self: { ]; description = "A theory solver for conjunctions of literals in difference logic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "DifferentialEvolution" = callPackage @@ -4287,6 +4583,8 @@ self: { ]; description = "Global optimization using Differential Evolution"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Digit" = callPackage @@ -4321,6 +4619,8 @@ self: { testHaskellDepends = [ base hspec lens mtl text ]; description = "A client library for the DigitalOcean API"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DimensionalHash" = callPackage @@ -4332,6 +4632,8 @@ self: { libraryHaskellDepends = [ base ]; description = "An n-dimensional hash using Morton numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DirectSound" = callPackage @@ -4365,6 +4667,7 @@ self: { ]; description = "Distributed Bug Tracking System"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "DiscussionSupportSystem" = callPackage @@ -4381,6 +4684,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Discussion support system"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Dish" = callPackage @@ -4395,6 +4700,8 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Hash modules (currently Murmur3)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Dist" = callPackage @@ -4407,6 +4714,8 @@ self: { testHaskellDepends = [ base containers MonadRandom ]; description = "A Haskell library for probability distributions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DistanceTransform" = callPackage @@ -4460,6 +4769,7 @@ self: { ]; description = "Frameshift-aware alignment of protein sequences with DNA sequences"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "DocTest" = callPackage @@ -4477,6 +4787,7 @@ self: { ]; description = "Test interactive Haskell examples"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Docs" = callPackage @@ -4506,6 +4817,7 @@ self: { executableHaskellDepends = [ array base containers pretty ]; description = "A tool for deriving hylomorphisms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "DrIFT" = callPackage @@ -4523,6 +4835,8 @@ self: { ]; description = "Program to derive type class instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DrIFT-cabalized" = callPackage @@ -4537,6 +4851,8 @@ self: { executableHaskellDepends = [ base old-time process random ]; description = "Program to derive type class instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Dung" = callPackage @@ -4550,6 +4866,8 @@ self: { libraryHaskellDepends = [ base cmdargs containers parsec ]; description = "An implementation of the Dung argumentation frameworks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Dust" = callPackage @@ -4575,6 +4893,7 @@ self: { ]; description = "Polymorphic protocol engine"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Dust-crypto" = callPackage @@ -4601,6 +4920,8 @@ self: { ]; description = "Cryptographic operations"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openssl;}; "Dust-tools" = callPackage @@ -4625,6 +4946,7 @@ self: { ]; description = "Network filtering exploration tools"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Dust-tools-pcap" = callPackage @@ -4646,6 +4968,7 @@ self: { ]; description = "Network filtering exploration tools that rely on pcap"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "DynamicTimeWarp" = callPackage @@ -4663,6 +4986,8 @@ self: { ]; description = "Dynamic time warping of sequences"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DysFRP" = callPackage @@ -4676,6 +5001,8 @@ self: { ]; description = "dysFunctional Reactive Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "DysFRP-Cairo" = callPackage @@ -4687,6 +5014,7 @@ self: { libraryHaskellDepends = [ base cairo DysFRP gtk mtl ]; description = "dysFunctional Reactive Programming on Cairo"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "DysFRP-Craftwerk" = callPackage @@ -4703,6 +5031,7 @@ self: { ]; description = "dysFunctional Reactive Programming on Craftwerk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "EEConfig" = callPackage @@ -4816,6 +5145,7 @@ self: { ]; description = "Query language and report generator for edit logs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Eight-Ball-Pool-Hack-Cheats" = callPackage @@ -4838,6 +5168,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "EitherT" = callPackage @@ -4855,6 +5187,8 @@ self: { ]; description = "EitherT monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Elm" = callPackage @@ -4910,6 +5244,8 @@ self: { ]; description = "derives heuristic rules from nominal data"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Empty" = callPackage @@ -4921,6 +5257,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A type class for empty containers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Encode" = callPackage @@ -4951,6 +5289,7 @@ self: { ]; description = "Libary to interface with the NCBI Entrez REST service"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Enum" = callPackage @@ -4974,6 +5313,8 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "Simple Enum-class-based int containers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "EnumMap" = callPackage @@ -4985,6 +5326,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "More general IntMap replacement"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Eq" = callPackage @@ -5003,6 +5346,8 @@ self: { ]; description = "Render math formula in ASCII, and perform some simplifications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "EqualitySolver" = callPackage @@ -5016,6 +5361,8 @@ self: { ]; description = "A theory solver for conjunctions of literals in the theory of uninterpreted functions with equality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "EsounD" = callPackage @@ -5035,6 +5382,7 @@ self: { ]; description = "Type-safe bindings to EsounD (ESD; Enlightened Sound Daemon)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "EstProgress" = callPackage @@ -5046,6 +5394,8 @@ self: { libraryHaskellDepends = [ ansi-terminal base mtl ]; description = "Methods for estimating the progress of functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "EtaMOO" = callPackage @@ -5070,6 +5420,7 @@ self: { executablePkgconfigDepends = [ pcre ]; description = "A new implementation of the LambdaMOO server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) pcre;}; "Etage" = callPackage @@ -5085,6 +5436,8 @@ self: { ]; description = "A general data-flow framework"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Etage-Graph" = callPackage @@ -5103,6 +5456,7 @@ self: { ]; description = "Data-flow based graph algorithms"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Eternal10Seconds" = callPackage @@ -5117,6 +5471,7 @@ self: { executableHaskellDepends = [ base haskell98 SDL SDL-mixer ]; description = "A 2-D shooting game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Etherbunny" = callPackage @@ -5138,6 +5493,7 @@ self: { executableSystemDepends = [ libpcap ]; description = "A network analysis toolkit for Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libpcap;}; "EuroIT" = callPackage @@ -5183,6 +5539,7 @@ self: { ]; description = "Interfaces with FreeSwitch Event Socket"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Extra" = callPackage @@ -5202,6 +5559,8 @@ self: { ]; description = "A grab bag of modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FAI" = callPackage @@ -5239,6 +5598,7 @@ self: { ]; description = "Compose music"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "FM-SBLEX" = callPackage @@ -5252,6 +5612,7 @@ self: { executableHaskellDepends = [ array base containers haskell98 ]; description = "A set of computational morphology tools for Swedish diachronic lexicons"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "FModExRaw" = callPackage @@ -5264,6 +5625,8 @@ self: { librarySystemDepends = [ fmodex64 ]; description = "The Haskell FModEx raw API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {fmodex64 = null;}; "FPretty" = callPackage @@ -5277,6 +5640,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Efficient simple pretty printing combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FSM" = callPackage @@ -5319,6 +5684,8 @@ self: { librarySystemDepends = [ ftgl ]; description = "Portable TrueType font rendering for OpenGL using the Freetype2 library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ftgl;}; "FTPLine" = callPackage @@ -5337,6 +5704,7 @@ self: { ]; description = "A command-line FTP client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Facebook-Password-Hacker-Online-Latest-Version" = callPackage @@ -5361,6 +5729,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Facts" = callPackage @@ -5376,6 +5746,7 @@ self: { ]; description = "A collection of facts about the real world"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "FailureT" = callPackage @@ -5387,6 +5758,7 @@ self: { libraryHaskellDepends = [ base base-unicode-symbols mmtl ]; description = "Failure Monad Transformer"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "FastPush" = callPackage @@ -5398,6 +5770,8 @@ self: { libraryHaskellDepends = [ base STMonadTrans vector ]; description = "A monad and monad transformer for pushing things onto a stack very fast"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FastxPipe" = callPackage @@ -5414,6 +5788,8 @@ self: { ]; description = "Fasta and Fastq streaming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FenwickTree" = callPackage @@ -5446,6 +5822,7 @@ self: { ]; description = "Annotate ps and pdf documents"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "FerryCore" = callPackage @@ -5462,6 +5839,8 @@ self: { ]; description = "Ferry Core Components"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Feval" = callPackage @@ -5475,6 +5854,8 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Evaluation using F-Algebras"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FieldTrip" = callPackage @@ -5491,6 +5872,7 @@ self: { ]; description = "Functional 3D"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "FileManip" = callPackage @@ -5506,6 +5888,8 @@ self: { ]; description = "Expressive file and directory manipulation for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FileManipCompat" = callPackage @@ -5521,6 +5905,8 @@ self: { ]; description = "Expressive file and directory manipulation for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FilePather" = callPackage @@ -5537,6 +5923,7 @@ self: { ]; description = "Functions on System.FilePath"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "FileSystem" = callPackage @@ -5552,6 +5939,8 @@ self: { ]; description = "File system data structure and monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Files" = callPackage @@ -5568,6 +5957,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "File content extraction/rearrangement"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Fin" = callPackage @@ -5600,6 +5991,8 @@ self: { ]; description = "Obtain quote data from finance.yahoo.com"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Finance-Treasury" = callPackage @@ -5616,6 +6009,7 @@ self: { ]; description = "Obtain Treasury yield curve data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "FindBin" = callPackage @@ -5638,6 +6032,7 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "A finite map implementation, derived from the paper: Efficient sets: a balancing act, S. Adams, Journal of functional programming 3(4) Oct 1993, pp553-562"; license = lib.licenses.bsdOriginal; + hydraPlatforms = lib.platforms.none; }) {}; "FirstOrderTheory" = callPackage @@ -5649,6 +6044,7 @@ self: { libraryHaskellDepends = [ base containers Proper ]; description = "Grammar and typeclass for first order theories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "FixedPoint-simple" = callPackage @@ -5678,6 +6074,7 @@ self: { ]; description = "Wiki"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "FloatingHex" = callPackage @@ -5751,6 +6148,8 @@ self: { ]; description = "ForSyDe's Haskell-embedded Domain Specific Language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ForestStructures" = callPackage @@ -5798,6 +6197,7 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Comparison of trees and forests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ForkableT" = callPackage @@ -5809,6 +6209,8 @@ self: { libraryHaskellDepends = [ base monad-control mtl resourcet ]; description = "Forkable monad transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FormalGrammars" = callPackage @@ -5833,6 +6235,7 @@ self: { ]; description = "(Context-free) grammars in formal language theory"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Fortnite-Hack-Cheats-Free-V-Bucks-Generator" = callPackage @@ -5855,6 +6258,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Foster" = callPackage @@ -5875,6 +6280,7 @@ self: { ]; description = "Utilities to generate and solve puzzles"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "FpMLv53" = callPackage @@ -5921,6 +6327,8 @@ self: { base FTGL GLFW-b OpenGLRaw parallel random time ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Frames" = callPackage @@ -5975,6 +6383,7 @@ self: { ]; description = "A library for accessing Postgres tables as in-memory data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Frames-dsv" = callPackage @@ -5992,6 +6401,7 @@ self: { testHaskellDepends = [ base Frames hspec pipes ]; description = "Alternative CSV parser for the Frames package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Frames-map-reduce" = callPackage @@ -6012,6 +6422,8 @@ self: { ]; description = "Frames wrapper for map-reduce-folds and some extra folds helpers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Frames-streamly" = callPackage @@ -6035,6 +6447,8 @@ self: { ]; description = "A streamly layer for Frames I/O"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Frank" = callPackage @@ -6048,6 +6462,7 @@ self: { executableHaskellDepends = [ base mtl newtype she void ]; description = "An experimental programming language with typed algebraic effects"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "FreeTypeGL" = callPackage @@ -6062,6 +6477,8 @@ self: { libraryHaskellDepends = [ base freetype2 OpenGL ]; description = "Loadable texture fonts for OpenGL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FunGEn" = callPackage @@ -6098,6 +6515,8 @@ self: { ]; description = "Funge-98 interpreter written in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GA" = callPackage @@ -6122,6 +6541,8 @@ self: { executableHaskellDepends = [ base bimap ]; description = "GGg cipher"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GHood" = callPackage @@ -6146,6 +6567,8 @@ self: { librarySystemDepends = [ libGL libX11 libXext libXfixes ]; description = "A Haskell binding for GLFW"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libGL; inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXfixes;}; @@ -6160,6 +6583,7 @@ self: { librarySystemDepends = [ libX11 libXrandr ]; description = "A binding for GLFW (OGL)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXrandr;}; "GLFW-b" = callPackage @@ -6194,6 +6618,8 @@ self: { ]; description = "GLFW-b demo"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GLFW-task" = callPackage @@ -6207,6 +6633,7 @@ self: { ]; description = "GLFW utility functions to use together with monad-task"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GLHUI" = callPackage @@ -6258,6 +6685,8 @@ self: { libraryHaskellDepends = [ base OpenGLRaw ]; description = "Utilities for working with OpenGL matrices"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GLURaw" = callPackage @@ -6323,6 +6752,7 @@ self: { ]; description = "Parse GPX files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GPipe" = callPackage @@ -6340,6 +6770,8 @@ self: { ]; description = "Typesafe functional GPU graphics programming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GPipe-Collada" = callPackage @@ -6353,6 +6785,7 @@ self: { ]; description = "Load GPipe meshes from Collada files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GPipe-Core" = callPackage @@ -6374,6 +6807,8 @@ self: { benchmarkHaskellDepends = [ base criterion lens ]; description = "Typesafe functional GPU graphics programming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GPipe-Examples" = callPackage @@ -6391,6 +6826,7 @@ self: { ]; description = "Examples for the GPipes package"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "GPipe-GLFW" = callPackage @@ -6403,6 +6839,7 @@ self: { libraryHaskellDepends = [ async base containers GLFW-b GPipe stm ]; description = "GLFW OpenGL context creation for GPipe"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "GPipe-GLFW4" = callPackage @@ -6432,6 +6869,7 @@ self: { ]; description = "GLFW OpenGL context creation for GPipe"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "GPipe-TextureLoad" = callPackage @@ -6443,6 +6881,7 @@ self: { libraryHaskellDepends = [ base bitmap GPipe stb-image ]; description = "Load GPipe textures from filesystem"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GTALib" = callPackage @@ -6461,6 +6900,8 @@ self: { ]; description = "A library for GTA programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Gamgine" = callPackage @@ -6482,6 +6923,7 @@ self: { libraryToolDepends = [ cpphs ]; description = "Some kind of game library or set of utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Ganymede" = callPackage @@ -6499,6 +6941,8 @@ self: { ]; description = "An Io interpreter in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GaussQuadIntegration" = callPackage @@ -6526,6 +6970,7 @@ self: { ]; description = "Several games"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GenI" = callPackage @@ -6572,6 +7017,7 @@ self: { executableHaskellDepends = [ base haskell98 QuickCheck random ]; description = "Automatic SMS message generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Genbank" = callPackage @@ -6590,6 +7036,7 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "Libary for processing the NCBI genbank format"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Gene-CluEDO" = callPackage @@ -6615,6 +7062,7 @@ self: { ]; description = "Hox gene clustering"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "GeneralTicTacToe" = callPackage @@ -6628,6 +7076,8 @@ self: { executableHaskellDepends = [ base ]; description = "A general TicTacToe game implementation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GenericPretty" = callPackage @@ -6666,6 +7116,7 @@ self: { ]; description = "MCFGs for Genus-1 RNA Pseudoknots"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "GeoIp" = callPackage @@ -6690,6 +7141,8 @@ self: { libraryHaskellDepends = [ aeson base bytestring HTTP text ]; description = "Geocoder and Reverse Geocoding Service Wrapper"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Geodetic" = callPackage @@ -6723,6 +7176,8 @@ self: { libraryHaskellDepends = [ base GeomPredicates ]; description = "Geometric predicates (Intel SSE)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Get" = callPackage @@ -6735,6 +7190,8 @@ self: { testHaskellDepends = [ base constraints singletons ]; description = "get stuff out of stuff"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GiST" = callPackage @@ -6746,6 +7203,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "A Haskell implementation of a Generalized Search Tree (GiST)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Gifcurry" = callPackage @@ -6771,6 +7230,8 @@ self: { ]; description = "GIF creation utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GiveYouAHead" = callPackage @@ -6793,6 +7254,8 @@ self: { libraryHaskellDepends = [ base mtl split threepenny-gui ]; description = "HTML Canvas graphics, animations and simulations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Glob" = callPackage @@ -6826,6 +7289,8 @@ self: { libraryHaskellDepends = [ array base GlomeVec ]; description = "Ray Tracing Library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GlomeVec" = callPackage @@ -6855,6 +7320,7 @@ self: { ]; description = "SDL Frontend for Glome ray tracer"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "GoogleChart" = callPackage @@ -6881,6 +7347,8 @@ self: { ]; description = "A monad for flexible parsing of Google Code Jam input files with automatic parallelization"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GoogleDirections" = callPackage @@ -6896,6 +7364,7 @@ self: { ]; description = "Haskell Interface to Google Directions API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GoogleSB" = callPackage @@ -6911,6 +7380,7 @@ self: { ]; description = "Interface to Google Safe Browsing API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GoogleSuggest" = callPackage @@ -6938,6 +7408,7 @@ self: { ]; description = "Interface to Google Translate API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "GotoT-transformers" = callPackage @@ -6949,6 +7420,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A monad and monadic transformer providing \"goto\" functionality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Grafos" = callPackage @@ -6960,6 +7433,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Grafos Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GrammarProducts" = callPackage @@ -6982,6 +7457,7 @@ self: { testHaskellDepends = [ base ]; description = "Grammar products and higher-dimensional grammars"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Graph500" = callPackage @@ -7000,6 +7476,8 @@ self: { executableHaskellDepends = [ array base mtl ]; description = "Graph500 benchmark-related definitions and data set generator"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GraphHammer" = callPackage @@ -7014,6 +7492,7 @@ self: { ]; description = "GraphHammer Haskell graph analyses framework inspired by STINGER"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "GraphHammer-examples" = callPackage @@ -7031,6 +7510,7 @@ self: { ]; description = "Test harness for TriangleCount analysis"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "GraphSCC" = callPackage @@ -7074,6 +7554,8 @@ self: { ]; description = "Embedded grammar DSL and LALR parser generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "GroteTrap" = callPackage @@ -7091,6 +7573,8 @@ self: { ]; description = "Parser and selection library for expression languages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Grow" = callPackage @@ -7133,6 +7617,7 @@ self: { ]; description = "Notification utility for Growl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Gtk2hsGenerics" = callPackage @@ -7148,6 +7633,7 @@ self: { ]; description = "Convenience functions to extend Gtk2hs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "GtkGLTV" = callPackage @@ -7163,6 +7649,7 @@ self: { ]; description = "OpenGL support for Gtk-based GUIs for Tangible Values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GtkTV" = callPackage @@ -7194,6 +7681,7 @@ self: { ]; description = "A graphical REPL and development environment for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "GuiTV" = callPackage @@ -7205,6 +7693,7 @@ self: { libraryHaskellDepends = [ base DeepArrow phooey TV TypeCompose ]; description = "GUIs for Tangible Values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "H" = callPackage @@ -7249,6 +7738,8 @@ self: { ]; description = "Hierarchical adaptive Bayesian quantum tomography for quantum bits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HARM" = callPackage @@ -7280,6 +7771,7 @@ self: { ]; description = "HAppS data manipulation libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HAppS-IxSet" = callPackage @@ -7295,6 +7787,7 @@ self: { syb-with-class template-haskell ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HAppS-Server" = callPackage @@ -7315,6 +7808,7 @@ self: { ]; description = "Web related tools and services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HAppS-State" = callPackage @@ -7334,6 +7828,7 @@ self: { ]; description = "Event-based distributed state"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HAppS-Util" = callPackage @@ -7350,6 +7845,8 @@ self: { ]; description = "Web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HAppSHelpers" = callPackage @@ -7395,6 +7892,8 @@ self: { ]; description = "A library for implementing a Deck of Cards"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HCodecs" = callPackage @@ -7446,6 +7945,8 @@ self: { librarySystemDepends = [ mysqlclient openssl zlib ]; description = "MySQL driver for HDBC"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {mysqlclient = null; inherit (pkgs) openssl; inherit (pkgs) zlib;}; @@ -7496,6 +7997,8 @@ self: { libraryHaskellDepends = [ attoparsec base containers HDBC text ]; description = "Manipulate data in PostgreSQL \"hstore\" columns"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HDBC-session" = callPackage @@ -7536,6 +8039,8 @@ self: { librarySystemDepends = [ pfstools ]; description = "Utilities for reading, manipulating, and writing HDR images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) pfstools;}; "HERA" = callPackage @@ -7547,6 +8052,8 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ mpfr ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) mpfr;}; "HExcel" = callPackage @@ -7563,6 +8070,8 @@ self: { librarySystemDepends = [ xlsxwriter zlib ]; description = "Create Excel files with Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {xlsxwriter = null; inherit (pkgs) zlib;}; "HFitUI" = callPackage @@ -7584,6 +8093,8 @@ self: { testHaskellDepends = [ base ]; description = "The library for generating a graphical interface on the web"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HFrequencyQueue" = callPackage @@ -7595,6 +8106,8 @@ self: { libraryHaskellDepends = [ base c-storable-deriving ]; description = "A Queue with a random (weighted) pick function"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HFuse" = callPackage @@ -7631,6 +8144,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "2D game engine written in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HGL" = callPackage @@ -7989,6 +8504,8 @@ self: { ]; description = "Graph database stored on disk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HHDL" = callPackage @@ -8000,6 +8517,8 @@ self: { libraryHaskellDepends = [ base containers mtl template-haskell ]; description = "Hardware Description Language embedded in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HJScript" = callPackage @@ -8011,6 +8530,7 @@ self: { libraryHaskellDepends = [ base HJavaScript hsp mtl text ]; description = "HJScript is a Haskell EDSL for writing JavaScript programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HJVM" = callPackage @@ -8033,6 +8553,8 @@ self: { ]; description = "A library to create a Java Virtual Machine and manipulate Java objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) jdk;}; "HJavaScript" = callPackage @@ -8046,6 +8568,8 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "HJavaScript is an abstract syntax for a typed subset of JavaScript"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HLearn-algebra" = callPackage @@ -8065,6 +8589,7 @@ self: { ]; description = "Algebraic foundation for homomorphic learning"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HLearn-approximation" = callPackage @@ -8083,6 +8608,7 @@ self: { HLearn-datastructures HLearn-distributions list-extras vector ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HLearn-classification" = callPackage @@ -8105,6 +8631,7 @@ self: { QuickCheck statistics vector vector-th-unbox ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HLearn-datastructures" = callPackage @@ -8120,6 +8647,7 @@ self: { MonadRandom QuickCheck vector ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HLearn-distributions" = callPackage @@ -8143,6 +8671,7 @@ self: { ]; description = "Distributions for use with the HLearn library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HList" = callPackage @@ -8168,6 +8697,8 @@ self: { ]; description = "Heterogeneous lists"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HListPP" = callPackage @@ -8195,6 +8726,8 @@ self: { executableHaskellDepends = [ base old-locale time ]; description = "Simple, concurrent and easy-to-use logging library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HMM" = callPackage @@ -8205,6 +8738,8 @@ self: { sha256 = "01y8l76c56gysynbilp32yq0wfc129hl24siw8s9fmpn98qa71s6"; description = "A hidden markov model library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HMap" = callPackage @@ -8260,6 +8795,7 @@ self: { ]; description = "Happy Network Manager"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HNumeric" = callPackage @@ -8290,6 +8826,8 @@ self: { librarySystemDepends = [ ode ]; description = "Binding to libODE"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ode;}; "HOpenCV" = callPackage @@ -8306,6 +8844,8 @@ self: { executablePkgconfigDepends = [ opencv ]; description = "A binding for the OpenCV computer vision library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) opencv;}; "HPDF" = callPackage @@ -8352,6 +8892,8 @@ self: { ]; description = "Extract Haskell declarations by name"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HPhone" = callPackage @@ -8381,6 +8923,8 @@ self: { librarySystemDepends = [ bcm2835 ]; description = "GPIO, I2C and SPI functions for the Raspberry Pi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {bcm2835 = null;}; "HPlot" = callPackage @@ -8398,6 +8942,7 @@ self: { executablePkgconfigDepends = [ plplotd-gnome2 ]; description = "A minimal monadic PLplot interface for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {plplotd-gnome2 = null;}; "HPong" = callPackage @@ -8416,6 +8961,7 @@ self: { ]; description = "A simple OpenGL Pong game based on GLFW"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "HROOT" = callPackage @@ -8433,6 +8979,7 @@ self: { ]; description = "Haskell binding to the ROOT data analysis framework"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "HROOT-core" = callPackage @@ -8446,6 +8993,7 @@ self: { ]; description = "Haskell binding to ROOT Core modules"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "HROOT-graf" = callPackage @@ -8461,6 +9009,7 @@ self: { ]; description = "Haskell binding to ROOT Graf modules"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "HROOT-hist" = callPackage @@ -8476,6 +9025,7 @@ self: { ]; description = "Haskell binding to ROOT Hist modules"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "HROOT-io" = callPackage @@ -8491,6 +9041,7 @@ self: { ]; description = "Haskell binding to ROOT IO modules"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "HROOT-math" = callPackage @@ -8506,6 +9057,7 @@ self: { ]; description = "Haskell binding to ROOT Math modules"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "HROOT-tree" = callPackage @@ -8521,6 +9073,7 @@ self: { ]; description = "Haskell binding to ROOT Tree modules"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "HRay" = callPackage @@ -8535,6 +9088,7 @@ self: { executableHaskellDepends = [ array base directory haskell98 ]; description = "Haskell raytracer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HSFFIG" = callPackage @@ -8555,6 +9109,8 @@ self: { ]; description = "Generate FFI import declarations from C include files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HSGEP" = callPackage @@ -8573,6 +9129,7 @@ self: { executableHaskellDepends = [ csv ]; description = "Gene Expression Programming evolutionary algorithm in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HSH" = callPackage @@ -8609,6 +9166,7 @@ self: { ]; description = "Convenience functions that use HSH, instances for HSH"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "HSet" = callPackage @@ -8620,6 +9178,8 @@ self: { libraryHaskellDepends = [ base containers hashable hashtables ]; description = "Faux heterogeneous sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HSlippyMap" = callPackage @@ -8684,6 +9244,7 @@ self: { ]; description = "Audio file reading/writing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HStringTemplate" = callPackage @@ -8720,6 +9281,7 @@ self: { ]; description = "Convenience functions and instances for HStringTemplate"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "HSvm" = callPackage @@ -8816,6 +9378,7 @@ self: { ]; description = "Tableau based theorem prover for hybrid logics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HTicTacToe" = callPackage @@ -8833,6 +9396,8 @@ self: { ]; description = "An SDL tic-tac-toe game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HUnit" = callPackage @@ -8856,6 +9421,8 @@ self: { libraryHaskellDepends = [ ansi-terminal base Diff groom HUnit ]; description = "Assertions for HUnit with difference reporting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HUnit-Plus" = callPackage @@ -8915,6 +9482,7 @@ self: { ]; description = "A (prototyped) easy to use XMPP library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HXQ" = callPackage @@ -8932,6 +9500,8 @@ self: { ]; description = "A Compiler from XQuery to Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaLeX" = callPackage @@ -8946,6 +9516,8 @@ self: { libraryHaskellDepends = [ base HUnit mtl QuickCheck ]; description = "HaLeX enables modelling, manipulation and visualization of regular languages"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaMinitel" = callPackage @@ -8957,6 +9529,7 @@ self: { libraryHaskellDepends = [ base bytestring serialport stm ]; description = "An Haskell library to drive the french Minitel through a serial port"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "HaPy" = callPackage @@ -8968,6 +9541,8 @@ self: { libraryHaskellDepends = [ base template-haskell th-lift ]; description = "Haskell bindings for Python"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaRe" = callPackage @@ -9002,6 +9577,7 @@ self: { ]; description = "the Haskell Refactorer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HaTeX" = callPackage @@ -9040,6 +9616,7 @@ self: { ]; description = "This package is deprecated. From version 3, HaTeX does not need this anymore."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HaTeX-qq" = callPackage @@ -9055,6 +9632,7 @@ self: { ]; description = "Quasiquoters for HaTeX"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HaVSA" = callPackage @@ -9074,6 +9652,7 @@ self: { ]; description = "An implementation of the Version Space Algebra learning framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HaXml" = callPackage @@ -9110,6 +9689,7 @@ self: { executableHaskellDepends = [ text time vty vty-ui ]; description = "Simple chat"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "HackMail" = callPackage @@ -9130,6 +9710,8 @@ self: { ]; description = "A Procmail Replacement as Haskell EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Haggressive" = callPackage @@ -9147,6 +9729,8 @@ self: { testHaskellDepends = [ base Cabal containers HUnit tuple vector ]; description = "Aggression analysis for Tweets on Twitter"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HandlerSocketClient" = callPackage @@ -9158,6 +9742,8 @@ self: { libraryHaskellDepends = [ base bytestring network ]; description = "Haskell implementation of a HandlerSocket client (API)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HandsomeSoup" = callPackage @@ -9192,6 +9778,8 @@ self: { testHaskellDepends = [ base hspec transformers ]; description = "The classic game of Hangman"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HappyTree" = callPackage @@ -9209,6 +9797,8 @@ self: { ]; description = "Type Safe and End to End Decision Tree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HarmTrace" = callPackage @@ -9232,6 +9822,7 @@ self: { ]; description = "Harmony Analysis and Retrieval of Music"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "HarmTrace-Base" = callPackage @@ -9281,6 +9872,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Haskell bindings for CacBDD"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {CacBDD = null;}; "HasGP" = callPackage @@ -9297,6 +9890,7 @@ self: { ]; description = "A Haskell library for inference using Gaussian processes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Haschoo" = callPackage @@ -9315,6 +9909,8 @@ self: { ]; description = "Minimalist R5RS Scheme interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hashell" = callPackage @@ -9333,6 +9929,7 @@ self: { ]; description = "Simple shell written in Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "HaskRel" = callPackage @@ -9349,6 +9946,7 @@ self: { ]; description = "HaskRel, Haskell as a DBMS with support for the relational algebra"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "HaskellAnalysisProgram" = callPackage @@ -9372,6 +9970,8 @@ self: { ]; description = "Haskell source code analysis program"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaskellForMaths" = callPackage @@ -9394,6 +9994,8 @@ self: { libraryHaskellDepends = [ base hmatrix ]; description = "Pure Haskell implementation of the Levenberg-Marquardt algorithm"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaskellNN" = callPackage @@ -9405,6 +10007,8 @@ self: { libraryHaskellDepends = [ base hmatrix random ]; description = "High Performance Neural Network in Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaskellNet" = callPackage @@ -9437,6 +10041,8 @@ self: { ]; description = "Helpers to connect to SSL/TLS mail servers with HaskellNet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaskellTorrent" = callPackage @@ -9460,6 +10066,8 @@ self: { ]; description = "A concurrent bittorrent client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HaskellTutorials" = callPackage @@ -9473,6 +10081,8 @@ self: { executableHaskellDepends = [ base cmdargs text ]; description = "Haskell Tutorials by Evgeny Ukhanov"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Haskelloids" = callPackage @@ -9490,6 +10100,8 @@ self: { ]; description = "A reproduction of the Atari 1979 classic \"Asteroids\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hastodon" = callPackage @@ -9531,6 +10143,7 @@ self: { ]; description = "A small 2D game framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Hawk" = callPackage @@ -9552,6 +10165,7 @@ self: { ]; description = "Haskell Web Application Kit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Hayoo" = callPackage @@ -9578,6 +10192,7 @@ self: { ]; description = "The Hayoo! search engine for Haskell API search on hackage"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Hclip" = callPackage @@ -9610,6 +10225,7 @@ self: { ]; description = "Line oriented editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HerbiePlugin" = callPackage @@ -9628,6 +10244,8 @@ self: { testHaskellDepends = [ base linear subhask ]; description = "automatically improve your code's numeric stability"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hermes" = callPackage @@ -9646,6 +10264,8 @@ self: { ]; description = "Message-based middleware layer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hieroglyph" = callPackage @@ -9663,6 +10283,7 @@ self: { ]; description = "Purely functional 2D graphics for visualization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HiggsSet" = callPackage @@ -9679,6 +10300,7 @@ self: { ]; description = "A multi-index set with advanced query capabilites"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Hipmunk" = callPackage @@ -9742,6 +10364,8 @@ self: { base directory MissingH process regex-tdfa time ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Histogram" = callPackage @@ -9769,6 +10393,8 @@ self: { ]; description = "An MPD client designed for a Home Theatre PC"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hoed" = callPackage @@ -9793,6 +10419,7 @@ self: { testHaskellDepends = [ base process QuickCheck ]; description = "Lightweight algorithmic debugging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HoleyMonoid" = callPackage @@ -9916,6 +10543,7 @@ self: { testHaskellDepends = [ base process random ]; description = "A Simple Key Value Store"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HostAndPort" = callPackage @@ -9942,6 +10570,8 @@ self: { executableHaskellDepends = [ base containers ]; description = "A Cricket scoring application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hs2lib" = callPackage @@ -9969,6 +10599,7 @@ self: { testHaskellDepends = [ base directory filepath process ]; description = "A Library and Preprocessor that makes it easier to create shared libs from Haskell programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HsASA" = callPackage @@ -10000,6 +10631,8 @@ self: { ]; description = "Bindings to htslib"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) zlib;}; "HsHaruPDF" = callPackage @@ -10011,6 +10644,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell binding to libharu (http://libharu.sourceforge.net/)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HsHyperEstraier" = callPackage @@ -10027,6 +10662,8 @@ self: { libraryPkgconfigDepends = [ hyperestraier qdbm ]; description = "HyperEstraier binding for Haskell"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {hyperestraier = null; qdbm = null;}; "HsJudy" = callPackage @@ -10040,6 +10677,8 @@ self: { librarySystemDepends = [ Judy ]; description = "Judy bindings, and some nice APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {Judy = null;}; "HsOpenSSL" = callPackage @@ -10079,6 +10718,7 @@ self: { ]; description = "Haskell integration with Parrot virtual machine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HsPerl5" = callPackage @@ -10090,6 +10730,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell interface to embedded Perl 5 interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HsSVN" = callPackage @@ -10101,6 +10743,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl stm ]; description = "Partial Subversion (SVN) binding for Haskell"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HsSyck" = callPackage @@ -10149,6 +10793,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Webots bindings for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {Controller = null; driver = null;}; "HsYAML" = callPackage @@ -10213,6 +10858,7 @@ self: { ]; description = "Stream Editor in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Hsmtlib" = callPackage @@ -10230,6 +10876,8 @@ self: { ]; description = "Haskell library for easy interaction with SMT-LIB 2 compliant solvers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HueAPI" = callPackage @@ -10245,6 +10893,8 @@ self: { ]; description = "API for controlling Philips Hue lights"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HulkImport" = callPackage @@ -10262,6 +10912,8 @@ self: { testHaskellDepends = [ base tasty tasty-golden ]; description = "Easily bulk import CSV data to SQL Server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hungarian-Munkres" = callPackage @@ -10299,6 +10951,7 @@ self: { testHaskellDepends = [ base ]; description = "The library for generating a WebGL scene for the web"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "I1M" = callPackage @@ -10313,6 +10966,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ]; description = "Code for the Haskell course taught at the University of Seville"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IDynamic" = callPackage @@ -10324,6 +10979,8 @@ self: { libraryHaskellDepends = [ base containers directory ]; description = "Indexable, serializable form of Data.Dynamic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IFS" = callPackage @@ -10339,6 +10996,8 @@ self: { ]; description = "Iterated Function System generation for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "INblobs" = callPackage @@ -10358,6 +11017,7 @@ self: { ]; description = "Editor and interpreter for Interaction Nets"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "IOR" = callPackage @@ -10370,6 +11030,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Region based resource management for the IO monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IORefCAS" = callPackage @@ -10388,6 +11050,7 @@ self: { ]; description = "Atomic compare and swap for IORefs and STRefs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "IOSpec" = callPackage @@ -10445,6 +11108,8 @@ self: { ]; description = "A RESTful microService for IPv6-related data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IcoGrid" = callPackage @@ -10456,6 +11121,8 @@ self: { libraryHaskellDepends = [ array base GlomeVec ]; description = "Library for generating grids of hexagons and pentagons mapped to a sphere"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IfElse" = callPackage @@ -10489,6 +11156,8 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "A library for writing Imperative style haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IndentParser" = callPackage @@ -10511,6 +11180,7 @@ self: { libraryHaskellDepends = [ base PeanoWitnesses ]; description = "Length- and element-indexed lists sitting somewhere between homogeneous and fully heterogeneous"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "InfixApplicative" = callPackage @@ -10522,6 +11192,7 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "liftA2 for infix operators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "IntFormats" = callPackage @@ -10534,6 +11205,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Convert integers in various bases to and from strings"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IntGraph" = callPackage @@ -10632,6 +11305,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "DSL for IRC bots"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "IrrHaskell" = callPackage @@ -10663,6 +11338,8 @@ self: { ]; description = "A typeclass to determine if a given value is null"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "JSON-Combinator" = callPackage @@ -10680,6 +11357,7 @@ self: { ]; description = "A combinator library on top of a generalised JSON type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JSON-Combinator-Examples" = callPackage @@ -10693,6 +11371,7 @@ self: { ]; description = "Example uses of the JSON-Combinator library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JSONParser" = callPackage @@ -10724,6 +11403,7 @@ self: { ]; description = "JSON parser that uses byte strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JYU-Utils" = callPackage @@ -10743,6 +11423,8 @@ self: { ]; description = "Some utility functions for JYU projects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "JackMiniMix" = callPackage @@ -10754,6 +11436,8 @@ self: { libraryHaskellDepends = [ base hosc ]; description = "control JackMiniMix"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Javasf" = callPackage @@ -10770,6 +11454,7 @@ self: { ]; description = "A utility to print the SourceFile attribute of one or more Java class files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Javav" = callPackage @@ -10783,6 +11468,8 @@ self: { executableHaskellDepends = [ base ]; description = "A utility to print the target version of Java class files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Jazzkell" = callPackage @@ -10806,6 +11493,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A Json implementation for Haskell, with JavaScript Values and Encoding/Decoding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "JsContracts" = callPackage @@ -10828,6 +11517,7 @@ self: { ]; description = "Design-by-contract for JavaScript"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JsonGrammar" = callPackage @@ -10849,6 +11539,7 @@ self: { ]; description = "Combinators for bidirectional JSON parsing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JuPyTer-notebook" = callPackage @@ -10865,6 +11556,7 @@ self: { ]; description = "JuPyTer notebook parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JuicyPixels" = callPackage @@ -10904,6 +11596,8 @@ self: { ]; description = "BLP format decoder/encoder over JuicyPixels library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "JuicyPixels-blurhash" = callPackage @@ -10944,6 +11638,8 @@ self: { libraryHaskellDepends = [ base containers JuicyPixels ]; description = "Functions for drawing lines, squares and so on pixel by pixel"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "JuicyPixels-extra" = callPackage @@ -11035,6 +11731,8 @@ self: { filepath mtl network resourcet ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "JunkDB-driver-gdbm" = callPackage @@ -11049,6 +11747,7 @@ self: { base bytestring conduit directory filepath JunkDB mtl resourcet ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JunkDB-driver-hashtables" = callPackage @@ -11063,6 +11762,7 @@ self: { base bytestring conduit hashable hashtables JunkDB mtl resourcet ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JustParse" = callPackage @@ -11074,6 +11774,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple and comprehensive Haskell parsing library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "KMP" = callPackage @@ -11097,6 +11799,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A library with the kerbal space program universe and demo code"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Kalman" = callPackage @@ -11108,6 +11812,8 @@ self: { libraryHaskellDepends = [ base hmatrix ]; description = "A slightly extended Kalman filter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Kawaii-Parser" = callPackage @@ -11146,6 +11852,8 @@ self: { ]; description = "A super small web framework for those who don't like big and fancy codebases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "KiCS" = callPackage @@ -11244,6 +11952,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Category for Continuation Passing Style"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Kulitta" = callPackage @@ -11274,6 +11984,8 @@ self: { librarySystemDepends = [ kyotocabinet ]; description = "Kyoto Cabinet DB bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) kyotocabinet;}; "L-seed" = callPackage @@ -11291,6 +12003,8 @@ self: { ]; description = "Plant growing programming game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LATS" = callPackage @@ -11307,6 +12021,8 @@ self: { librarySystemDepends = [ openblasCompat ]; description = "Linear Algebra on Typed Spaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openblasCompat;}; "LC3" = callPackage @@ -11361,6 +12077,7 @@ self: { ]; description = "Lightweight Directory Access Protocol (LDAP) version 3"; license = lib.licenses.gpl2Plus; + hydraPlatforms = lib.platforms.none; }) {}; "LParse" = callPackage @@ -11384,6 +12101,8 @@ self: { libraryHaskellDepends = [ base containers QuickCheck ]; description = "Implements an LRU data structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LTS" = callPackage @@ -11404,6 +12123,8 @@ self: { benchmarkHaskellDepends = [ base criterion time ]; description = "LTS: Labelled Transition System"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LTree" = callPackage @@ -11464,6 +12185,7 @@ self: { ]; description = "A type-safe EDSL for TouchDesigner written in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "LambdaHack" = callPackage @@ -11518,6 +12240,7 @@ self: { ]; description = "Graphical Interaction Net Evaluator for Optimal Evaluation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "LambdaNet" = callPackage @@ -11533,6 +12256,8 @@ self: { ]; description = "A configurable and extensible neural network library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LambdaPrettyQuote" = callPackage @@ -11557,6 +12282,7 @@ self: { ]; description = "Quasiquoter, and Arbitrary helpers for the lambda calculus"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "LambdaShell" = callPackage @@ -11574,6 +12300,7 @@ self: { ]; description = "Simple shell for evaluating lambda expressions"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Lambdajudge" = callPackage @@ -11586,6 +12313,8 @@ self: { testHaskellDepends = [ base filepath hspec mtl process text ]; description = "A library to easily host Haskell based programming competitions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Lambdaya" = callPackage @@ -11602,6 +12331,8 @@ self: { ]; description = "Library for RedPitaya"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LargeCardinalHierarchy" = callPackage @@ -11630,6 +12361,8 @@ self: { ]; description = "A library for compiling programs in a variety of languages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Lattices" = callPackage @@ -11679,6 +12412,8 @@ self: { executableHaskellDepends = [ base directory filepath unix ]; description = "A simple sandboxing tool for Haskell packages"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Learning" = callPackage @@ -11694,6 +12429,8 @@ self: { testHaskellDepends = [ base containers hmatrix vector ]; description = "The most frequently used machine learning tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Level0" = callPackage @@ -11707,6 +12444,8 @@ self: { executableHaskellDepends = [ base directory random SDL SDL-ttf ]; description = "A Snake II clone written using SDL"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LibClang" = callPackage @@ -11727,6 +12466,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell bindings for libclang (a C++ parsing library)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (self.llvmPackages) clang; inherit (pkgs) ncurses;}; "LibZip" = callPackage @@ -11757,6 +12498,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Wrapper for data that can be unbounded"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LinearSplit" = callPackage @@ -11771,6 +12514,7 @@ self: { ]; description = "Partition the sequence of items to the subsequences in the order given"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "LinguisticsTypes" = callPackage @@ -11815,6 +12559,7 @@ self: { ]; description = "Check a bunch of local html files for broken links"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Liquorice" = callPackage @@ -11827,6 +12572,8 @@ self: { testHaskellDepends = [ base binary bytestring HTF mtl ]; description = "Algorithmic Doom map generation"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "List" = callPackage @@ -11879,6 +12626,8 @@ self: { ]; description = "List transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ListTree" = callPackage @@ -11931,6 +12680,8 @@ self: { doHaddock = false; description = "Converter to convert from .lhs to .md and vice versa."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Logic" = callPackage @@ -11942,6 +12693,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Logic"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "LogicGrowsOnTrees" = callPackage @@ -11978,6 +12731,7 @@ self: { benchmarkHaskellDepends = [ base cereal criterion deepseq ]; description = "a parallel implementation of logic programming using distributed tree exploration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "LogicGrowsOnTrees-MPI" = callPackage @@ -11999,6 +12753,7 @@ self: { librarySystemDepends = [ openmpi ]; description = "an adapter for LogicGrowsOnTrees that uses MPI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {openmpi = null;}; "LogicGrowsOnTrees-network" = callPackage @@ -12024,6 +12779,7 @@ self: { ]; description = "an adapter for LogicGrowsOnTrees that uses multiple processes running in a network"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "LogicGrowsOnTrees-processes" = callPackage @@ -12050,6 +12806,7 @@ self: { benchmarkHaskellDepends = [ base criterion LogicGrowsOnTrees ]; description = "an adapter for LogicGrowsOnTrees that uses multiple processes for parallelism"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "LslPlus" = callPackage @@ -12070,6 +12827,7 @@ self: { ]; description = "An execution and testing framework for the Linden Scripting Language (LSL)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Lucu" = callPackage @@ -12090,6 +12848,7 @@ self: { ]; description = "HTTP Daemonic Library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "Lykah" = callPackage @@ -12118,6 +12877,7 @@ self: { ]; description = "A static website and blog generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "MASMGen" = callPackage @@ -12130,6 +12890,8 @@ self: { testHaskellDepends = [ base containers mtl ]; description = "Generate MASM code from haskell"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MBot" = callPackage @@ -12141,6 +12903,8 @@ self: { libraryHaskellDepends = [ base bytestring hidapi mtl ]; description = "Haskell interface for controlling the mBot educational robot"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MC-Fold-DP" = callPackage @@ -12159,6 +12923,7 @@ self: { executableHaskellDepends = [ cmdargs split ]; description = "Folding algorithm based on nucleotide cyclic motifs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "MFlow" = callPackage @@ -12184,6 +12949,7 @@ self: { libraryToolDepends = [ cpphs ]; description = "stateful, RESTful web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MHask" = callPackage @@ -12195,6 +12961,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "The category of monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MIP" = callPackage @@ -12222,6 +12990,8 @@ self: { ]; description = "Library for using Mixed Integer Programming (MIP)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MIP-glpk" = callPackage @@ -12246,6 +13016,7 @@ self: { ]; description = "A GLPK backend to the MIP library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) glpk;}; "MSQueue" = callPackage @@ -12257,6 +13028,7 @@ self: { libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ]; description = "Michael-Scott queue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MTGBuilder" = callPackage @@ -12270,6 +13042,8 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Builds decks out of a meta"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MagicHaskeller" = callPackage @@ -12299,6 +13073,8 @@ self: { ]; description = "Automatic inductive functional programmer by systematic search"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MailchimpSimple" = callPackage @@ -12317,6 +13093,8 @@ self: { ]; description = "Haskell library to interact with Mailchimp JSON API Version 3.0"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Map" = callPackage @@ -12333,6 +13111,8 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Class of key-value maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MapWith" = callPackage @@ -12357,6 +13137,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Mapping"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MaybeT" = callPackage @@ -12370,6 +13152,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "MaybeT monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MaybeT-monads-tf" = callPackage @@ -12381,6 +13165,8 @@ self: { libraryHaskellDepends = [ base monads-tf transformers ]; description = "MaybeT monad transformer compatible with monads-tf (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MaybeT-transformers" = callPackage @@ -12392,6 +13178,7 @@ self: { libraryHaskellDepends = [ base monads-fd transformers ]; description = "MaybeT monad transformer using transformers instead of mtl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MazesOfMonad" = callPackage @@ -12411,6 +13198,8 @@ self: { ]; description = "Console-based Role Playing Game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MeanShift" = callPackage @@ -12422,6 +13211,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Mean shift algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Measure" = callPackage @@ -12433,6 +13224,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for units of measurement"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Mecha" = callPackage @@ -12444,6 +13237,8 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Mechs" = callPackage @@ -12455,6 +13250,8 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MemoTrie" = callPackage @@ -12483,6 +13280,8 @@ self: { ]; description = "Statically checked database access"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MetaObject" = callPackage @@ -12494,6 +13293,7 @@ self: { libraryHaskellDepends = [ base containers stringtable-atom ]; description = "A meta-object system for Haskell based on Perl 6"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Metrics" = callPackage @@ -12505,6 +13305,7 @@ self: { libraryHaskellDepends = [ base hstats ]; description = "Evaluation metrics commonly used in supervised machine learning"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Mhailist" = callPackage @@ -12523,6 +13324,7 @@ self: { ]; description = "Haskell mailing list manager"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Michelangelo" = callPackage @@ -12539,6 +13341,7 @@ self: { ]; description = "OpenGL for dummies"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "MicrosoftTranslator" = callPackage @@ -12555,6 +13358,7 @@ self: { ]; description = "Interface for Microsoft Translator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MiniAgda" = callPackage @@ -12637,6 +13441,7 @@ self: { libraryHaskellDepends = [ anydbm base MissingH ]; description = "Haskell interface to Python"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Mobile-Legends-Hack-Cheats" = callPackage @@ -12659,6 +13464,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Modulo" = callPackage @@ -12684,6 +13491,8 @@ self: { executableHaskellDepends = [ base GLUT random ]; description = "A FRP library based on signal functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MoeDict" = callPackage @@ -12699,6 +13508,8 @@ self: { ]; description = "Utilities working with MoeDict.tw JSON dataset"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MonadCatchIO-mtl" = callPackage @@ -12714,6 +13525,7 @@ self: { ]; description = "Monad-transformer version of the Control.Exception module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MonadCatchIO-mtl-foreign" = callPackage @@ -12725,6 +13537,7 @@ self: { libraryHaskellDepends = [ base MonadCatchIO-mtl mtl primitive ]; description = "Polymorphic combinators for working with foreign functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MonadCatchIO-transformers" = callPackage @@ -12740,6 +13553,8 @@ self: { ]; description = "Monad-transformer compatible version of the Control.Exception module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MonadCatchIO-transformers-foreign" = callPackage @@ -12755,6 +13570,7 @@ self: { ]; description = "Polymorphic combinators for working with foreign functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MonadCompose" = callPackage @@ -12766,6 +13582,8 @@ self: { libraryHaskellDepends = [ base free mmorph mtl transformers ]; description = "Methods for composing monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MonadLab" = callPackage @@ -12782,6 +13600,7 @@ self: { executableHaskellDepends = [ base haskell98 process ]; description = "Automatically generate layered monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MonadPrompt" = callPackage @@ -12832,6 +13651,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Generalizing lift to monad stacks"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Monadius" = callPackage @@ -12846,6 +13667,8 @@ self: { executableHaskellDepends = [ array base directory GLUT OpenGL ]; description = "2-D arcade scroller"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Monadoro" = callPackage @@ -12861,6 +13684,8 @@ self: { testHaskellDepends = [ ansi-terminal base doctest process time ]; description = "A minimalistic CLI Pomodoro timer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Monaris" = callPackage @@ -12879,6 +13704,7 @@ self: { ]; description = "A simple tetris clone"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Monatron" = callPackage @@ -12890,6 +13716,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Monad transformer library with uniform liftings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Monatron-IO" = callPackage @@ -12901,6 +13729,7 @@ self: { libraryHaskellDepends = [ base Monatron transformers ]; description = "MonadIO instances for the Monatron transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Monocle" = callPackage @@ -12912,6 +13741,7 @@ self: { libraryHaskellDepends = [ base containers haskell98 mtl ]; description = "Symbolic computations in strict monoidal categories with LaTeX output"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "MorseCode" = callPackage @@ -12943,6 +13773,8 @@ self: { ]; description = "Automated Mutation Testing"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MuCheck-HUnit" = callPackage @@ -12957,6 +13789,7 @@ self: { executableHaskellDepends = [ base HUnit MuCheck ]; description = "Automated Mutation Testing for HUnit tests"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "MuCheck-Hspec" = callPackage @@ -12971,6 +13804,7 @@ self: { executableHaskellDepends = [ base hspec hspec-core MuCheck ]; description = "Automated Mutation Testing for Hspec tests"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "MuCheck-QuickCheck" = callPackage @@ -12985,6 +13819,7 @@ self: { executableHaskellDepends = [ base MuCheck QuickCheck ]; description = "Automated Mutation Testing for QuickCheck tests"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "MuCheck-SmallCheck" = callPackage @@ -12999,6 +13834,7 @@ self: { executableHaskellDepends = [ base MuCheck smallcheck ]; description = "Automated Mutation Testing for SmallCheck tests"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "Munkres" = callPackage @@ -13021,6 +13857,8 @@ self: { libraryHaskellDepends = [ array base bimap containers Munkres ]; description = "Simple and typesafe layer over the Munkres package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "MusicBrainz" = callPackage @@ -13087,6 +13925,7 @@ self: { ]; description = "Most likely order of mutation events in RNA"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "MyPrimes" = callPackage @@ -13102,6 +13941,8 @@ self: { benchmarkHaskellDepends = [ base time ]; description = "Generate all primes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NGrams" = callPackage @@ -13115,6 +13956,8 @@ self: { executableHaskellDepends = [ base HCL HTTP network regex-compat ]; description = "Simple application for calculating n-grams using Google"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NMap" = callPackage @@ -13126,6 +13969,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A transparent nested Map structure"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NTRU" = callPackage @@ -13166,6 +14011,7 @@ self: { ]; description = "A Haskell interface to Lego Mindstorms NXT"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {bluetooth = null;}; "NXTDSL" = callPackage @@ -13184,6 +14030,8 @@ self: { ]; description = "Generate NXC Code from DSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NaCl" = callPackage @@ -13232,6 +14080,8 @@ self: { executableHaskellDepends = [ base uu-parsinglib ]; description = "Very small interpreter for a Prolog-like language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Naperian" = callPackage @@ -13258,6 +14108,7 @@ self: { executableHaskellDepends = [ base hnetcdf Naperian split ]; description = "Instances of NcStore for hypercuboids"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "NaturalLanguageAlphabets" = callPackage @@ -13287,6 +14138,8 @@ self: { ]; description = "Simple scoring schemes for word alignments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NaturalSort" = callPackage @@ -13300,6 +14153,8 @@ self: { libraryHaskellDepends = [ base bytestring strict ]; description = "Natural sorting for strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NearContextAlgebra" = callPackage @@ -13317,6 +14172,7 @@ self: { ]; description = "Context Algebra of near"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Neks" = callPackage @@ -13339,6 +14195,8 @@ self: { ]; description = "Simple networked key/value store"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NestedFunctor" = callPackage @@ -13350,6 +14208,8 @@ self: { libraryHaskellDepends = [ base comonad distributive ]; description = "Nested composition of functors with a type index tracking nesting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NestedSampling" = callPackage @@ -13374,6 +14234,8 @@ self: { testHaskellDepends = [ base bytestring HUnit process ]; description = "Bindings for net-snmp's C API for clients"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {net_snmp = null;}; "Network-NineP" = callPackage @@ -13437,6 +14299,7 @@ self: { ]; description = "Ninja game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "NoHoed" = callPackage @@ -13467,6 +14330,7 @@ self: { ]; description = "Microbenchmarks for various array libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "NoTrace" = callPackage @@ -13479,6 +14343,8 @@ self: { testHaskellDepends = [ base ]; description = "Remove all the functions come from Debug.Trace after debugging"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Noise" = callPackage @@ -13509,6 +14375,7 @@ self: { ]; description = "A Nomic game in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Nomyx-Core" = callPackage @@ -13535,6 +14402,7 @@ self: { ]; description = "A Nomic game in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Nomyx-Language" = callPackage @@ -13554,6 +14422,7 @@ self: { ]; description = "Language to express rules for Nomic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Nomyx-Rules" = callPackage @@ -13571,6 +14440,7 @@ self: { ]; description = "Language to express rules for Nomic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Nomyx-Web" = callPackage @@ -13595,6 +14465,7 @@ self: { ]; description = "Web gui for Nomyx"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "NonEmpty" = callPackage @@ -13606,6 +14477,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Library providing a non-empty list datatype, and total functions operating on it"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NonEmptyList" = callPackage @@ -13622,6 +14495,7 @@ self: { ]; description = "A list with a length of at least one"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "NumInstances" = callPackage @@ -13655,6 +14529,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Number Theoretic Sieves: primes, factorization, and Euler's Totient"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "NumberTheory" = callPackage @@ -13667,6 +14543,8 @@ self: { testHaskellDepends = [ base containers HUnit primes ]; description = "A library for number theoretic computations, written in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Numbers" = callPackage @@ -13695,6 +14573,7 @@ self: { ]; description = "Nussinov78 using the ADPfusion library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Nutri" = callPackage @@ -13706,6 +14585,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A little library to calculate nutrition values of food items"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OGL" = callPackage @@ -13717,6 +14598,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A context aware binding for the OpenGL graphics system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ONC-RPC" = callPackage @@ -13741,6 +14624,8 @@ self: { executableHaskellDepends = [ base filepath ]; description = "ONC RPC (aka Sun RPC) and XDR library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OSM" = callPackage @@ -13756,6 +14641,7 @@ self: { ]; description = "Parse OpenStreetMap files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "OTP" = callPackage @@ -13775,6 +14661,8 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hunit time ]; description = "HMAC-Based and Time-Based One-Time Passwords (HOTP & TOTP)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Object" = callPackage @@ -13786,6 +14674,8 @@ self: { libraryHaskellDepends = [ base containers ghc template-haskell ]; description = "Object oriented programming for haskell using multiparameter typeclasses"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ObjectIO" = callPackage @@ -13801,6 +14691,8 @@ self: { winspool ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {comctl32 = null; comdlg32 = null; gdi32 = null; kernel32 = null; ole32 = null; shell32 = null; user32 = null; winmm = null; winspool = null;}; @@ -13849,6 +14741,8 @@ self: { ]; description = "Simple unbalanced Octree for storing data about 3D points"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OddWord" = callPackage @@ -13862,6 +14756,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Provides a wrapper for deriving word types with fewer bits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Omega" = callPackage @@ -13874,6 +14770,8 @@ self: { testHaskellDepends = [ base containers HUnit ]; description = "Integer sets and relations using Presburger arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OnRmt" = callPackage @@ -13910,6 +14808,7 @@ self: { ]; description = "Text UI library for performing parallel remote SSH operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "OneTuple" = callPackage @@ -13952,6 +14851,8 @@ self: { ]; description = "IBM AFP document format parser and generator"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OpenAFP-Utils" = callPackage @@ -13972,6 +14873,7 @@ self: { ]; description = "Assorted utilities to work with AFP data streams"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "OpenAL" = callPackage @@ -14004,6 +14906,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Haskell high-level wrapper for OpenCL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {OpenCL = null;}; "OpenCLRaw" = callPackage @@ -14015,6 +14919,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "The OpenCL Standard for heterogenous data-parallel computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OpenCLWrappers" = callPackage @@ -14026,6 +14932,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "The OpenCL Standard for heterogenous data-parallel computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OpenGL" = callPackage @@ -14057,6 +14965,7 @@ self: { ]; description = "Quickcheck instances for various data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "OpenGLRaw" = callPackage @@ -14104,6 +15013,7 @@ self: { ]; description = "ADT wrapper and renderer for OpenSCAD models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "OpenVG" = callPackage @@ -14115,6 +15025,7 @@ self: { libraryHaskellDepends = [ base GLUT OpenGL OpenGLRaw OpenVGRaw ]; description = "OpenVG (ShivaVG-0.2.1) binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "OpenVGRaw" = callPackage @@ -14126,6 +15037,8 @@ self: { libraryHaskellDepends = [ base OpenGLRaw ]; description = "Raw binding to OpenVG (ShivaVG-0.2.1 implementation)."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Operads" = callPackage @@ -14137,6 +15050,8 @@ self: { libraryHaskellDepends = [ array base containers mtl ]; description = "Groebner basis computation for Operads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OptDir" = callPackage @@ -14164,6 +15079,8 @@ self: { ]; description = "A quasiquoter for or-patterns"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OrchestrateDB" = callPackage @@ -14183,6 +15100,8 @@ self: { ]; description = "Unofficial Haskell Client Library for the Orchestrate.io API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "OrderedBits" = callPackage @@ -14228,6 +15147,8 @@ self: { testHaskellDepends = [ base safe threepenny-gui ]; description = "A Programming Language in Construction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Oslo-Vectize" = callPackage @@ -14243,6 +15164,8 @@ self: { executableHaskellDepends = [ base ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PArrows" = callPackage @@ -14267,6 +15190,8 @@ self: { libraryHaskellDepends = [ base binary bytestring Crypto random ]; description = "Make password-based security schemes more secure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PCLT" = callPackage @@ -14280,6 +15205,8 @@ self: { ]; description = "Extension to Show: templating, catalogizing, languages, parameters, etc"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PCLT-DB" = callPackage @@ -14296,6 +15223,7 @@ self: { ]; description = "An addon to PCLT package: enchance PCLT catalog with PostgreSQL powers"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "PDBtools" = callPackage @@ -14320,6 +15248,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A generic derivable Haskell pretty printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PSQueue" = callPackage @@ -14350,6 +15280,8 @@ self: { ]; description = "An implementation of Montague's PTQ"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PUH-Project" = callPackage @@ -14369,6 +15301,8 @@ self: { ]; description = "This is a package which includes Assignments, Email, User and Reviews modules for Programming in Haskell course"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PageIO" = callPackage @@ -14395,6 +15329,7 @@ self: { ]; description = "Page-oriented extraction and composition library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Paillier" = callPackage @@ -14413,6 +15348,8 @@ self: { ]; description = "a simple Paillier cryptosystem"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PandocAgda" = callPackage @@ -14433,6 +15370,8 @@ self: { executableHaskellDepends = [ base ]; description = "Pandoc support for literate Agda"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Paraiso" = callPackage @@ -14457,6 +15396,7 @@ self: { ]; description = "a code generator for partial differential equations solvers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Parallel-Arrows-BaseSpec" = callPackage @@ -14506,6 +15446,7 @@ self: { ]; description = "Eden based backend for @Parallel-Arrows-Definition@"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Parallel-Arrows-Multicore" = callPackage @@ -14561,6 +15502,8 @@ self: { ]; description = "A proven synchronization server for high performance computing"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ParsecTools" = callPackage @@ -14605,6 +15548,8 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Simple library for generating passwords"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PastePipe" = callPackage @@ -14635,6 +15580,8 @@ self: { ]; description = "A tree used to merge and maintain paths"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Pathfinder" = callPackage @@ -14647,6 +15594,8 @@ self: { librarySystemDepends = [ libxml2 ]; description = "Relational optimiser and code generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libxml2;}; "Peano" = callPackage @@ -14669,6 +15618,8 @@ self: { libraryHaskellDepends = [ base ]; description = "GADT type witnesses for Peano-style natural numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PerfectHash" = callPackage @@ -14685,6 +15636,8 @@ self: { librarySystemDepends = [ cmph ]; description = "A perfect hashing library for mapping bytestrings to values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {cmph = null;}; "PermuteEffects" = callPackage @@ -14696,6 +15649,7 @@ self: { libraryHaskellDepends = [ base ReplicateEffects ]; description = "Permutations of effectful computations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Persistence" = callPackage @@ -14714,6 +15668,8 @@ self: { ]; description = "A versatile library for topological data analysis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Phsu" = callPackage @@ -14738,6 +15694,8 @@ self: { ]; description = "Personal Happstack Server Utils"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Pipe" = callPackage @@ -14749,6 +15707,8 @@ self: { libraryHaskellDepends = [ base filepath process unix ]; description = "Process piping library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Piso" = callPackage @@ -14760,6 +15720,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Partial isomorphisms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PlayHangmanGame" = callPackage @@ -14793,6 +15755,8 @@ self: { ]; description = "Playing cards api"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Plot-ho-matic" = callPackage @@ -14814,6 +15778,7 @@ self: { ]; description = "Real-time line plotter for generic data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "PlslTools" = callPackage @@ -14833,6 +15798,7 @@ self: { ]; description = "So far just a lint like program for PL/SQL. Diff and refactoring tools are planned"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Plural" = callPackage @@ -14857,6 +15823,8 @@ self: { executableHaskellDepends = [ array base clock GLUT random ]; description = "An imaginary world"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PortFusion" = callPackage @@ -14870,6 +15838,8 @@ self: { executableHaskellDepends = [ base bytestring network splice ]; description = "high-performance distributed reverse / forward proxy & tunneling for TCP"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PortMidi" = callPackage @@ -14929,6 +15899,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A Prelude module replacement"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PrimitiveArray" = callPackage @@ -14984,6 +15956,8 @@ self: { ]; description = "Pretty-printing for primitive arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Printf-TH" = callPackage @@ -14994,6 +15968,7 @@ self: { sha256 = "0n1gva510p69vy25zvjkzwqqz2gilbns1wnrzz2p22rjkkbrinvx"; libraryHaskellDepends = [ base haskell98 pretty template-haskell ]; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "PriorityChansConverger" = callPackage @@ -15005,6 +15980,8 @@ self: { libraryHaskellDepends = [ base containers stm ]; description = "Read single output from an array of inputs - channels with priorities"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ProbabilityMonads" = callPackage @@ -15016,6 +15993,7 @@ self: { libraryHaskellDepends = [ base MaybeT MonadRandom mtl ]; description = "Probability distribution monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Probnet" = callPackage @@ -15055,6 +16033,8 @@ self: { executableHaskellDepends = [ base containers HUnit parsec syb ]; description = "An implementation of propositional logic in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ProxN" = callPackage @@ -15090,6 +16070,7 @@ self: { ]; description = "A Perl 6 Implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Pup-Events" = callPackage @@ -15109,6 +16090,7 @@ self: { doHaddock = false; description = "A networked event handling framework for hooking into other programs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Pup-Events-Client" = callPackage @@ -15142,6 +16124,7 @@ self: { ]; description = "A networked event handling framework for hooking into other programs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Pup-Events-PQueue" = callPackage @@ -15168,6 +16151,8 @@ self: { ]; description = "A networked event handling framework for hooking into other programs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "PyF" = callPackage @@ -15201,6 +16186,8 @@ self: { libraryHaskellDepends = [ base containers mtl old-time random ]; description = "The Quantum IO Monad is a library for defining quantum computations in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "QLearn" = callPackage @@ -15212,6 +16199,8 @@ self: { libraryHaskellDepends = [ base random vector ]; description = "A library for fast, easy-to-use Q-learning"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "QuadEdge" = callPackage @@ -15223,6 +16212,8 @@ self: { libraryHaskellDepends = [ base random vector ]; description = "QuadEdge structure for representing triangulations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "QuadTree" = callPackage @@ -15235,6 +16226,8 @@ self: { testHaskellDepends = [ base composition lens QuickCheck ]; description = "QuadTree library for Haskell, with lens support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "QuasiText" = callPackage @@ -15270,6 +16263,7 @@ self: { ]; description = "Programming with Eventual Consistency over Cassandra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "QuickAnnotate" = callPackage @@ -15284,6 +16278,8 @@ self: { executableHaskellDepends = [ base haskell-src-exts ]; description = "Annotation Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "QuickCheck" = callPackage @@ -15337,6 +16333,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Generator of \"valid\" and \"invalid\" data in a type class"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "QuickPlot" = callPackage @@ -15360,6 +16358,8 @@ self: { ]; description = "Quick and easy data visualization with Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Quickson" = callPackage @@ -15374,6 +16374,8 @@ self: { ]; description = "Quick JSON extractions with Aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "R-pandoc" = callPackage @@ -15391,6 +16393,8 @@ self: { ]; executableHaskellDepends = [ base pandoc-types ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "RANSAC" = callPackage @@ -15466,6 +16470,8 @@ self: { ]; description = "A reflective JSON serializer/parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "RLP" = callPackage @@ -15478,6 +16484,8 @@ self: { testHaskellDepends = [ base binary bytestring hspec ]; description = "RLP serialization as defined in Ethereum Yellow Paper"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "RMP" = callPackage @@ -15498,6 +16506,7 @@ self: { executableSystemDepends = [ canlib ftd2xx ]; description = "Binding to code that controls a Segway RMP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {canlib = null; ftd2xx = null;}; "RNAFold" = callPackage @@ -15520,6 +16529,7 @@ self: { ]; description = "RNA secondary structure prediction"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "RNAFoldProgs" = callPackage @@ -15539,6 +16549,7 @@ self: { ]; description = "RNA secondary structure folding"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "RNAdesign" = callPackage @@ -15564,6 +16575,7 @@ self: { executableHaskellDepends = [ bytestring cmdargs file-embed ]; description = "Multi-target RNA sequence design"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "RNAdraw" = callPackage @@ -15583,6 +16595,7 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "Draw RNA secondary structures"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "RNAlien" = callPackage @@ -15615,6 +16628,7 @@ self: { ]; description = "Unsupervized construction of RNA family models"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "RNAwolf" = callPackage @@ -15635,6 +16649,7 @@ self: { executableHaskellDepends = [ cmdargs split ]; description = "RNA folding with non-canonical basepairs and base-triplets"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "RSA" = callPackage @@ -15689,6 +16704,8 @@ self: { ]; description = "AMQP 0-9-1 client library for RabbitMQ servers"; license = "BSD-3-Clause AND GPL-3.0-or-later"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Raincat" = callPackage @@ -15741,6 +16758,8 @@ self: { libraryHaskellDepends = [ base HTTP-Simple network ]; description = "Interface to random.org"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Randometer" = callPackage @@ -15765,6 +16784,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Data structure for managing ranges"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Ranged-sets" = callPackage @@ -15795,6 +16816,7 @@ self: { ]; description = "HTTP to XMPP omegle chats gate"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Rasenschach" = callPackage @@ -15815,6 +16837,8 @@ self: { ]; description = "Soccer simulation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Rasterific" = callPackage @@ -15887,6 +16911,8 @@ self: { ]; description = "Library to access Redmine's REST services"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Ref" = callPackage @@ -15898,6 +16924,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Generic Mutable Ref Abstraction Layer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "RefSerialize" = callPackage @@ -15933,6 +16961,8 @@ self: { ]; description = "A utility for computing distributions of material to review among reviewers"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "RepLib" = callPackage @@ -15948,6 +16978,8 @@ self: { ]; description = "Generic programming library with representation types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ReplicateEffects" = callPackage @@ -15959,6 +16991,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Composable replication schemes of applicative functors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ReviewBoard" = callPackage @@ -15977,6 +17011,8 @@ self: { ]; description = "Haskell bindings to ReviewBoard"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "RichConditional" = callPackage @@ -15988,6 +17024,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Tiny library to replace classic if/else"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Ritt-Wu" = callPackage @@ -16016,6 +17054,8 @@ self: { ]; description = "Parallel implementation of Ritt-Wu's algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Rlang-QQ" = callPackage @@ -16039,6 +17079,7 @@ self: { testHaskellDepends = [ base directory doctest hspec lens vector ]; description = "quasiquoter for inline-R code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "RollingDirectory" = callPackage @@ -16063,6 +17104,7 @@ self: { ]; description = "Limits the size of a directory's contents"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "RoyalMonad" = callPackage @@ -16092,6 +17134,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit vector ]; description = "Haskell wrapper for RtMidi, the lightweight, cross-platform MIDI I/O library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) alsaLib;}; "RxHaskell" = callPackage @@ -16103,6 +17147,8 @@ self: { libraryHaskellDepends = [ base containers stm transformers ]; description = "Reactive Extensions for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "S3" = callPackage @@ -16123,6 +17169,7 @@ self: { ]; description = "Library for accessing S3 compatible storage services"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; }) {}; "SBench" = callPackage @@ -16140,6 +17187,7 @@ self: { ]; description = "A benchmark suite for runtime and heap measurements over a series of inputs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SCRIPTWriter" = callPackage @@ -16159,6 +17207,7 @@ self: { executableHaskellDepends = [ base ]; description = "ESCRIPT: a human friendly language for programming Bitcoin scripts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SCalendar" = callPackage @@ -16175,6 +17224,7 @@ self: { ]; description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "SDL" = callPackage @@ -16290,6 +17340,8 @@ self: { ]; description = "SFML bindings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {csfml-audio = null; csfml-graphics = null; csfml-network = null; csfml-system = null; csfml-window = null; sfml-audio = null; sfml-graphics = null; sfml-network = null; @@ -16304,6 +17356,7 @@ self: { libraryHaskellDepends = [ base mtl SFML template-haskell ]; description = "Higher level library on top of SFML"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "SFont" = callPackage @@ -16315,6 +17368,7 @@ self: { libraryHaskellDepends = [ array base SDL Sprig ]; description = "SFont SDL Bitmap Fonts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SG" = callPackage @@ -16326,6 +17380,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Small geometry library for dealing with vectors and collision detection"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SGdemo" = callPackage @@ -16339,6 +17395,7 @@ self: { executableHaskellDepends = [ base GLUT OpenGL SG ]; description = "An example of using the SG and OpenGL libraries"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "SGplus" = callPackage @@ -16350,6 +17407,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "(updated) Small geometry library for dealing with vectors and collision detection"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SHA" = callPackage @@ -16405,6 +17464,8 @@ self: { benchmarkHaskellDepends = [ base directory filepath random time ]; description = "The Simple Javascript Wrench"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SMTPClient" = callPackage @@ -16421,6 +17482,8 @@ self: { ]; description = "A simple SMTP client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SNet" = callPackage @@ -16437,6 +17500,8 @@ self: { libraryToolDepends = [ c2hsc ]; description = "Declarative coördination language for streaming networks"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SQLDeps" = callPackage @@ -16467,6 +17532,8 @@ self: { testHaskellDepends = [ base containers ]; description = "STG Symbolic Execution"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "STL" = callPackage @@ -16478,6 +17545,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring cereal text ]; description = "STL 3D geometry format parsing and pretty-printing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "STLinkUSB" = callPackage @@ -16493,6 +17562,7 @@ self: { ]; description = "STLink USB interface in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "STM32-Zombie" = callPackage @@ -16509,6 +17579,7 @@ self: { ]; description = "control a STM32F103 microcontroller"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "STM32F103xx-SVD" = callPackage @@ -16551,6 +17622,8 @@ self: { ]; description = "translate a SVD of a Microcontroller to Haskell tables"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SVG2Q" = callPackage @@ -16568,6 +17641,7 @@ self: { ]; description = "Code generation tool for Quartz code from a SVG"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SVGFonts" = callPackage @@ -16634,6 +17708,8 @@ self: { ]; description = "Generate a parser (in Haskell) with the SableCC parser generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Safe" = callPackage @@ -16671,6 +17747,8 @@ self: { librarySystemDepends = [ glib mono ]; description = "A .NET Bridge for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) glib; inherit (pkgs) mono;}; "Saturnin" = callPackage @@ -16694,6 +17772,8 @@ self: { testHaskellDepends = [ base data-default either hlint hspec mtl ]; description = "Saturnin CI / Job System"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SciBaseTypes" = callPackage @@ -16722,6 +17802,8 @@ self: { ]; description = "Base types and classes for statistics, sciences and humanities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SciFlow" = callPackage @@ -16746,6 +17828,7 @@ self: { ]; description = "Scientific workflow management system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "SciFlow-drmaa" = callPackage @@ -16762,6 +17845,7 @@ self: { ]; description = "Scientific workflow management system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ScratchFs" = callPackage @@ -16780,6 +17864,8 @@ self: { ]; description = "Size limited temp filesystem based on fuse"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Scurry" = callPackage @@ -16798,6 +17884,7 @@ self: { ]; description = "A cross platform P2P VPN application built using Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SecureHash-SHA3" = callPackage @@ -16811,6 +17898,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "simple static linked SHA3 using private symbols and the ref impl"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SegmentTree" = callPackage @@ -16848,6 +17937,7 @@ self: { ]; description = "Selects a representative subset of sequences from multiple sequence alignment"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Semantique" = callPackage @@ -16866,6 +17956,7 @@ self: { ]; description = "Command-line tool for maintaining the Semantique database"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "Semigroup" = callPackage @@ -16877,6 +17968,8 @@ self: { libraryHaskellDepends = [ base bytestring containers mtl ]; description = "A semigroup"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SeqAlign" = callPackage @@ -16888,6 +17981,8 @@ self: { libraryHaskellDepends = [ base bytestring vector ]; description = "Sequence Alignment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SessionLogger" = callPackage @@ -16903,6 +17998,8 @@ self: { ]; description = "Easy Loggingframework"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Set" = callPackage @@ -16916,6 +18013,8 @@ self: { benchmarkHaskellDepends = [ base containers gauge util ]; description = "See README for more info"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ShellCheck_0_7_1" = callPackage @@ -16984,6 +18083,8 @@ self: { libraryHaskellDepends = [ base directory mtl unix ]; description = "A framework for creating shell envinronments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Shellac-compatline" = callPackage @@ -16997,6 +18098,7 @@ self: { libraryHaskellDepends = [ base Shellac Shellac-readline ]; description = "\"compatline\" backend module for Shellac"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shellac-editline" = callPackage @@ -17010,6 +18112,7 @@ self: { libraryHaskellDepends = [ base editline Shellac ]; description = "Editline backend module for Shellac"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shellac-haskeline" = callPackage @@ -17021,6 +18124,7 @@ self: { libraryHaskellDepends = [ base haskeline mtl Shellac ]; description = "Haskeline backend module for Shellac"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shellac-readline" = callPackage @@ -17034,6 +18138,7 @@ self: { libraryHaskellDepends = [ base readline Shellac ]; description = "Readline backend module for Shellac"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ShortestPathProblems" = callPackage @@ -17054,6 +18159,7 @@ self: { ]; description = "grammars for TSP and SHP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ShowF" = callPackage @@ -17100,6 +18206,7 @@ self: { ]; description = "A Virtual Dom in pure Haskell, based on Html as an Alignable Functor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-backend-snabbdom" = callPackage @@ -17117,6 +18224,8 @@ self: { ]; description = "Use the high-performance Snabbdom virtual dom library written in JavaScript"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Shpadoinkle-backend-static" = callPackage @@ -17128,6 +18237,7 @@ self: { libraryHaskellDepends = [ base compactable Shpadoinkle text ]; description = "A backend for rendering Shpadoinkle as Text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-console" = callPackage @@ -17173,6 +18283,7 @@ self: { ]; description = "Chrome extension to aide in development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-disembodied" = callPackage @@ -17191,6 +18302,7 @@ self: { ]; description = "Shpadoinkle as a static site"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-examples" = callPackage @@ -17222,6 +18334,7 @@ self: { ]; description = "Example usages of Shpadoinkle"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-html" = callPackage @@ -17240,6 +18353,7 @@ self: { ]; description = "A typed, template generated Html DSL, and helpers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-lens" = callPackage @@ -17274,6 +18388,7 @@ self: { ]; description = "A single page application rounter for Shpadoinkle based on Servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-streaming" = callPackage @@ -17285,6 +18400,8 @@ self: { libraryHaskellDepends = [ base lens Shpadoinkle streaming text ]; description = "Integration of the streaming library with Shpadoinkle continuations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Shpadoinkle-template" = callPackage @@ -17305,6 +18422,7 @@ self: { ]; description = "Read standard file formats into Shpadoinkle with Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shpadoinkle-widgets" = callPackage @@ -17328,6 +18446,7 @@ self: { ]; description = "A collection of common reusable types and components"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Shrub" = callPackage @@ -17390,6 +18509,7 @@ self: { ]; description = "A Simple Graphics Library from the SimpleH framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SimpleH" = callPackage @@ -17426,6 +18546,7 @@ self: { ]; description = "Simple, configurable logging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SimpleServer" = callPackage @@ -17446,6 +18567,7 @@ self: { ]; description = "A simple static file server, for when apache is overkill"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "SimpleTableGenerator" = callPackage @@ -17506,6 +18628,8 @@ self: { testHaskellDepends = [ base file-embed ]; description = "Generate slides from Haskell code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Smooth" = callPackage @@ -17521,6 +18645,7 @@ self: { ]; description = "A tiny, lazy SMT solver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SmtLib" = callPackage @@ -17532,6 +18657,8 @@ self: { libraryHaskellDepends = [ base parsec transformers ]; description = "Library for parsing SMTLIB2"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Snusmumrik" = callPackage @@ -17554,6 +18681,7 @@ self: { executableToolDepends = [ cpphs ]; description = "E-library directory based on FUSE virtual file system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) zip;}; "SoOSiM" = callPackage @@ -17570,6 +18698,8 @@ self: { ]; description = "Abstract full system simulator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SoccerFun" = callPackage @@ -17589,6 +18719,7 @@ self: { ]; description = "Football simulation framework for teaching functional programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "SoccerFunGL" = callPackage @@ -17608,6 +18739,7 @@ self: { ]; description = "OpenGL UI for the SoccerFun framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Sonnex" = callPackage @@ -17620,6 +18752,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Sonnex is an alternative to Soundex for french language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SourceGraph" = callPackage @@ -17670,6 +18804,8 @@ self: { executableHaskellDepends = [ array base HGL random Yampa ]; description = "Video game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SpacePrivateers" = callPackage @@ -17691,6 +18827,8 @@ self: { ]; description = "Simple space pirate roguelike"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SpinCounter" = callPackage @@ -17702,6 +18840,7 @@ self: { libraryHaskellDepends = [ base monad-loops ref-mtl stm ]; description = "Lock free Spin Counter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Spintax" = callPackage @@ -17740,6 +18879,8 @@ self: { ]; description = "Another Haskell web framework for rapid development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Spock-api" = callPackage @@ -17766,6 +18907,8 @@ self: { ]; description = "Another Haskell web framework for rapid development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Spock-api-server" = callPackage @@ -17788,6 +18931,7 @@ self: { libraryHaskellDepends = [ base http-types Spock text time ]; description = "Provides authentification helpers for Spock"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Spock-core" = callPackage @@ -17843,6 +18987,7 @@ self: { libraryHaskellDepends = [ base lucid Spock transformers ]; description = "Lucid support for Spock"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Spock-worker" = callPackage @@ -17860,6 +19005,7 @@ self: { testHaskellDepends = [ base containers HTF stm vector ]; description = "Background workers for Spock"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "SpreadsheetML" = callPackage @@ -17882,6 +19028,8 @@ self: { libraryHaskellDepends = [ base SDL ]; description = "Binding to Sprig"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Stack" = callPackage @@ -17909,6 +19057,8 @@ self: { executableHaskellDepends = [ base ]; description = "A simple MVCC like library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "StateVar" = callPackage @@ -17958,6 +19108,7 @@ self: { ]; description = "Libary for Stockholm aligmnent format"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Stomp" = callPackage @@ -17973,6 +19124,8 @@ self: { ]; description = "Client library for Stomp brokers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Strafunski-ATermLib" = callPackage @@ -17984,6 +19137,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "An abstract data type designed for the exchange of tree-like data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Strafunski-Sdf2Haskell" = callPackage @@ -18003,6 +19158,7 @@ self: { ]; description = "Converts SDF to Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Strafunski-StrategyLib" = callPackage @@ -18016,6 +19172,8 @@ self: { libraryHaskellDepends = [ base directory mtl syb transformers ]; description = "Library for strategic programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "StrappedTemplates" = callPackage @@ -18033,6 +19191,8 @@ self: { testHaskellDepends = [ base blaze-builder bytestring hspec text ]; description = "General purpose templates in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "StrategyLib" = callPackage @@ -18067,6 +19227,8 @@ self: { libraryHaskellDepends = [ base benchpress parallel ]; description = "Benchmarking code through strict evaluation"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "StrictCheck" = callPackage @@ -18085,6 +19247,8 @@ self: { ]; description = "StrictCheck: Keep Your Laziness In Check"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "StringUtils" = callPackage @@ -18122,6 +19286,8 @@ self: { ]; description = "Suffix array construction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SybWidget" = callPackage @@ -18137,6 +19303,8 @@ self: { ]; description = "Library which aids constructing generic (SYB3-based) widgets"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "SyntaxMacros" = callPackage @@ -18153,6 +19321,7 @@ self: { ]; description = "Syntax Macros in the form of an EDSL"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Sysmon" = callPackage @@ -18173,6 +19342,8 @@ self: { ]; description = "Sybase 15 sysmon reports processor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TBC" = callPackage @@ -18193,6 +19364,8 @@ self: { ]; description = "Testing By Convention"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TBit" = callPackage @@ -18209,6 +19382,8 @@ self: { ]; description = "Utilities for condensed matter physics tight binding calculations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TCache" = callPackage @@ -18257,6 +19432,8 @@ self: { executableHaskellDepends = [ base bytestring Yampa ]; description = "Bindings to the TORCS vehicle simulator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TTTAS" = callPackage @@ -18294,6 +19471,8 @@ self: { ]; description = "Template Your Boilerplate - a Template Haskell version of SYB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TableAlgebra" = callPackage @@ -18322,6 +19501,8 @@ self: { executableHaskellDepends = [ base cookbook ]; description = "A client for Quill databases"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Tablify" = callPackage @@ -18335,6 +19516,8 @@ self: { executableHaskellDepends = [ base parsec xhtml ]; description = "Tool to render CSV into tables of various formats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Tahin" = callPackage @@ -18378,6 +19561,8 @@ self: { libraryHaskellDepends = [ base mtl old-time time ]; description = "Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Tape" = callPackage @@ -18389,6 +19574,8 @@ self: { libraryHaskellDepends = [ base comonad distributive Stream ]; description = "Bidirectionally infinite streams, akin to the tape of a Turing machine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TaskMonad" = callPackage @@ -18407,6 +19594,8 @@ self: { ]; description = "A collection of tools which can be used to access taskwarrior from xmonad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Taxonomy" = callPackage @@ -18422,6 +19611,7 @@ self: { ]; description = "Libary for parsing, processing and vizualization of taxonomy data"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "TaxonomyTools" = callPackage @@ -18441,6 +19631,7 @@ self: { ]; description = "Tool for parsing, processing, comparing and visualizing taxonomy data"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "TeX-my-math" = callPackage @@ -18469,6 +19660,7 @@ self: { ]; description = "Render general Haskell math to LaTeX. Or: math typesetting with high signal-to-noise–ratio."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "TeaHS" = callPackage @@ -18484,6 +19676,7 @@ self: { ]; description = "TeaHS Game Creation Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Tensor" = callPackage @@ -18538,6 +19731,8 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ ogg theora ]; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {ogg = null; theora = null;}; "Thingie" = callPackage @@ -18549,6 +19744,8 @@ self: { libraryHaskellDepends = [ base cairo gtk mtl ]; description = "Purely functional 2D drawing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ThreadObjects" = callPackage @@ -18606,6 +19803,8 @@ self: { ]; description = "A sub-project (exercise) for a functional programming course"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TigerHash" = callPackage @@ -18640,6 +19839,8 @@ self: { ]; description = "A simple tile-based digital clock screen saver"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TinyLaunchbury" = callPackage @@ -18651,6 +19852,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Simple implementation of call-by-need using Launchbury's semantics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TinyURL" = callPackage @@ -18662,6 +19865,8 @@ self: { libraryHaskellDepends = [ base HTTP network ]; description = "Use TinyURL to compress URLs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Titim" = callPackage @@ -18675,6 +19880,8 @@ self: { executableHaskellDepends = [ base containers matrix random ]; description = "Game for Lounge Marmelade"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Top" = callPackage @@ -18689,6 +19896,8 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Constraint solving framework employed by the Helium Compiler"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TotalMap" = callPackage @@ -18708,6 +19917,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "A total map datatype"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Tournament" = callPackage @@ -18725,6 +19936,8 @@ self: { ]; description = "Tournament related algorithms"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TraceUtils" = callPackage @@ -18753,6 +19966,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "eDSL in R for Safe Variable Transformarion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TransformersStepByStep" = callPackage @@ -18766,6 +19981,8 @@ self: { executableHaskellDepends = [ base containers mtl ]; description = "Tutorial on monad transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Transhare" = callPackage @@ -18788,6 +20005,7 @@ self: { libraryHaskellDepends = [ base ref-mtl stm ]; description = "Wait-free Tree Counter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "TreeStructures" = callPackage @@ -18799,6 +20017,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A collection of heaps and search trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TreeT" = callPackage @@ -18821,6 +20041,7 @@ self: { libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ]; description = "Lock free Treiber stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "TrendGraph" = callPackage @@ -18837,6 +20058,8 @@ self: { ]; description = "A simple trend Graph script"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TrieMap" = callPackage @@ -18854,6 +20077,7 @@ self: { ]; description = "Automatic type inference of generalized tries with Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Twofish" = callPackage @@ -18892,6 +20116,7 @@ self: { ]; description = "Typing speed game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "TypeCompose" = callPackage @@ -18918,6 +20143,7 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "TypeIlluminator is a prototype tool exploring debugging of type errors/"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "TypeNat" = callPackage @@ -18929,6 +20155,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Some Nat-indexed types for GHC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "TypingTester" = callPackage @@ -18974,6 +20202,7 @@ self: { ]; description = "A small command-line accounting tool"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "URLT" = callPackage @@ -18991,6 +20220,7 @@ self: { ]; description = "Library for maintaining correctness of URLs within an application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "URLb" = callPackage @@ -19002,6 +20232,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring containers ]; description = "DEPRECATED A simple, liberal URL parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "UTFTConverter" = callPackage @@ -19025,6 +20257,8 @@ self: { ]; description = "Processing popular picture formats into .c or .raw format in RGB565"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Unique" = callPackage @@ -19084,6 +20318,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Monadic FRP library based on stm"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "UrlDisp" = callPackage @@ -19095,6 +20331,7 @@ self: { libraryHaskellDepends = [ base cgi MaybeT mtl ]; description = "Url dispatcher. Helps to retain friendly URLs in web applications."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Useful" = callPackage @@ -19147,6 +20384,8 @@ self: { ]; description = "Provides access to Vkontakte social network via public API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "VRML" = callPackage @@ -19170,6 +20409,8 @@ self: { ]; description = "VRML parser and generator for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Validation" = callPackage @@ -19183,6 +20424,8 @@ self: { ]; description = "A data-type like Either but with an accumulating Applicative"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Vec" = callPackage @@ -19205,6 +20448,8 @@ self: { libraryHaskellDepends = [ base Boolean Vec ]; description = "Provides Boolean instances for the Vec package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Vec-OpenGLRaw" = callPackage @@ -19216,6 +20461,8 @@ self: { libraryHaskellDepends = [ base OpenGLRaw Vec ]; description = "Instances and functions to interoperate Vec and OpenGL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Vec-Transform" = callPackage @@ -19227,6 +20474,8 @@ self: { doHaddock = false; description = "This package is obsolete"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "VecN" = callPackage @@ -19252,6 +20501,8 @@ self: { executableHaskellDepends = [ base containers matrix ]; description = "A solver for the WordBrain game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ViennaRNA-bindings" = callPackage @@ -19295,6 +20546,7 @@ self: { ]; description = "ViennaRNA v2 extensions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ViennaRNAParser" = callPackage @@ -19341,6 +20593,8 @@ self: { ]; description = "Villefort is a task manager and time tracker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Vulkan" = callPackage @@ -19382,6 +20636,7 @@ self: { ]; description = "WAVE audio file IO library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "WEditor" = callPackage @@ -19395,6 +20650,8 @@ self: { doHaddock = false; description = "Generic text-editor logic for use with fixed-width fonts"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WEditorBrick" = callPackage @@ -19409,6 +20666,7 @@ self: { executableHaskellDepends = [ base brick vty WEditor ]; description = "Text-editor widget with dynamic line-wrapping for use with Brick"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "WEditorHyphen" = callPackage @@ -19421,6 +20679,7 @@ self: { testHaskellDepends = [ base directory hyphenation WEditor ]; description = "Language-specific hyphenation policies for WEditor"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "WL500gPControl" = callPackage @@ -19437,6 +20696,7 @@ self: { ]; description = "A simple command line tools to control the Asus WL500gP router"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "WL500gPLib" = callPackage @@ -19451,6 +20711,8 @@ self: { executableHaskellDepends = [ base ]; description = "A simple library to access to the WL 500gP router from the Haskell code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WMSigner" = callPackage @@ -19470,6 +20732,8 @@ self: { ]; description = "WebMoney authentication module"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WURFL" = callPackage @@ -19481,6 +20745,7 @@ self: { libraryHaskellDepends = [ base haskell98 parsec ]; description = "Convert the WURFL file into a Parsec parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "WXDiffCtrl" = callPackage @@ -19493,6 +20758,7 @@ self: { libraryHaskellDepends = [ base containers wx wxcore ]; description = "WXDiffCtrl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "WashNGo" = callPackage @@ -19511,6 +20777,7 @@ self: { executableHaskellDepends = [ directory ghc-paths process ]; description = "WASH is a family of EDSLs for programming Web applications in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "WaveFront" = callPackage @@ -19527,6 +20794,7 @@ self: { ]; description = "Parsers and utilities for the OBJ WaveFront 3D model format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Weather" = callPackage @@ -19553,6 +20821,8 @@ self: { libraryHaskellDepends = [ base containers mtl parsec pretty syb ]; description = "JavaScript analysis tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WebBits-Html" = callPackage @@ -19568,6 +20838,7 @@ self: { ]; description = "JavaScript analysis tools"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "WebBits-multiplate" = callPackage @@ -19584,6 +20855,7 @@ self: { ]; description = "A Multiplate instance for JavaScript"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "WebCont" = callPackage @@ -19602,6 +20874,7 @@ self: { ]; description = "Continuation based web programming for Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "WeberLogic" = callPackage @@ -19616,6 +20889,8 @@ self: { executableHaskellDepends = [ base parsec ]; description = "Logic interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Webrexp" = callPackage @@ -19642,6 +20917,8 @@ self: { ]; description = "Regexp-like engine to scrap web data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Wheb" = callPackage @@ -19666,6 +20943,8 @@ self: { ]; description = "The frictionless WAI Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WikimediaParser" = callPackage @@ -19677,6 +20956,8 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "A parser for wikimedia style article markup"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Win32" = callPackage @@ -19857,6 +21138,8 @@ self: { ]; description = "Wire-aware hardware description"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WordAlignment" = callPackage @@ -19896,6 +21179,7 @@ self: { ]; description = "Bigram word pair alignments"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "WordNet" = callPackage @@ -19909,6 +21193,8 @@ self: { libraryHaskellDepends = [ array base containers filepath ]; description = "Haskell interface to the WordNet database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WordNet-ghc74" = callPackage @@ -19922,6 +21208,8 @@ self: { libraryHaskellDepends = [ array base containers filepath ]; description = "Haskell interface to the WordNet database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Wordlint" = callPackage @@ -19956,6 +21244,8 @@ self: { ]; description = "Workflow patterns over a monad for thread state logging & recovery"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "WxGeneric" = callPackage @@ -19970,6 +21260,7 @@ self: { ]; description = "Generic (SYB3) construction of wxHaskell widgets"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "X" = callPackage @@ -20017,6 +21308,8 @@ self: { librarySystemDepends = [ libX11 ]; description = "Missing bindings to the X11 graphics library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs.xorg) libX11;}; "X11-rm" = callPackage @@ -20028,6 +21321,8 @@ self: { libraryHaskellDepends = [ base X11 ]; description = "A binding to the resource management functions missing from X11"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "X11-xdamage" = callPackage @@ -20040,6 +21335,8 @@ self: { librarySystemDepends = [ Xdamage ]; description = "A binding to the Xdamage X11 extension library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {Xdamage = null;}; "X11-xfixes" = callPackage @@ -20052,6 +21349,8 @@ self: { librarySystemDepends = [ Xfixes ]; description = "A binding to the Xfixes X11 extension library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {Xfixes = null;}; "X11-xft" = callPackage @@ -20143,6 +21442,8 @@ self: { librarySystemDepends = [ xmmsclient xmmsclient-glib ]; description = "XMMS2 client library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {xmmsclient = null; xmmsclient-glib = null;}; "XMPP" = callPackage @@ -20159,6 +21460,7 @@ self: { ]; description = "XMPP library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "XSaiga" = callPackage @@ -20185,6 +21487,7 @@ self: { ]; description = "An implementation of a polynomial-time top-down parser suitable for NLP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Xauth" = callPackage @@ -20215,6 +21518,8 @@ self: { ]; description = "Gtk command launcher with identicon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "XmlHtmlWriter" = callPackage @@ -20226,6 +21531,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "A library for writing XML and HTML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Xorshift128Plus" = callPackage @@ -20237,6 +21544,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Pure haskell implementation of xorshift128plus random number generator"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "YACPong" = callPackage @@ -20257,6 +21566,7 @@ self: { ]; description = "Yet Another Pong Clone using SDL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "YFrob" = callPackage @@ -20268,6 +21578,8 @@ self: { libraryHaskellDepends = [ array base HGL Yampa ]; description = "Yampa-based library for programming robots"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Yablog" = callPackage @@ -20302,6 +21614,7 @@ self: { ]; description = "A simple blog engine powered by Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "YamlReference" = callPackage @@ -20329,6 +21642,8 @@ self: { ]; description = "YAML reference implementation"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Yampa" = callPackage @@ -20376,6 +21691,8 @@ self: { ]; description = "Software synthesizer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Yocto" = callPackage @@ -20403,6 +21720,7 @@ self: { ]; description = "A MUD client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Yogurt-Standalone" = callPackage @@ -20422,6 +21740,7 @@ self: { executableSystemDepends = [ readline ]; description = "A functional MUD client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) readline;}; "Z-Data" = callPackage @@ -20448,6 +21767,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Array, vector and text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Z-IO" = callPackage @@ -20474,6 +21795,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Simple and high performance IO toolkit for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Z-MessagePack" = callPackage @@ -20498,6 +21820,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "MessagePack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Z-YAML" = callPackage @@ -20515,6 +21838,7 @@ self: { testHaskellDepends = [ base hspec Z-Data ]; description = "YAML tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ZEBEDDE" = callPackage @@ -20528,6 +21852,8 @@ self: { libraryHaskellDepends = [ base vect ]; description = "Polymer growth simulation method"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ZFS" = callPackage @@ -20543,6 +21869,8 @@ self: { ]; description = "Oleg's Zipper FS"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ZMachine" = callPackage @@ -20557,6 +21885,8 @@ self: { executableHaskellDepends = [ array base gtk mtl random ]; description = "A Z-machine interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ZipFold" = callPackage @@ -20607,6 +21937,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinators for bidirectional URL routing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "a50" = callPackage @@ -20625,6 +21957,7 @@ self: { ]; description = "Compare genome assemblies"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "abacate" = callPackage @@ -20678,6 +22011,7 @@ self: { ]; description = "Bindings for ABC, A System for Sequential Synthesis and Verification"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {abc = null;}; "abcnotation" = callPackage @@ -20691,6 +22025,8 @@ self: { ]; description = "Haskell representation and parser for ABC notation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "abeson" = callPackage @@ -20710,6 +22046,7 @@ self: { ]; description = "interconversion between aeson and bson"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "abides" = callPackage @@ -20722,6 +22059,8 @@ self: { testHaskellDepends = [ base comonad tasty tasty-quickcheck ]; description = "Simple boolean tests to see if a value abides by certain properties"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "abnf" = callPackage @@ -20741,6 +22080,8 @@ self: { ]; description = "Parse ABNF and generate parsers for the specified document"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "abstract-deque" = callPackage @@ -20796,6 +22137,8 @@ self: { ]; description = "Provides the class ParAccelerate, nothing more"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "abt" = callPackage @@ -20811,6 +22154,8 @@ self: { ]; description = "Abstract binding trees for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ac-machine" = callPackage @@ -20824,6 +22169,8 @@ self: { ]; description = "Aho-Corasick string matching algorithm in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ac-machine-conduit" = callPackage @@ -20835,6 +22182,7 @@ self: { libraryHaskellDepends = [ ac-machine base conduit text ]; description = "Drive Aho-Corasick machines in Conduit pipelines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "acc" = callPackage @@ -20854,6 +22202,8 @@ self: { benchmarkHaskellDepends = [ criterion rerebase ]; description = "Sequence optimized for monoidal construction and folding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "accelerate" = callPackage @@ -20899,6 +22249,7 @@ self: { ]; description = "Linear algebra and interpolation using the Accelerate framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "accelerate-bignum" = callPackage @@ -21110,6 +22461,8 @@ self: { ]; description = "Accelerate frontend to the FFTW library (Fourier transform)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "accelerate-fourier" = callPackage @@ -21135,6 +22488,7 @@ self: { ]; description = "Fast Fourier transform and convolution using the Accelerate framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "accelerate-fourier-benchmark" = callPackage @@ -21352,6 +22706,8 @@ self: { testHaskellDepends = [ accelerate base ]; description = "Accelerate backend for multicore CPUs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "accelerate-llvm-ptx" = callPackage @@ -21385,6 +22741,8 @@ self: { libraryHaskellDepends = [ accelerate base mwc-random ]; description = "Generate Accelerate arrays filled with high quality pseudorandom numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "accelerate-typelits" = callPackage @@ -21407,6 +22765,7 @@ self: { ]; description = "a typesafe way encode accelerate matrices and vectors"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "accelerate-utility" = callPackage @@ -21418,6 +22777,8 @@ self: { libraryHaskellDepends = [ accelerate base utility-ht ]; description = "Utility functions for the Accelerate framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "accentuateus" = callPackage @@ -21429,6 +22790,8 @@ self: { libraryHaskellDepends = [ base bytestring HTTP json network text ]; description = "A Haskell implementation of the Accentuate.us API."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "access-time" = callPackage @@ -21440,6 +22803,8 @@ self: { libraryHaskellDepends = [ base filepath old-time time unix ]; description = "Cross-platform support for retrieving file access times"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "access-token-provider" = callPackage @@ -21466,6 +22831,7 @@ self: { ]; description = "Provides Access Token for Services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "accuerr" = callPackage @@ -21518,6 +22884,8 @@ self: { ]; description = "A library for building static site generators"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acid-state" = callPackage @@ -21574,6 +22942,8 @@ self: { ]; description = "A replication backend for acid-state"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acid-state-tls" = callPackage @@ -21589,6 +22959,8 @@ self: { ]; description = "Add TLS support for Data.Acid.Remote"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acl2" = callPackage @@ -21611,6 +22983,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A monad which is powerful enough to interpret any action"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-box" = callPackage @@ -21688,6 +23062,8 @@ self: { libraryHaskellDepends = [ base comonad ]; description = "A more efficient dualization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-cuteboy" = callPackage @@ -21739,6 +23115,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "A \"don't\" construct"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-flipping-tables" = callPackage @@ -21750,6 +23128,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Stop execution with rage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-functors" = callPackage @@ -21783,6 +23163,8 @@ self: { libraryHaskellDepends = [ base ]; description = "An embedded DSL for the HQ9+ programming language"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-http" = callPackage @@ -21800,6 +23182,8 @@ self: { ]; description = "fastest Haskell PONG server in the world"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-inator" = callPackage @@ -21814,6 +23198,8 @@ self: { executableHaskellDepends = [ base ]; description = "Evil inventions in the Tri-State area"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-io" = callPackage @@ -21848,6 +23234,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A place for dumping that does-not-feel-right code while you improve it"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-left-pad" = callPackage @@ -21859,6 +23247,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "free your haskell from the tyranny of npm!"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-lolcat" = callPackage @@ -21914,6 +23304,8 @@ self: { libraryHaskellDepends = [ base random ]; description = "Miscellaneous newtypes for orderings of discutable use"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-missiles" = callPackage @@ -21939,6 +23331,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A mutable package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-now" = callPackage @@ -21950,6 +23344,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "An interface to the philosophical and metaphysical \"now\""; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-numbersystem" = callPackage @@ -21961,6 +23357,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Define the less than and add and subtract for nats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-omitted" = callPackage @@ -21995,6 +23393,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Operators of base, all in one place!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-php" = callPackage @@ -22006,6 +23406,7 @@ self: { libraryHaskellDepends = [ acme-left-pad base ]; description = "The flexibility of Haskell and the safety of PHP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "acme-pointful-numbers" = callPackage @@ -22057,6 +23458,8 @@ self: { ]; description = "Proper names for curry and uncurry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-smuggler" = callPackage @@ -22080,6 +23483,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A binding to the glibc strfry function"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-stringly-typed" = callPackage @@ -22093,6 +23498,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Stringly Typed Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-strtok" = callPackage @@ -22117,6 +23524,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "import This"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acme-timemachine" = callPackage @@ -22165,6 +23574,8 @@ self: { doHaddock = false; description = "The absorbing element of package dependencies"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "acousticbrainz-client" = callPackage @@ -22188,6 +23599,7 @@ self: { ]; description = "AcousticBrainz API client"; license = lib.licenses.cc0; + hydraPlatforms = lib.platforms.none; }) {}; "acquire" = callPackage @@ -22258,6 +23670,7 @@ self: { ]; description = "Haskell code presentation tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "activehs-base" = callPackage @@ -22271,6 +23684,8 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Basic definitions for activehs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "activitypub" = callPackage @@ -22282,6 +23697,8 @@ self: { libraryHaskellDepends = [ aeson base network-uri text time ]; description = "ActivityPub Haskell Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "activitystreams-aeson" = callPackage @@ -22295,6 +23712,8 @@ self: { ]; description = "An interface to the ActivityStreams specification"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "actor" = callPackage @@ -22307,6 +23726,7 @@ self: { libraryHaskellDepends = [ base haskell98 stm time ]; description = "Actors with multi-headed receive clauses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "acts" = callPackage @@ -22324,6 +23744,8 @@ self: { doHaddock = false; description = "Semigroup actions and torsors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ad" = callPackage @@ -22357,6 +23779,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Self optimizing container types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "adaptive-tuple" = callPackage @@ -22368,6 +23792,8 @@ self: { libraryHaskellDepends = [ base template-haskell type-level ]; description = "Self-optimizing tuple types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "adb" = callPackage @@ -22382,6 +23808,8 @@ self: { ]; description = "Android Debug Bridge (ADB) protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "adblock2privoxy" = callPackage @@ -22437,6 +23865,7 @@ self: { ]; description = "A full-featured library for parsing, validating, and rendering email addresses"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "adhoc-network" = callPackage @@ -22454,6 +23883,7 @@ self: { ]; description = "Ad-hoc P2P network protocol"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "adict" = callPackage @@ -22475,6 +23905,7 @@ self: { ]; description = "Approximate dictionary searching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "adjunction" = callPackage @@ -22490,6 +23921,8 @@ self: { benchmarkHaskellDepends = [ base gauge hs-functors ]; description = "See README for more info"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "adjunctions" = callPackage @@ -22546,6 +23979,8 @@ self: { ]; description = "parse Adobe Swatch Exchange files and (optionally) output .css files with the colors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "adp-multi" = callPackage @@ -22566,6 +24001,8 @@ self: { ]; description = "ADP for multiple context-free languages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "adp-multi-monadiccp" = callPackage @@ -22585,6 +24022,7 @@ self: { ]; description = "Subword construction in adp-multi using monadiccp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "adtrees" = callPackage @@ -22596,6 +24034,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Modelling, rendering and quantitative analysis on attack defense trees"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "advent-of-code-api" = callPackage @@ -22667,6 +24107,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Multi-precision ball (interval) arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aern2-real" = callPackage @@ -22690,6 +24132,7 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Exact real numbers via Cauchy sequences and MPFR"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aeson" = callPackage @@ -22735,6 +24178,8 @@ self: { libraryHaskellDepends = [ aeson base text unordered-containers ]; description = "make To/From JSOn instances from an applicative description"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-attoparsec" = callPackage @@ -22893,6 +24338,8 @@ self: { ]; description = "Easy functions for converting from Aeson.Value"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-default" = callPackage @@ -22969,6 +24416,8 @@ self: { ]; description = "Apply a json-patch to any haskell datatype"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-extra" = callPackage @@ -23016,6 +24465,8 @@ self: { ]; description = "Several newtypes and combinators for dealing with less-than-cleanly JSON input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-flat" = callPackage @@ -23065,6 +24516,8 @@ self: { ]; description = "Create Flow type definitions from Haskell data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-gadt-th" = callPackage @@ -23201,6 +24654,8 @@ self: { ]; description = "Declarative JSON matchers"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-native" = callPackage @@ -23221,6 +24676,7 @@ self: { ]; description = "Fast JSON parsing and encoding (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aeson-optics" = callPackage @@ -23253,6 +24709,8 @@ self: { libraryHaskellDepends = [ aeson base ]; description = "Options to derive FromJSON/ToJSON instances"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-parsec-picky" = callPackage @@ -23296,6 +24754,8 @@ self: { testHaskellDepends = [ aeson base bytestring hspec mtl text ]; description = "Hiearchical prefixing for aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-pretty" = callPackage @@ -23398,6 +24858,8 @@ self: { ]; description = "Haskell JSON schema validator and parser generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-schemas" = callPackage @@ -23427,6 +24889,8 @@ self: { ]; description = "Easily consume JSON data on-demand with type-safety"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-serialize" = callPackage @@ -23455,6 +24919,8 @@ self: { ]; description = "Smart derivation of Aeson instances"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-streams" = callPackage @@ -23470,6 +24936,8 @@ self: { ]; description = "An HTTP client library for JSON-based APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-t" = callPackage @@ -23489,6 +24957,8 @@ self: { ]; description = "Transform JSON"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-tiled" = callPackage @@ -23508,6 +24978,8 @@ self: { testHaskellDepends = [ aeson base hspec ]; description = "Aeson instances for the Tiled map editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-toolkit" = callPackage @@ -23542,6 +25014,8 @@ self: { ]; description = "Generate TypeScript definition files from your ADTs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-utils" = callPackage @@ -23559,6 +25033,8 @@ self: { ]; description = "Utilities for working with Aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-value-parser" = callPackage @@ -23594,6 +25070,8 @@ self: { ]; description = "Wrappers to derive-via Aeson ToJSON/FromJSON typeclasses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-with" = callPackage @@ -23665,6 +25143,8 @@ self: { ]; description = "A simple Game Engine using SDL"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "affine" = callPackage @@ -23693,6 +25173,8 @@ self: { ]; description = "General-purpose sampling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "affinely-extended" = callPackage @@ -23742,6 +25224,7 @@ self: { ]; description = "Infinite state model checking of iterative C programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ag-pictgen" = callPackage @@ -23755,6 +25238,8 @@ self: { executableHaskellDepends = [ base containers uuagc uulib ]; description = "Attribute Grammar picture generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "agda-language-server" = callPackage @@ -23781,6 +25266,8 @@ self: { ]; description = "LSP server for Agda"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "agda-server" = callPackage @@ -23801,6 +25288,7 @@ self: { ]; description = "Http server for Agda (prototype)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "agda-snippets" = callPackage @@ -23821,6 +25309,8 @@ self: { executableHaskellDepends = [ Agda base network-uri transformers ]; description = "Render just the Agda snippets of a literate Agda file to HTML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "agda-snippets-hakyll" = callPackage @@ -23837,6 +25327,7 @@ self: { ]; description = "Literate Agda support using agda-snippets, for Hakyll pages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "agda-unused" = callPackage @@ -23895,6 +25386,7 @@ self: { ]; description = "AgentX protocol for write SNMP subagents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "agum" = callPackage @@ -23927,6 +25419,8 @@ self: { ]; description = "And-inverter graphs in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aip" = callPackage @@ -23955,6 +25449,7 @@ self: { ]; description = "Aeronautical Information Package (AIP)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "air" = callPackage @@ -24009,6 +25504,8 @@ self: { libraryHaskellDepends = [ air base template-haskell ]; description = "air"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "airbrake" = callPackage @@ -24028,6 +25525,8 @@ self: { ]; description = "An Airbrake notifier for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "airship" = callPackage @@ -24057,6 +25556,7 @@ self: { ]; description = "A Webmachine-inspired HTTP library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "airtable-api" = callPackage @@ -24074,6 +25574,8 @@ self: { testHaskellDepends = [ base ]; description = "Requesting and introspecting Tables within an Airtable project"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aivika" = callPackage @@ -24122,6 +25624,7 @@ self: { ]; description = "Parallel distributed discrete event simulation module for the Aivika library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aivika-experiment" = callPackage @@ -24278,6 +25781,8 @@ self: { ]; description = "Haskell compiler that produce binary through C language"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "al" = callPackage @@ -24343,6 +25848,8 @@ self: { ]; description = "Bindings to the alerta REST API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alerts" = callPackage @@ -24398,6 +25905,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "Collection of useful functions for writing console applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alex-tools" = callPackage @@ -24430,6 +25939,8 @@ self: { ]; description = "utility library for Alfred version 2"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alfred-margaret" = callPackage @@ -24496,6 +26007,8 @@ self: { ]; description = "Algorithmic automation for various DAWs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "algebra" = callPackage @@ -24531,6 +26044,7 @@ self: { ]; description = "Model and test API surfaces algebraically"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "algebra-dag" = callPackage @@ -24546,6 +26060,8 @@ self: { ]; description = "Infrastructure for DAG-shaped relational algebra plans"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "algebra-driven-design" = callPackage @@ -24564,6 +26080,7 @@ self: { ]; description = "Companion library for the book Algebra-Driven Design by Sandy Maguire"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "algebra-sql" = callPackage @@ -24590,6 +26107,7 @@ self: { ]; description = "Relational Algebra and SQL Code Generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "algebraic" = callPackage @@ -24601,6 +26119,8 @@ self: { libraryHaskellDepends = [ accelerate base ]; description = "General linear algebra structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "algebraic-classes" = callPackage @@ -24674,6 +26194,8 @@ self: { ]; description = "Algebraically structured Prelude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "algo-s" = callPackage @@ -24699,6 +26221,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "An implementation of Knuth's algorithm S"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "algolia" = callPackage @@ -24724,6 +26248,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "A client implementing the Algolia search API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "algorithmic-composition-additional" = callPackage @@ -24842,6 +26367,8 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "A simple unix filter to align text on specified substrings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aligned-foreignptr" = callPackage @@ -24917,6 +26444,8 @@ self: { ]; description = "Ally Invest integration library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "almost-fix" = callPackage @@ -24950,6 +26479,7 @@ self: { ]; description = "a practical affine language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "alpaca-netcode" = callPackage @@ -24987,6 +26517,7 @@ self: { ]; description = "A compiler for the Alpha language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "alphachar" = callPackage @@ -25007,6 +26538,8 @@ self: { ]; description = "A character between a-z"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alpino-tools" = callPackage @@ -25046,6 +26579,8 @@ self: { librarySystemDepends = [ alsaLib ]; description = "Binding to the ALSA Library API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) alsaLib;}; "alsa-core" = callPackage @@ -25078,6 +26613,7 @@ self: { ]; description = "Some simple interactive programs for sending MIDI control messages via ALSA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "alsa-midi" = callPackage @@ -25098,6 +26634,8 @@ self: { executableSystemDepends = [ alsaLib ]; description = "Bindings for the ALSA sequencer API (MIDI stuff)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) alsaLib;}; "alsa-mixer" = callPackage @@ -25149,6 +26687,7 @@ self: { executableHaskellDepends = [ alsa base ]; description = "Tests for the ALSA audio signal library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "alsa-seq" = callPackage @@ -25185,6 +26724,7 @@ self: { executableHaskellDepends = [ alsa base ]; description = "Tests for the ALSA sequencer library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "altcomposition" = callPackage @@ -25196,6 +26736,8 @@ self: { libraryHaskellDepends = [ base composition ]; description = "Alternative combinators for unorthodox function composition"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alternative-extra" = callPackage @@ -25207,6 +26749,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Extra utilities for alternatives"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alternative-io" = callPackage @@ -25224,6 +26768,8 @@ self: { ]; description = "IO as Alternative instance (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alternative-vector" = callPackage @@ -25286,6 +26832,8 @@ self: { executableHaskellDepends = [ base warp ]; description = "Implement a menu experience fit for web users"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "altsvc" = callPackage @@ -25314,6 +26862,8 @@ self: { librarySystemDepends = [ alure ]; description = "A Haskell binding for ALURE"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) alure;}; "always" = callPackage @@ -25343,6 +26893,8 @@ self: { ]; description = "A queue daemon for Amazon's SES with a PostgreSQL table as a queue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "amazon-emailer-client-snap" = callPackage @@ -25357,6 +26909,7 @@ self: { ]; description = "Client library for amazon-emailer daemon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "amazon-products" = callPackage @@ -25382,6 +26935,8 @@ self: { ]; description = "Connector for Amazon Products API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "amazonka" = callPackage @@ -27836,6 +29391,8 @@ self: { benchmarkHaskellDepends = [ base statistics ]; description = "Statistical data visualization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ampersand" = callPackage @@ -27866,6 +29423,7 @@ self: { ]; description = "Toolsuite for automated design of business processes"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "amqp" = callPackage @@ -27913,6 +29471,8 @@ self: { ]; description = "Conduit bindings for AMQP (see amqp package)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "amqp-streamly" = callPackage @@ -27929,6 +29489,7 @@ self: { ]; description = "A simple streamly wrapper for amqp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "amqp-utils" = callPackage @@ -28034,6 +29595,8 @@ self: { ]; description = "making data science easy and safe with data frames"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "analyze-client" = callPackage @@ -28050,6 +29613,7 @@ self: { ]; description = "Client for analyze service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "anansi" = callPackage @@ -28102,6 +29666,8 @@ self: { ]; description = "Looms which use Pandoc to parse and produce a variety of formats"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "anatomy" = callPackage @@ -28128,6 +29694,7 @@ self: { ]; description = "Anatomy: Atomo documentation system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "android" = callPackage @@ -28139,6 +29706,8 @@ self: { libraryHaskellDepends = [ base process ]; description = "Android methods exposed to Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "android-activity" = callPackage @@ -28150,6 +29719,8 @@ self: { libraryHaskellDepends = [ base data-default ]; description = "Turn regular Haskell programs into Android Activities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "android-lint-summary" = callPackage @@ -28176,6 +29747,8 @@ self: { ]; description = "A pretty printer for Android Lint errors"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "angel" = callPackage @@ -28203,6 +29776,8 @@ self: { ]; description = "Process management and supervision daemon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "angle" = callPackage @@ -28231,6 +29806,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A small, general-purpose programming language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "animalcase" = callPackage @@ -28263,6 +29840,8 @@ self: { testHaskellDepends = [ ansi-terminal-game base hspec parsec ]; description = "text-file based ASCII animator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "animate" = callPackage @@ -28279,6 +29858,8 @@ self: { testHaskellDepends = [ aeson base containers hspec vector ]; description = "Animation for sprites"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "animate-example" = callPackage @@ -28297,6 +29878,7 @@ self: { ]; description = "Animation for sprites"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "animate-frames" = callPackage @@ -28318,6 +29900,7 @@ self: { testHaskellDepends = [ base tasty tasty-hspec ]; description = "Convert sprite frames to animate files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "animate-preview" = callPackage @@ -28343,6 +29926,7 @@ self: { executableHaskellDepends = [ base ]; description = "Preview tool for sprite animation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "animate-sdl2" = callPackage @@ -28354,6 +29938,7 @@ self: { libraryHaskellDepends = [ aeson animate base sdl2 sdl2-image ]; description = "sdl2 + animate auxiliary library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "anki-tools" = callPackage @@ -28397,6 +29982,7 @@ self: { ]; description = "Medium-level language that desugars to Morte"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "annihilator" = callPackage @@ -28419,6 +30005,8 @@ self: { libraryHaskellDepends = [ base recursion-schemes ]; description = "A fixpoint of a functor that can be annotated"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "annotated-wl-pprint" = callPackage @@ -28443,6 +30031,8 @@ self: { libraryHaskellDepends = [ base lens template-haskell ]; description = "Anonymous sum types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "anonymous-sums-tests" = callPackage @@ -28454,6 +30044,7 @@ self: { libraryHaskellDepends = [ anonymous-sums base QuickCheck ]; description = "QuickCheck functions to accompany the anonymous-sums package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ansi-escape-codes" = callPackage @@ -28552,6 +30143,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Terminal-based graphing via ANSI and Unicode"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "antagonist" = callPackage @@ -28577,6 +30170,7 @@ self: { ]; description = "A web interface to Antisplice dungeons"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "antfarm" = callPackage @@ -28599,6 +30193,8 @@ self: { ]; description = "Referring expressions for definitions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "anticiv" = callPackage @@ -28624,6 +30220,7 @@ self: { ]; description = "This is an IRC bot for Mafia and Resistance"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "antigate" = callPackage @@ -28641,6 +30238,8 @@ self: { ]; description = "Interface for antigate.com captcha recognition API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "antimirov" = callPackage @@ -28655,6 +30254,8 @@ self: { executableHaskellDepends = [ base containers QuickCheck ]; description = "Define the language containment (=subtyping) relation on regulare expressions"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "antiope-athena" = callPackage @@ -28801,6 +30402,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Please see the README on Github at "; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "antiope-s3" = callPackage @@ -28945,6 +30548,8 @@ self: { libraryHaskellDepends = [ base syb template-haskell ]; description = "Combinator library for quasi- and anti-quoting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "antisplice" = callPackage @@ -28961,6 +30566,8 @@ self: { ]; description = "An engine for text-based dungeons"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "antlr-haskell" = callPackage @@ -28985,6 +30592,8 @@ self: { ]; description = "A Haskell implementation of the ANTLR top-down parser generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "antlrc" = callPackage @@ -29005,6 +30614,7 @@ self: { ]; description = "Haskell binding to the ANTLR parser generator C runtime library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {antlr3c = null;}; "anydbm" = callPackage @@ -29020,6 +30630,8 @@ self: { libraryHaskellDepends = [ base containers MissingH mtl ]; description = "Interface for DBM-like database systems"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aop-prelude" = callPackage @@ -29032,6 +30644,8 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "prelude for Algebra of Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aos-signature" = callPackage @@ -29052,6 +30666,8 @@ self: { ]; description = "An implementation of the AOS signatures"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aosd" = callPackage @@ -29072,6 +30688,8 @@ self: { ]; description = "Bindings to libaosd, a library for Cairo-based on-screen displays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libaosd;}; "ap-normalize" = callPackage @@ -29144,6 +30762,8 @@ self: { ]; description = "Get all your structure and rip it apart"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "apecs" = callPackage @@ -29219,6 +30839,8 @@ self: { ]; description = "STM stores for apecs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "apelsin" = callPackage @@ -29240,6 +30862,7 @@ self: { ]; description = "Server and community browser for the game Tremulous"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "api-builder" = callPackage @@ -29261,6 +30884,8 @@ self: { ]; description = "Library for easily building REST API wrappers in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "api-field-json-th" = callPackage @@ -29364,6 +30989,8 @@ self: { testHaskellDepends = [ base bytestring ]; description = "RPC API client for Factom"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "api-rpc-pegnet" = callPackage @@ -29387,6 +31014,7 @@ self: { ]; description = "simple json-rpc client for PegNet"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "api-tools" = callPackage @@ -29441,6 +31069,7 @@ self: { testHaskellDepends = [ base bytestring text ]; description = "Api bindings for Yoti services"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary" = callPackage @@ -29473,6 +31102,7 @@ self: { ]; description = "Simple and type safe web framework that generate web API documentation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-authenticate" = callPackage @@ -29492,6 +31122,7 @@ self: { ]; description = "authenticate support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-clientsession" = callPackage @@ -29509,6 +31140,7 @@ self: { ]; description = "clientsession support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-cookie" = callPackage @@ -29524,6 +31156,7 @@ self: { ]; description = "Cookie support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-eventsource" = callPackage @@ -29535,6 +31168,7 @@ self: { libraryHaskellDepends = [ apiary base blaze-builder wai-extra ]; description = "eventsource support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-helics" = callPackage @@ -29554,6 +31188,7 @@ self: { ]; description = "helics support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-http-client" = callPackage @@ -29570,6 +31205,7 @@ self: { ]; description = "A http client for Apiary"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-logger" = callPackage @@ -29587,6 +31223,7 @@ self: { ]; description = "fast-logger support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-memcached" = callPackage @@ -29605,6 +31242,7 @@ self: { ]; description = "memcached client for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-mongoDB" = callPackage @@ -29622,6 +31260,7 @@ self: { ]; description = "mongoDB support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-persistent" = callPackage @@ -29639,6 +31278,7 @@ self: { ]; description = "persistent support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-purescript" = callPackage @@ -29658,6 +31298,7 @@ self: { ]; description = "purescript compiler for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-redis" = callPackage @@ -29669,6 +31310,7 @@ self: { libraryHaskellDepends = [ apiary base hedis transformers ]; description = "redis support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-session" = callPackage @@ -29680,6 +31322,7 @@ self: { libraryHaskellDepends = [ apiary base wai ]; description = "session support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apiary-websockets" = callPackage @@ -29691,6 +31334,7 @@ self: { libraryHaskellDepends = [ apiary base wai-websockets websockets ]; description = "websockets support for apiary web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "apioiaf-client" = callPackage @@ -29723,6 +31367,7 @@ self: { ]; description = "A Template Haskell library for generating type safe API calls"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "apns-http2" = callPackage @@ -29751,6 +31396,8 @@ self: { ]; description = "Apple Push Notification service HTTP/2 integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "apotiki" = callPackage @@ -29780,6 +31427,7 @@ self: { ]; description = "a faster debian repository"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "app-lens" = callPackage @@ -29794,6 +31442,8 @@ self: { ]; description = "applicative (functional) bidirectional programming beyond composition chains"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "app-settings" = callPackage @@ -29848,6 +31498,8 @@ self: { ]; description = "app container types and tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "appendmap" = callPackage @@ -29889,6 +31541,8 @@ self: { ]; description = "Applicative functor and monad which collects all your fails"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "applicative-numbers" = callPackage @@ -29916,6 +31570,8 @@ self: { ]; description = "An applicative parser combinator library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "applicative-quoters" = callPackage @@ -29929,6 +31585,8 @@ self: { libraryHaskellDepends = [ base haskell-src-meta template-haskell ]; description = "Quasiquoters for idiom brackets and an applicative do-notation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "applicative-splice" = callPackage @@ -29944,6 +31602,8 @@ self: { ]; description = "Write applicative programs in direct style (generalizes idiom brackets)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "apply-refact" = callPackage @@ -29991,6 +31651,8 @@ self: { ]; description = "Apply a function to an argument specified by a type level Nat"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "apply-unordered-mono" = callPackage @@ -30041,6 +31703,8 @@ self: { ]; description = "ApproveAPI Haskell Client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "approx" = callPackage @@ -30067,6 +31731,8 @@ self: { ]; description = "Easy-to-use emulation of approximate, ranges and tolerances in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "approx-rand-test" = callPackage @@ -30163,6 +31829,8 @@ self: { ]; description = "Pure Haskell arbitrary length FFT library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arbb-vm" = callPackage @@ -30179,6 +31847,8 @@ self: { librarySystemDepends = [ arbb_dev ]; description = "FFI binding to the Intel Array Building Blocks (ArBB) virtual machine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {arbb_dev = null;}; "arbor-datadog" = callPackage @@ -30241,6 +31911,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Counter library for submitting metrics to a backend such as datadog"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arbor-monad-logger" = callPackage @@ -30264,6 +31936,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Simple logging library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arbor-monad-metric" = callPackage @@ -30287,6 +31961,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Core metric library for publishing metrics"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arbor-monad-metric-datadog" = callPackage @@ -30312,6 +31988,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Metric library backend for datadog"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "arbor-postgres" = callPackage @@ -30330,6 +32007,8 @@ self: { ]; description = "Convenience types and functions for postgresql-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arbtt" = callPackage @@ -30423,6 +32102,7 @@ self: { ]; description = "Distribute hackage packages to archlinux"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "arch-web" = callPackage @@ -30446,6 +32126,8 @@ self: { ]; description = "Arch Linux official and AUR web interface binding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "archive" = callPackage @@ -30549,6 +32231,8 @@ self: { ]; description = "Archive supplied URLs in WebCite & Internet Archive"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "archlinux" = callPackage @@ -30564,6 +32248,8 @@ self: { ]; description = "Support for working with Arch Linux packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "archlinux-web" = callPackage @@ -30589,6 +32275,7 @@ self: { ]; description = "Website maintenance for Arch Linux packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "archnews" = callPackage @@ -30604,6 +32291,8 @@ self: { ]; description = "Convert Arch Linux package updates in RSS to pretty markdown"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arduino-copilot" = callPackage @@ -30622,6 +32311,7 @@ self: { testHaskellDepends = [ base directory process temporary ]; description = "Arduino programming in haskell using the Copilot stream DSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "arena" = callPackage @@ -30647,6 +32337,8 @@ self: { ]; description = "A journaled data store"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arff" = callPackage @@ -30663,6 +32355,7 @@ self: { ]; description = "Generate Attribute-Relation File Format (ARFF) files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "arghwxhaskell" = callPackage @@ -30676,6 +32369,7 @@ self: { executableHaskellDepends = [ base directory wx ]; description = "An interpreter for the Argh! programming language in wxHaskell"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "argon" = callPackage @@ -30702,6 +32396,7 @@ self: { ]; description = "Measure your code's complexity"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "argon2" = callPackage @@ -30720,6 +32415,8 @@ self: { ]; description = "Memory-hard password hash and proof-of-work function"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "argparser" = callPackage @@ -30732,6 +32429,8 @@ self: { testHaskellDepends = [ base containers HTF HUnit ]; description = "Command line parsing framework for console applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arguedit" = callPackage @@ -30749,6 +32448,8 @@ self: { ]; description = "A computer assisted argumentation transcription and editing software"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ariadne" = callPackage @@ -30776,6 +32477,7 @@ self: { ]; description = "Go-to-definition for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "arion" = callPackage @@ -30799,6 +32501,8 @@ self: { ]; description = "Watcher and runner for Hspec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arion-compose" = callPackage @@ -30922,6 +32626,7 @@ self: { ]; description = "Arithmetic circuits for zkSNARKs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "arithmoi" = callPackage @@ -30979,6 +32684,8 @@ self: { executableHaskellDepends = [ base GLUT mtl OpenGL stm ]; description = "Space-based real time strategy game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "armor" = callPackage @@ -31011,6 +32718,8 @@ self: { executableHaskellDepends = [ base ]; description = "Library for reading ARPA n-gram models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arpack" = callPackage @@ -31034,6 +32743,8 @@ self: { ]; description = "Solve large scale eigenvalue problems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) arpack;}; "array_0_5_4_0" = callPackage @@ -31102,6 +32813,7 @@ self: { ]; description = "A simple interpreter for arrayForth, the language used on GreenArrays chips"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "array-list" = callPackage @@ -31144,6 +32856,8 @@ self: { benchmarkHaskellDepends = [ base criterion ghc-prim ]; description = "Extra foreign primops for primitive arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "array-utils" = callPackage @@ -31179,6 +32893,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell bindings to the ArrayFire general-purpose GPU library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {af = null;}; "arraylist" = callPackage @@ -31196,6 +32912,7 @@ self: { ]; description = "Memory-efficient ArrayList implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "arrow-extras" = callPackage @@ -31221,6 +32938,8 @@ self: { ]; description = "Improved arrows"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arrow-list" = callPackage @@ -31232,6 +32951,8 @@ self: { libraryHaskellDepends = [ base containers fail mtl ]; description = "List arrows for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arrowapply-utils" = callPackage @@ -31243,6 +32964,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Utilities for working with ArrowApply instances more naturally"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arrowp" = callPackage @@ -31256,6 +32979,8 @@ self: { executableHaskellDepends = [ array base containers haskell-src ]; description = "preprocessor translating arrow notation into Haskell 98"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arrowp-qq" = callPackage @@ -31276,6 +33001,8 @@ self: { executableHaskellDepends = [ base haskell-src-exts NoHoed ]; description = "A preprocessor and quasiquoter for translating arrow notation"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arrows" = callPackage @@ -31300,6 +33027,8 @@ self: { ]; description = "A simple, arrow-based reactive programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "artifact" = callPackage @@ -31313,6 +33042,8 @@ self: { libraryHaskellDepends = [ aeson base bytestring containers text ]; description = "Basic types and instances for Valve's Artifact Card-set API"; license = lib.licenses.agpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "arx" = callPackage @@ -31363,6 +33094,8 @@ self: { testHaskellDepends = [ base hedgehog jwt mtl text time ]; description = "Atlassian Service Authentication Protocol"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ascetic" = callPackage @@ -31453,6 +33186,8 @@ self: { executableHaskellDepends = [ base text ]; description = "Flattens European non-ASCII characaters into ASCII"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ascii-group" = callPackage @@ -31532,6 +33267,8 @@ self: { ]; description = "Compact representation of ASCII strings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ascii-superset" = callPackage @@ -31561,6 +33298,7 @@ self: { ]; description = "ASCII table"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ascii-th" = callPackage @@ -31597,6 +33335,8 @@ self: { ]; description = "Process Ascii Vectors for Advantest 93k"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ascii85-conduit" = callPackage @@ -31609,6 +33349,8 @@ self: { testHaskellDepends = [ base bytestring conduit hspec ]; description = "Conduit for encoding ByteString into Ascii85"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "asciichart" = callPackage @@ -31661,6 +33403,7 @@ self: { executableHaskellDepends = [ asil base bytestring utf8-string ]; description = "Action Script Instrumentation Compiler"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "asif" = callPackage @@ -31721,6 +33464,8 @@ self: { ]; description = "Action Script Instrumentation Library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "asn" = callPackage @@ -31735,6 +33480,8 @@ self: { ]; description = "asn type and encoding/decoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "asn1-codec" = callPackage @@ -31759,6 +33506,8 @@ self: { ]; description = "Encode and decode ASN.1"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "asn1-data" = callPackage @@ -31775,6 +33524,8 @@ self: { libraryHaskellDepends = [ base bytestring cereal mtl text ]; description = "ASN1 data reader and writer in RAW, BER and DER forms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "asn1-encoding" = callPackage @@ -31877,6 +33628,8 @@ self: { ]; description = "Helpers for Control.Exception.assert"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "assert-failure" = callPackage @@ -31901,6 +33654,8 @@ self: { testHaskellDepends = [ base data-default pretty-diff tasty text ]; description = "A set of assertion for writing more readable tests cases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "assert4hs-core" = callPackage @@ -31918,6 +33673,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "A set of assertion for writing more readable tests cases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "assert4hs-hspec" = callPackage @@ -31930,6 +33687,7 @@ self: { testHaskellDepends = [ assert4hs-core base hspec HUnit ]; description = "integration point of assert4hs and hspec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "assert4hs-tasty" = callPackage @@ -31942,6 +33700,7 @@ self: { testHaskellDepends = [ assert4hs-core base tasty ]; description = "Provider for tasty runner to run assert4hs tests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "assertions" = callPackage @@ -31957,6 +33716,8 @@ self: { testHaskellDepends = [ base interpolate process ]; description = "A simple testing framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "asset-bundle" = callPackage @@ -31985,6 +33746,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Asset map support for the JavaScript broccoli-asset-rev library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "assimp" = callPackage @@ -31998,6 +33761,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "The Assimp asset import library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) assimp;}; "assoc" = callPackage @@ -32057,6 +33821,8 @@ self: { ]; description = "An SMTP client library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "assumpta-core" = callPackage @@ -32089,6 +33855,8 @@ self: { testHaskellDepends = [ base ]; description = "A library for constructing AST by using do-notation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ast-monad-json" = callPackage @@ -32103,6 +33871,7 @@ self: { testHaskellDepends = [ ast-monad base hspec text ]; description = "A library for writing JSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ast-path" = callPackage @@ -32158,6 +33927,8 @@ self: { ]; description = "an incomplete 2d space game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "astro" = callPackage @@ -32195,6 +33966,7 @@ self: { ]; description = "A GTK-based abstract syntax tree viewer for custom languages and parsers"; license = lib.licenses.bsdOriginal; + hydraPlatforms = lib.platforms.none; }) {}; "astview-utils" = callPackage @@ -32256,6 +34028,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Async combinators"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "async-dejafu" = callPackage @@ -32272,6 +34046,8 @@ self: { ]; description = "Run MonadConc operations asynchronously and wait for their results"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "async-extra" = callPackage @@ -32324,6 +34100,8 @@ self: { executableHaskellDepends = [ async base stm unordered-containers ]; description = "A thread manager for async"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "async-pool" = callPackage @@ -32406,6 +34184,8 @@ self: { ]; description = "Provides API for timer based execution of IO actions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "asynchronous-exceptions" = callPackage @@ -32417,6 +34197,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Distinguish between synchronous and asynchronous exceptions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aterm" = callPackage @@ -32444,6 +34226,8 @@ self: { executableHaskellDepends = [ aterm base transformers wl-pprint ]; description = "Utility functions for working with aterms as generated by Minitermite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atl" = callPackage @@ -32498,6 +34282,7 @@ self: { ]; description = "Atlassian Connect snaplet for the Snap Framework and helper code"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "atlassian-connect-descriptor" = callPackage @@ -32557,6 +34342,7 @@ self: { libraryHaskellDepends = [ atmos base dimensional-tf ]; description = "dimensional-tf wrapper on atmos package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "atndapi" = callPackage @@ -32581,6 +34367,8 @@ self: { ]; description = "An interface of ATND API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atom" = callPackage @@ -32645,6 +34433,8 @@ self: { libraryHaskellDepends = [ atom base mtl ]; description = "Convenience functions for using Atom with the MSP430 microcontroller family"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atomic-file-ops" = callPackage @@ -32671,6 +34461,8 @@ self: { libraryHaskellDepends = [ base stm ]; description = "A typeclass for mutable references that have an atomic modify operation"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atomic-primops" = callPackage @@ -32700,6 +34492,7 @@ self: { ]; description = "An atomic counter implemented using the FFI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "atomic-primops-vector" = callPackage @@ -32712,6 +34505,8 @@ self: { testHaskellDepends = [ base vector ]; description = "Atomic operations on Data.Vector types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atomic-write" = callPackage @@ -32755,6 +34550,8 @@ self: { ]; description = "A highly dynamic, extremely simple, very fun programming language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atp" = callPackage @@ -32773,6 +34570,7 @@ self: { ]; description = "Interface to automated theorem provers"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "atp-haskell" = callPackage @@ -32790,6 +34588,8 @@ self: { testHaskellDepends = [ base containers HUnit time ]; description = "Translation from Ocaml to Haskell of John Harrison's ATP code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atrans" = callPackage @@ -32873,6 +34673,8 @@ self: { ]; description = "ATS scripts for Cabal builds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ats-storable" = callPackage @@ -32890,6 +34692,8 @@ self: { testSystemDepends = [ storable ]; description = "Marshal ATS types into Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {storable = null;}; "attempt" = callPackage @@ -32901,6 +34705,8 @@ self: { libraryHaskellDepends = [ base failure ]; description = "Concrete data type for handling extensible exceptions as failures. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "attic-schedule" = callPackage @@ -32920,6 +34726,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "A script I use to run \"attic\" for my backups"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atto-lisp" = callPackage @@ -32943,6 +34751,8 @@ self: { ]; description = "Efficient parsing and serialisation of S-Expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "attomail" = callPackage @@ -32965,6 +34775,8 @@ self: { testHaskellDepends = [ base doctest Glob QuickCheck ]; description = "Minimal mail delivery agent (MDA) for local mail with maildir support"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "attoparsec" = callPackage @@ -33110,6 +34922,7 @@ self: { ]; description = "Pass input from an enumerator to an Attoparsec parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "attoparsec-expr" = callPackage @@ -33139,6 +34952,7 @@ self: { ]; description = "Parse IP data types with attoparsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "attoparsec-iso8601" = callPackage @@ -33171,6 +34985,7 @@ self: { ]; description = "An adapter to convert attoparsec Parsers into blazing-fast Iteratees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "attoparsec-parsec" = callPackage @@ -33215,6 +35030,8 @@ self: { libraryHaskellDepends = [ array attoparsec base containers text ]; description = "(deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "attoparsec-text-enumerator" = callPackage @@ -33226,6 +35043,7 @@ self: { libraryHaskellDepends = [ attoparsec-text base enumerator text ]; description = "(deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "attoparsec-time" = callPackage @@ -33252,6 +35070,8 @@ self: { libraryHaskellDepends = [ attoparsec base transformers ]; description = "Interleaved effects for attoparsec parsers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "attoparsec-uri" = callPackage @@ -33273,6 +35093,7 @@ self: { ]; description = "URI parser / printer using attoparsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "attoparsec-varword" = callPackage @@ -33301,6 +35122,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring ]; description = "Split a lazy bytestring at boundaries defined by an attoparsec parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "atuin" = callPackage @@ -33317,6 +35140,7 @@ self: { ]; description = "Embedded Turtle language compiler in Haskell, with Epic output"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "audacity" = callPackage @@ -33358,6 +35182,7 @@ self: { ]; description = "A battery-included audiovisual framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "augeas" = callPackage @@ -33377,6 +35202,8 @@ self: { executablePkgconfigDepends = [ augeas ]; description = "A Haskell FFI wrapper for the Augeas API"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) augeas;}; "augur" = callPackage @@ -33395,6 +35222,8 @@ self: { ]; description = "Renaming media collections in a breeze"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aur" = callPackage @@ -33413,6 +35242,8 @@ self: { ]; description = "Access metadata from the Arch Linux User Repository"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aur-api" = callPackage @@ -33429,6 +35260,8 @@ self: { ]; description = "ArchLinux AUR json v5 API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aura" = callPackage @@ -33463,6 +35296,7 @@ self: { ]; description = "A secure package manager for Arch Linux and the AUR"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "authenticate" = callPackage @@ -33504,6 +35338,8 @@ self: { libraryHaskellDepends = [ base LDAP text transformers ]; description = "LDAP authentication for Haskell web applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "authenticate-oauth" = callPackage @@ -33535,6 +35371,8 @@ self: { libraryHaskellDepends = [ attoparsec base network text ]; description = "Password querying for .authinfo"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "authoring" = callPackage @@ -33553,6 +35391,7 @@ self: { ]; description = "A library for writing papers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "auto" = callPackage @@ -33629,6 +35468,8 @@ self: { ]; description = "Generates and displays patterns from next nearest neighbors cellular automata"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "automata" = callPackage @@ -33653,6 +35494,8 @@ self: { ]; description = "automata"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "automitive-cse" = callPackage @@ -33711,6 +35554,8 @@ self: { ]; description = "Library for Nix expression dependency generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "autonix-deps-kf5" = callPackage @@ -33734,6 +35579,7 @@ self: { ]; description = "Generate dependencies for KDE 5 Nix expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "autopack" = callPackage @@ -33745,6 +35591,8 @@ self: { libraryHaskellDepends = [ base Cabal dir-traverse filepath ]; description = "Custom Setup to automate package modules discovery"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "autoproc" = callPackage @@ -33786,6 +35634,8 @@ self: { executableHaskellDepends = [ base JuicyPixels random ]; description = "A simple random avatar icon generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "average" = callPackage @@ -33832,6 +35682,7 @@ self: { ]; description = "Server-side implementation of the Avers storage model"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "avers-api" = callPackage @@ -33848,6 +35699,7 @@ self: { ]; description = "Types describing the core and extended Avers APIs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "avers-api-docs" = callPackage @@ -33866,6 +35718,7 @@ self: { ]; description = "Swagger documentation for the Avers API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "avers-server" = callPackage @@ -33886,6 +35739,7 @@ self: { ]; description = "Server implementation of the Avers API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "aviation-cessna172-diagrams" = callPackage @@ -33959,6 +35813,8 @@ self: { ]; description = "A compile-time balanced AVL tree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "avr-shake" = callPackage @@ -33970,6 +35826,8 @@ self: { libraryHaskellDepends = [ base dependent-sum mtl process shake ]; description = "AVR Crosspack actions for shake build systems"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "avro" = callPackage @@ -34043,6 +35901,7 @@ self: { ]; description = "Tool for decoding avro"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "avwx" = callPackage @@ -34073,6 +35932,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A prelude which I can be happy with. Based on base-prelude."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "awesomium" = callPackage @@ -34088,6 +35949,7 @@ self: { ]; description = "High-level Awesomium bindings"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "awesomium-glut" = callPackage @@ -34099,6 +35961,7 @@ self: { libraryHaskellDepends = [ awesomium awesomium-raw base GLUT ]; description = "Utilities for using Awesomium with GLUT"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "awesomium-raw" = callPackage @@ -34112,6 +35975,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Low-level Awesomium bindings"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {awesomium = null;}; "aws" = callPackage @@ -34207,6 +36072,8 @@ self: { ]; description = "For signing AWS CloudFront HTTP URL requests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-configuration-tools" = callPackage @@ -34226,6 +36093,7 @@ self: { ]; description = "Configuration types, parsers & renderers for AWS services"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "aws-dynamodb-conduit" = callPackage @@ -34243,6 +36111,7 @@ self: { ]; description = "Conduit-based interface for AWS DynamoDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "aws-dynamodb-streams" = callPackage @@ -34265,6 +36134,7 @@ self: { ]; description = "Haskell bindings for Amazon DynamoDB Streams"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "aws-easy" = callPackage @@ -34288,6 +36158,8 @@ self: { ]; description = "Helper function and types for working with amazonka"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-ec2" = callPackage @@ -34317,6 +36189,8 @@ self: { ]; description = "AWS EC2/VPC, ELB and CloudWatch client library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-ec2-knownhosts" = callPackage @@ -34339,6 +36213,8 @@ self: { ]; description = "Capture and manage AWS EC2 known_host pubkeys"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-elastic-transcoder" = callPackage @@ -34361,6 +36237,7 @@ self: { ]; description = "Haskell suite for the Elastic Transcoder service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aws-general" = callPackage @@ -34386,6 +36263,8 @@ self: { ]; description = "Bindings for Amazon Web Services (AWS) General Reference"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-kinesis" = callPackage @@ -34411,6 +36290,7 @@ self: { ]; description = "Bindings for Amazon Kinesis"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "aws-kinesis-client" = callPackage @@ -34445,6 +36325,7 @@ self: { ]; description = "A producer & consumer client library for AWS Kinesis"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "aws-kinesis-reshard" = callPackage @@ -34473,6 +36354,7 @@ self: { ]; description = "Reshard AWS Kinesis streams in response to Cloud Watch metrics"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "aws-lambda" = callPackage @@ -34492,6 +36374,7 @@ self: { ]; description = "Haskell bindings for AWS Lambda"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "aws-lambda-haskell-runtime" = callPackage @@ -34574,6 +36457,8 @@ self: { ]; description = "Package Haskell functions for easy use on AWS Lambda"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-mfa-credentials" = callPackage @@ -34595,6 +36480,7 @@ self: { ]; description = "Keep your AWS credentials file up to date with MFA-carrying credentials"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "aws-performance-tests" = callPackage @@ -34620,6 +36506,8 @@ self: { ]; description = "Performance Tests for the Haskell bindings for Amazon Web Services (AWS)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-route53" = callPackage @@ -34637,6 +36525,8 @@ self: { ]; description = "Amazon Route53 DNS service plugin for the aws package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-sdk" = callPackage @@ -34665,6 +36555,7 @@ self: { ]; description = "AWS SDK for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aws-sdk-text-converter" = callPackage @@ -34686,6 +36577,8 @@ self: { ]; description = "The text converter for aws-sdk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-sdk-xml-unordered" = callPackage @@ -34706,6 +36599,7 @@ self: { ]; description = "The xml parser for aws-sdk package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aws-ses-easy" = callPackage @@ -34748,6 +36642,7 @@ self: { ]; description = "Amazon Web Services (AWS) Signature v4 HTTP request signer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "aws-simple" = callPackage @@ -34765,6 +36660,8 @@ self: { ]; description = "Dead simple bindings to commonly used AWS Services"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aws-sns" = callPackage @@ -34788,6 +36685,7 @@ self: { ]; description = "Bindings for AWS SNS Version 2013-03-31"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "axel" = callPackage @@ -34839,6 +36737,8 @@ self: { testToolDepends = [ hpack tasty-discover ]; description = "The Axel programming language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "axiom" = callPackage @@ -34855,6 +36755,7 @@ self: { ]; description = "Web EDSL for running in browsers and server nodes using transient"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "axiomatic-classes" = callPackage @@ -34894,6 +36795,7 @@ self: { testHaskellDepends = [ base hspec shelly text urbit-hob ]; description = "Interact with Azimuth from Haskell"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "azubi" = callPackage @@ -34912,6 +36814,8 @@ self: { ]; description = "A simple DevOps tool which will never \"reach\" enterprice level"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "azure-acs" = callPackage @@ -34929,6 +36833,8 @@ self: { ]; description = "Windows Azure ACS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "azure-email" = callPackage @@ -34947,6 +36853,8 @@ self: { ]; description = "send email with microsoft azure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "azure-functions-worker" = callPackage @@ -34974,6 +36882,7 @@ self: { testHaskellDepends = [ base ]; description = "Azure Functions Worker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "azure-service-api" = callPackage @@ -34992,6 +36901,7 @@ self: { ]; description = "Haskell bindings for the Microsoft Azure Service Management API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "azure-servicebus" = callPackage @@ -35009,6 +36919,7 @@ self: { ]; description = "Haskell wrapper over Microsoft Azure ServiceBus REST API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "azurify" = callPackage @@ -35038,6 +36949,8 @@ self: { ]; description = "A simple library for accessing Azure blob storage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "b-tree" = callPackage @@ -35063,6 +36976,7 @@ self: { benchmarkHaskellDepends = [ base criterion pipes ]; description = "Immutable disk-based B* trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "b9" = callPackage @@ -35104,6 +37018,8 @@ self: { ]; description = "A tool and library for building virtual machine images"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "babl" = callPackage @@ -35133,6 +37049,7 @@ self: { ]; description = "An implementation of a simple 2-player board game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "backblaze-b2-hs" = callPackage @@ -35165,6 +37082,7 @@ self: { ]; description = "A client library to access Backblaze B2 cloud storage in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "backdropper" = callPackage @@ -35182,6 +37100,7 @@ self: { ]; description = "Rotates backdrops for X11 displays using Imagemagic"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "backprop" = callPackage @@ -35226,6 +37145,8 @@ self: { ]; description = "Backstop a target directory by source directories"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "backtracking" = callPackage @@ -35257,6 +37178,8 @@ self: { ]; description = "A monad transformer for backtracking exceptions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "backward-state" = callPackage @@ -35268,6 +37191,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A state monad that runs the state in reverse through the computation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bacteria" = callPackage @@ -35293,6 +37218,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple stable bag"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bake" = callPackage @@ -35326,6 +37253,8 @@ self: { ]; description = "Continuous integration system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ballast" = callPackage @@ -35349,6 +37278,7 @@ self: { ]; description = "Shipwire API client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bamboo" = callPackage @@ -35369,6 +37299,7 @@ self: { ]; description = "A blog engine on Hack"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "bamboo-launcher" = callPackage @@ -35389,6 +37320,7 @@ self: { ]; description = "bamboo-launcher"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "bamboo-plugin-highlight" = callPackage @@ -35406,6 +37338,7 @@ self: { ]; description = "A highlight middleware"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "bamboo-plugin-photo" = callPackage @@ -35424,6 +37357,7 @@ self: { ]; description = "A photo album middleware"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bamboo-theme-blueprint" = callPackage @@ -35442,6 +37376,7 @@ self: { ]; description = "bamboo blueprint theme"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bamboo-theme-mini-html5" = callPackage @@ -35464,6 +37399,7 @@ self: { ]; description = "bamboo mini html5 theme"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "bamse" = callPackage @@ -35481,6 +37417,7 @@ self: { ]; description = "A Windows Installer (MSI) generator framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bamstats" = callPackage @@ -35494,6 +37431,7 @@ self: { executableHaskellDepends = [ base cmdargs samtools ]; description = "A program to extract various information from BAM alignmnet files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "ban-instance" = callPackage @@ -35508,6 +37446,8 @@ self: { testHaskellDepends = [ base ]; description = "For when a type should never be an instance of a class"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bank-holiday-usa" = callPackage @@ -35520,6 +37460,8 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck time ]; description = "A library for determining US bank holidays"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bank-holidays-england" = callPackage @@ -35551,6 +37493,8 @@ self: { ]; description = "Generalized word blacklister"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "barbies" = callPackage @@ -35614,6 +37558,8 @@ self: { executableHaskellDepends = [ base cmdargs csv diagrams filepath ]; description = "Creating Bar Charts in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "barcodes-code128" = callPackage @@ -35625,6 +37571,8 @@ self: { libraryHaskellDepends = [ base bytestring HPDF ]; description = "Generate Code 128 barcodes as PDFs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "barecheck" = callPackage @@ -35636,6 +37584,8 @@ self: { libraryHaskellDepends = [ base containers QuickCheck text time ]; description = "QuickCheck implementations for common types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "barley" = callPackage @@ -35668,6 +37618,8 @@ self: { libraryHaskellDepends = [ base containers filepath glib gtk ]; description = "Declarative Gtk GUI library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "barrier" = callPackage @@ -35692,6 +37644,8 @@ self: { ]; description = "Shields.io style badge generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "barrier-monad" = callPackage @@ -35703,6 +37657,8 @@ self: { libraryHaskellDepends = [ base comonad mtl transformers ]; description = "Implementation of barrier monad, can use custom front/back type"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base_4_15_0_0" = callPackage @@ -35755,6 +37711,8 @@ self: { doHaddock = false; description = "Helps migrating projects to base-compat(-batteries)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base-encoding" = callPackage @@ -35770,6 +37728,8 @@ self: { ]; description = "Binary-to-text encodings (e.g. base64)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base-feature-macros" = callPackage @@ -35782,6 +37742,8 @@ self: { doHaddock = false; description = "Semantic CPP feature macros for base"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base-generics" = callPackage @@ -35793,6 +37755,8 @@ self: { libraryHaskellDepends = [ base ]; description = "This library provides some instances for extra GHC.Generic typeclass such as Int8, Word16 and some unboxed types as well."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base-io-access" = callPackage @@ -35804,6 +37768,8 @@ self: { libraryHaskellDepends = [ base ]; description = "The IO functions included in base delimited into small, composable classes"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base-noprelude" = callPackage @@ -35878,6 +37844,8 @@ self: { ]; description = "Fast RFC 4648-compliant Base16 encoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base16-bytestring_0_1_1_7" = callPackage @@ -35926,6 +37894,7 @@ self: { ]; description = "Optics for the Base16 library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "base32" = callPackage @@ -35966,6 +37935,7 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "Fast base32 and base32hex codec for ByteStrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "base32-lens" = callPackage @@ -36086,6 +38056,7 @@ self: { ]; description = "Base62 encoding and decoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "base64" = callPackage @@ -36136,6 +38107,7 @@ self: { ]; description = "Base64 encoding of byte sequences"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "base64-bytestring" = callPackage @@ -36219,6 +38191,8 @@ self: { ]; description = "Base64-encode and decode streams of bytes. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base64-lens" = callPackage @@ -36333,6 +38307,7 @@ self: { ]; description = "Baserock Definitions Schema"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "basex-client" = callPackage @@ -36344,6 +38319,8 @@ self: { libraryHaskellDepends = [ base network pureMD5 utf8-string ]; description = "A BaseX client for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bash" = callPackage @@ -36375,6 +38352,8 @@ self: { ]; description = "Lifting values from base types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "basic-cpuid" = callPackage @@ -36426,6 +38405,8 @@ self: { ]; description = "Basic examples and functions for generics-sop"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "baskell" = callPackage @@ -36442,6 +38423,8 @@ self: { ]; description = "An interpreter for a small functional language"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "batch" = callPackage @@ -36503,6 +38486,7 @@ self: { ]; description = "Batch processing toolset for Linux / Unix"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "battlenet" = callPackage @@ -36516,6 +38500,8 @@ self: { ]; description = "API client for Battle.Net"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "battlenet-yesod" = callPackage @@ -36529,6 +38515,7 @@ self: { ]; description = "Yesod integration for the battlenet package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "battleplace" = callPackage @@ -36582,6 +38569,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Compute number of possible arrangements in the battleship game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "battleships" = callPackage @@ -36614,6 +38603,7 @@ self: { ]; description = "A web-based implementation of battleships including an AI opponent"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bayes-stack" = callPackage @@ -36633,6 +38623,7 @@ self: { ]; description = "Framework for inferring generative probabilistic models with Gibbs sampling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bazel-coverage-report-renderer" = callPackage @@ -36650,6 +38641,8 @@ self: { ]; description = "HTML Coverage Reports for Rules_Haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bazel-runfiles" = callPackage @@ -36696,6 +38689,7 @@ self: { ]; description = "Tools for reading Big Binary Indexed files, e.g., bigBed, bigWig"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bcp47" = callPackage @@ -36792,6 +38786,7 @@ self: { ]; description = "Tools for managing a content store of software packages"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) ostree;}; "bdcs-api" = callPackage @@ -36831,6 +38826,7 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libgit2-glib;}; "bdd" = callPackage @@ -36848,6 +38844,8 @@ self: { ]; description = "Behavior-Driven Development DSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bdelta" = callPackage @@ -36874,6 +38872,8 @@ self: { executableHaskellDepends = [ aeson base network text url ]; description = "Update CSS in the browser without reloading the page"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "beam" = callPackage @@ -36893,6 +38893,8 @@ self: { ]; description = "A type-safe SQL mapper for Haskell that doesn't use Template Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "beam-automigrate" = callPackage @@ -36930,6 +38932,7 @@ self: { ]; description = "DB migration library for beam, targeting Postgres"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "beam-core" = callPackage @@ -36951,6 +38954,8 @@ self: { ]; description = "Type-safe, feature-complete SQL query and manipulation interface for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "beam-migrate" = callPackage @@ -36971,6 +38976,7 @@ self: { ]; description = "SQL DDL support and migrations support library for Beam"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "beam-mysql" = callPackage @@ -36988,6 +38994,7 @@ self: { ]; description = "Connection layer between beam and MySQL/MariaDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "beam-newtype-field" = callPackage @@ -37003,6 +39010,7 @@ self: { ]; description = "A newtype for wrapping newtypes into beam schemas"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "beam-postgres" = callPackage @@ -37029,6 +39037,7 @@ self: { ]; description = "Connection layer between beam and postgres"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "beam-sqlite" = callPackage @@ -37051,6 +39060,7 @@ self: { ]; description = "Beam driver for SQLite"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "beam-th" = callPackage @@ -37072,6 +39082,7 @@ self: { ]; description = "Template Haskell utilities for beam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "beamable" = callPackage @@ -37096,6 +39107,8 @@ self: { ]; description = "Generic serializer/deserializer with compact representation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bearriver" = callPackage @@ -37124,6 +39137,7 @@ self: { executableHaskellDepends = [ array base haskell98 mtl ]; description = "A pretty-printer for higher-order logic"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "bech32" = callPackage @@ -37151,6 +39165,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Implementation of the Bech32 cryptocurrency address format (BIP 0173)"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bech32-th" = callPackage @@ -37168,6 +39184,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Template Haskell extensions to the Bech32 library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bed-and-breakfast" = callPackage @@ -37184,6 +39201,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Efficient Matrix and Vector operations in 100% Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "beeminder-api" = callPackage @@ -37207,6 +39226,8 @@ self: { ]; description = "Bindings to the beeminder.com JSON API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bein" = callPackage @@ -37230,6 +39251,7 @@ self: { ]; description = "Bein is a provenance and workflow management system for bioinformatics"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "belka" = callPackage @@ -37258,6 +39280,7 @@ self: { ]; description = "HTTP client DSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bench" = callPackage @@ -37319,6 +39342,8 @@ self: { testHaskellDepends = [ base split text ]; description = "Show, plot and compare benchmark results"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "benchmark-function" = callPackage @@ -37386,6 +39411,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bencodex reader/writer for Haskell"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bencoding" = callPackage @@ -37432,6 +39459,8 @@ self: { librarySystemDepends = [ db ]; description = "Pretty BerkeleyDB v4 binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) db;}; "berp" = callPackage @@ -37457,6 +39486,7 @@ self: { ]; description = "An implementation of Python 3"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bert" = callPackage @@ -37479,6 +39509,8 @@ self: { ]; description = "BERT implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "besout" = callPackage @@ -37490,6 +39522,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Extended GCD of polynomials over F_p[x]"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bet" = callPackage @@ -37516,6 +39550,8 @@ self: { ]; description = "Betfair API bindings. Bet on sports on betting exchanges."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "betacode" = callPackage @@ -37532,6 +39568,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck smallcheck ]; description = "A codec for beta code (http://en.wikipedia.org/wiki/Beta_Code)."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "betris" = callPackage @@ -37554,6 +39592,8 @@ self: { ]; description = "A horizontal version of tetris for braille users"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "between" = callPackage @@ -37593,6 +39633,7 @@ self: { ]; description = "Bidirectionalization for Free! (POPL'09)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "bff-mono" = callPackage @@ -37625,6 +39666,7 @@ self: { ]; description = "Implementation of the BGAPI serial protocol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bgmax" = callPackage @@ -37636,6 +39678,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring time ]; description = "Parse BgMax-files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bgzf" = callPackage @@ -37651,6 +39695,8 @@ self: { ]; description = "Blocked GZip"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bhoogle" = callPackage @@ -37672,6 +39718,8 @@ self: { ]; description = "Simple terminal GUI for local hoogle"; license = "(BSD-3-Clause OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bibdb" = callPackage @@ -37694,6 +39742,8 @@ self: { executableToolDepends = [ alex happy ]; description = "A database based bibliography manager for BibTeX"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bibtex" = callPackage @@ -37729,6 +39779,8 @@ self: { ]; description = "The unicode bidirectional algorithm via ICU"; license = "(BSD-2-Clause OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {icu-uc = null;}; "bidirectional" = callPackage @@ -37741,6 +39793,8 @@ self: { testHaskellDepends = [ base hedgehog mtl ]; description = "Simple bidirectional serialization and deserialization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bidirectionalization-combined" = callPackage @@ -37760,6 +39814,8 @@ self: { ]; description = "Prototype Implementation of Combining Syntactic and Semantic Bidirectionalization (ICFP'10)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bidispec" = callPackage @@ -37771,6 +39827,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "Specification of generators and parsers"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bidispec-extras" = callPackage @@ -37782,6 +39840,8 @@ self: { libraryHaskellDepends = [ base bytestring dataenc mtl ]; description = "Extra helper functions for bidirectional specifications"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bifunctor" = callPackage @@ -37850,6 +39910,7 @@ self: { ]; description = "A parser for the Billboard chord dataset"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "billeksah-forms" = callPackage @@ -37867,6 +39928,7 @@ self: { ]; description = "Leksah library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "billeksah-main" = callPackage @@ -37885,6 +39947,7 @@ self: { ]; description = "Leksah plugin base"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "billeksah-main-static" = callPackage @@ -37925,6 +39988,7 @@ self: { ]; description = "Leksah library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "billeksah-services" = callPackage @@ -37940,6 +40004,8 @@ self: { ]; description = "Leksah library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bimap" = callPackage @@ -38059,6 +40125,8 @@ self: { ]; description = "Bit parsing/writing on top of binary"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binary-communicator" = callPackage @@ -38070,6 +40138,8 @@ self: { libraryHaskellDepends = [ base binary bytestring mtl ]; description = "Flexible way to ease transmission of binary data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binary-conduit" = callPackage @@ -38100,6 +40170,8 @@ self: { libraryHaskellDepends = [ base binary ghc-prim ]; description = "Automatic deriving of Binary using GHC.Generics"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binary-enum" = callPackage @@ -38136,6 +40208,8 @@ self: { ]; description = "An alternate with strong-typed errors for `Data.Binary.Get` monad from `binary` package."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binary-file" = callPackage @@ -38151,6 +40225,7 @@ self: { ]; description = "read/write binary file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "binary-generic" = callPackage @@ -38203,6 +40278,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Binary Indexed Trees (a.k.a. Fenwick Trees)."; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binary-instances" = callPackage @@ -38355,6 +40432,8 @@ self: { libraryHaskellDepends = [ base binary bytestring mtl ]; description = "Monad to ease implementing a binary network protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binary-protocol-zmq" = callPackage @@ -38370,6 +40449,7 @@ self: { ]; description = "Monad to ease implementing a binary network protocol over ZeroMQ"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "binary-search" = callPackage @@ -38458,6 +40538,7 @@ self: { ]; description = "data serialization/deserialization io-streams library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "binary-strict" = callPackage @@ -38539,6 +40620,8 @@ self: { ]; description = "Type-safe binary serialization"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binary-varint" = callPackage @@ -38591,6 +40674,8 @@ self: { ]; description = "Data marshaling library that uses type level equations to optimize buffering"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binding-core" = callPackage @@ -38619,6 +40704,8 @@ self: { testHaskellDepends = [ base binding-core directory gtk ]; description = "Data Binding in Gtk2Hs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binding-wx" = callPackage @@ -38633,6 +40720,7 @@ self: { testHaskellDepends = [ base binding-core directory wx ]; description = "Data Binding in WxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bindings" = callPackage @@ -38667,6 +40755,8 @@ self: { libraryPkgconfigDepends = [ esound ]; description = "Low level bindings to EsounD (ESD; Enlightened Sound Daemon)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {esound = null;}; "bindings-GLFW" = callPackage @@ -38705,6 +40795,8 @@ self: { librarySystemDepends = [ K8055D ]; description = "Bindings to Velleman K8055 dll"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {K8055D = null;}; "bindings-apr" = callPackage @@ -38717,6 +40809,8 @@ self: { libraryPkgconfigDepends = [ apr ]; description = "Low level bindings to Apache Portable Runtime (APR)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) apr;}; "bindings-apr-util" = callPackage @@ -38729,6 +40823,7 @@ self: { libraryPkgconfigDepends = [ apr-util ]; description = "Low level bindings to Apache Portable Runtime Utility (APR Utility)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {apr-util = null;}; "bindings-audiofile" = callPackage @@ -38756,6 +40851,8 @@ self: { libraryToolDepends = [ alex happy ]; description = "Bindings for libbfd, a library of the GNU `binutils'"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {bfd = null; opcodes = null;}; "bindings-cctools" = callPackage @@ -38768,6 +40865,8 @@ self: { librarySystemDepends = [ dttools ]; description = "Bindings to the CCTools WorkQueue C library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {dttools = null;}; "bindings-codec2" = callPackage @@ -38811,6 +40910,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Library for using firewire (iidc-1394) cameras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {dc1394 = null;}; "bindings-directfb" = callPackage @@ -38839,6 +40940,8 @@ self: { libraryPkgconfigDepends = [ eskit ]; description = "Bindings to ESKit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {eskit = null;}; "bindings-fann" = callPackage @@ -38851,6 +40954,8 @@ self: { libraryPkgconfigDepends = [ fann ]; description = "Low level bindings to FANN neural network library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {fann = null;}; "bindings-fluidsynth" = callPackage @@ -38863,6 +40968,8 @@ self: { libraryPkgconfigDepends = [ fluidsynth ]; description = "Haskell FFI bindings for fluidsynth software synthesizer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fluidsynth;}; "bindings-friso" = callPackage @@ -38875,6 +40982,8 @@ self: { librarySystemDepends = [ friso ]; description = "Low level bindings for friso"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {friso = null;}; "bindings-glib" = callPackage @@ -38923,6 +41032,8 @@ self: { libraryPkgconfigDepends = [ gsl ]; description = "Low level bindings to GNU GSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gsl;}; "bindings-gts" = callPackage @@ -38952,6 +41063,8 @@ self: { executableHaskellDepends = [ base ]; description = "Hamlib bindings for Haskell"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) hamlib;}; "bindings-hdf5" = callPackage @@ -38963,6 +41076,8 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "Project bindings-* raw interface to HDF5 library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bindings-levmar" = callPackage @@ -39012,6 +41127,8 @@ self: { libraryPkgconfigDepends = [ libftdi libusb ]; description = "Low level bindings to libftdi"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libftdi; libusb = null;}; "bindings-libg15" = callPackage @@ -39024,6 +41141,8 @@ self: { librarySystemDepends = [ g15 ]; description = "Bindings to libg15"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {g15 = null;}; "bindings-libpci" = callPackage @@ -39035,6 +41154,8 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "Low level bindings to libpci"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bindings-librrd" = callPackage @@ -39047,6 +41168,8 @@ self: { libraryPkgconfigDepends = [ librrd ]; description = "Low level bindings to RRDtool"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {librrd = null;}; "bindings-libstemmer" = callPackage @@ -39063,6 +41186,8 @@ self: { librarySystemDepends = [ stemmer ]; description = "Binding for libstemmer with low level binding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {stemmer = null;}; "bindings-libusb" = callPackage @@ -39075,6 +41200,8 @@ self: { libraryPkgconfigDepends = [ libusb ]; description = "Low level bindings to libusb"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {libusb = null;}; "bindings-libv4l2" = callPackage @@ -39087,6 +41214,8 @@ self: { librarySystemDepends = [ v4l2 ]; description = "bindings to libv4l2 for Linux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {v4l2 = null;}; "bindings-libzip" = callPackage @@ -39110,6 +41239,7 @@ self: { libraryHaskellDepends = [ base bindings-DSL ioctl ]; description = "bindings to Video For Linux Two (v4l2) kernel interfaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bindings-lxc" = callPackage @@ -39148,6 +41278,8 @@ self: { libraryPkgconfigDepends = [ monetdb-mapi ]; description = "Low-level bindings for the MonetDB API (mapi)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {monetdb-mapi = null;}; "bindings-mpdecimal" = callPackage @@ -39159,6 +41291,8 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "bindings to mpdecimal library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bindings-nettle" = callPackage @@ -39233,6 +41367,7 @@ self: { libraryHaskellDepends = [ base bindings-DSL ioctl ]; description = "PPDev bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bindings-saga-cmd" = callPackage @@ -39281,6 +41416,8 @@ self: { librarySystemDepends = [ scsynth ]; description = "Low-level bindings to the SuperCollider synthesis engine library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {scsynth = null;}; "bindings-sipc" = callPackage @@ -39296,6 +41433,8 @@ self: { executableHaskellDepends = [ base ]; description = "Low level bindings to SIPC"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {sipc = null;}; "bindings-sophia" = callPackage @@ -39354,6 +41493,8 @@ self: { testHaskellDepends = [ base ]; description = "Bindings against the wlc library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {wlc = null;}; "bindings-yices" = callPackage @@ -39380,6 +41521,8 @@ self: { libraryHaskellDepends = [ base binary bytestring rank1dynamic ]; description = "A variation of Data.Dynamic.Dynamic with a Binary instance"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binembed" = callPackage @@ -39398,6 +41541,8 @@ self: { ]; description = "Embed data into object files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "binembed-example" = callPackage @@ -39414,6 +41559,7 @@ self: { ]; description = "Example project using binembed to embed data in object files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bini" = callPackage @@ -39483,6 +41629,8 @@ self: { executableHaskellDepends = [ base bytestring random ]; description = "A bioinformatics library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bio-sequence" = callPackage @@ -39499,6 +41647,8 @@ self: { testHaskellDepends = [ base bytestring hspec QuickCheck ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bioace" = callPackage @@ -39512,6 +41662,7 @@ self: { ]; description = "Library for reading ace assembly files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "bioalign" = callPackage @@ -39523,6 +41674,7 @@ self: { libraryHaskellDepends = [ base biocore bytestring ]; description = "Data structures and helper functions for calculating alignments"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "biocore" = callPackage @@ -39536,6 +41688,8 @@ self: { libraryHaskellDepends = [ base bytestring stringable ]; description = "A bioinformatics library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "biofasta" = callPackage @@ -39547,6 +41701,7 @@ self: { libraryHaskellDepends = [ base biocore bytestring ]; description = "Library for reading fasta sequence files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "biofastq" = callPackage @@ -39558,6 +41713,7 @@ self: { libraryHaskellDepends = [ base biocore bytestring ]; description = "A library for reading FASTQ files"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "biohazard" = callPackage @@ -39580,6 +41736,8 @@ self: { ]; description = "bioinformatics support library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bioinformatics-toolkit" = callPackage @@ -39616,6 +41774,7 @@ self: { ]; description = "A collection of bioinformatics tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "biophd" = callPackage @@ -39631,6 +41790,7 @@ self: { ]; description = "Library for reading phd sequence files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "biopsl" = callPackage @@ -39647,6 +41807,7 @@ self: { executableHaskellDepends = [ cmdargs unordered-containers ]; description = "Library and executables for working with PSL files"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "biosff" = callPackage @@ -39663,6 +41824,7 @@ self: { executableHaskellDepends = [ array base cmdargs mtl ]; description = "Library and executables for working with SFF files"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "biostockholm" = callPackage @@ -39685,6 +41847,7 @@ self: { ]; description = "Parsing and rendering of Stockholm files (used by Pfam, Rfam and Infernal)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bip32" = callPackage @@ -39705,6 +41868,7 @@ self: { ]; description = "BIP-0032: Hierarchical Deterministic Wallets for Bitcoin and other cryptocurrencies"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "birch-beer" = callPackage @@ -39739,6 +41903,7 @@ self: { ]; description = "Plot a colorful tree"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "bird" = callPackage @@ -39759,6 +41924,7 @@ self: { ]; description = "A simple, sinatra-inspired web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "birds-of-paradise" = callPackage @@ -39771,6 +41937,8 @@ self: { testHaskellDepends = [ base ]; description = "Birds of Paradise"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bisc" = callPackage @@ -39808,6 +41976,8 @@ self: { ]; description = "Determine relevant parts of binary data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bishbosh" = callPackage @@ -39838,6 +42008,8 @@ self: { ]; description = "Plays chess"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bit-array" = callPackage @@ -39850,6 +42022,7 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "A bit array (aka bitset, bitmap, bit vector) API for numeric types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bit-protocol" = callPackage @@ -39889,6 +42062,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Lazy, infinite, compact stream of Bool with O(1) indexing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bit-vector" = callPackage @@ -39939,6 +42114,7 @@ self: { ]; description = "Bitcoin address generation and rendering. Parsing coming soon."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-api" = callPackage @@ -39963,6 +42139,7 @@ self: { ]; description = "Provides access to the RPC API of Bitcoin Core"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-api-extra" = callPackage @@ -39985,6 +42162,7 @@ self: { ]; description = "Higher level constructs on top of the bitcoin-api package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-block" = callPackage @@ -40005,6 +42183,7 @@ self: { ]; description = "Utility functions for manipulating bitcoin blocks"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-compact-filters" = callPackage @@ -40027,6 +42206,7 @@ self: { ]; description = "BIP 158 compact block filters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-hash" = callPackage @@ -40064,6 +42244,8 @@ self: { ]; description = "Partial implementation of the Bitcoin protocol (as of 2013)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bitcoin-keys" = callPackage @@ -40081,6 +42263,7 @@ self: { ]; description = "Bitcoin keys"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-payment-channel" = callPackage @@ -40146,6 +42329,7 @@ self: { ]; description = "Library to communicate with the Satoshi Bitcoin daemon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-script" = callPackage @@ -40163,6 +42347,8 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Compilation, manipulation and decompilation of Bitcoin scripts"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bitcoin-scripting" = callPackage @@ -40186,6 +42372,7 @@ self: { ]; description = "Resources for working with miniscript, and script descriptors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-tx" = callPackage @@ -40206,6 +42393,7 @@ self: { ]; description = "Utility functions for manipulating bitcoin transactions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoin-types" = callPackage @@ -40225,6 +42413,7 @@ self: { ]; description = "Provides consistent low-level types used commonly among Bitcoin implementations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoind-regtest" = callPackage @@ -40254,6 +42443,7 @@ self: { ]; description = "A library for working with bitcoin-core regtest networks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bitcoind-rpc" = callPackage @@ -40275,6 +42465,7 @@ self: { ]; description = "A streamlined interface to bitcoin core using Haskoin types and Servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bitly-cli" = callPackage @@ -40290,6 +42481,7 @@ self: { ]; description = "A command line tool to access bit.ly URL shortener."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bitmap" = callPackage @@ -40328,6 +42520,7 @@ self: { ]; description = "Bitmap library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bits" = callPackage @@ -40352,6 +42545,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Atomic bit operations on memory locations for low-level synchronization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bits-bytestring" = callPackage @@ -40401,6 +42596,8 @@ self: { ]; description = "Bitstream support for Conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bits-extra" = callPackage @@ -40437,6 +42634,8 @@ self: { librarySystemDepends = [ gcc_s ]; description = "Efficient high-level bit operations not found in Data.Bits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gcc_s = null;}; "bitset" = callPackage @@ -40459,6 +42658,8 @@ self: { benchmarkSystemDepends = [ gmp ]; description = "A space-efficient set data structure"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gmp;}; "bitset-word8" = callPackage @@ -40501,6 +42702,8 @@ self: { executablePkgconfigDepends = [ gtk2 pango ]; description = "Proof-of-concept tool for writing using binary choices"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtk2; inherit (pkgs) pango;}; "bitstream" = callPackage @@ -40562,6 +42765,7 @@ self: { ]; description = "Bittorrent protocol implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bittrex" = callPackage @@ -40666,6 +42870,8 @@ self: { ]; description = "A Haskell library for working with the BitX bitcoin exchange"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bizzlelude" = callPackage @@ -40692,6 +42898,8 @@ self: { libraryHaskellDepends = [ base containers text ]; description = "A lousy Prelude replacement by a lousy dude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bk-tree" = callPackage @@ -40726,6 +42934,8 @@ self: { ]; description = "Backup utility for backing up to cloud storage services (S3 only right now)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bktrees" = callPackage @@ -40751,6 +42961,7 @@ self: { executableHaskellDepends = [ base haskell98 unix ]; description = "a stupid cron"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "black-jewel" = callPackage @@ -40833,6 +43044,8 @@ self: { libraryHaskellDepends = [ base bytestring text vector ]; description = "The BLAKE SHA-3 candidate hashes, in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blakesum-demo" = callPackage @@ -40850,6 +43063,7 @@ self: { ]; description = "The BLAKE SHA-3 candidate hashes, in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "blank-canvas" = callPackage @@ -40904,6 +43118,8 @@ self: { libraryHaskellDepends = [ base ieee QuickCheck storable-complex ]; description = "Bindings to the BLAS library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blas-carray" = callPackage @@ -40976,6 +43192,7 @@ self: { ]; description = "Library for reading Blast XML output"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "blatex" = callPackage @@ -40993,6 +43210,7 @@ self: { ]; description = "Blog in LaTeX"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "blaze" = callPackage @@ -41063,6 +43281,7 @@ self: { ]; description = "Enumeratees for the incremental conversion of builders to bytestrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "blaze-colonnade" = callPackage @@ -41081,6 +43300,7 @@ self: { testHaskellDepends = [ base colonnade doctest ]; description = "blaze-html backend for colonnade"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "blaze-from-html" = callPackage @@ -41134,6 +43354,8 @@ self: { ]; description = "Some contributions to add handy things to blaze html"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blaze-html-hexpat" = callPackage @@ -41145,6 +43367,8 @@ self: { libraryHaskellDepends = [ base blaze-html bytestring hexpat text ]; description = "A hexpat backend for blaze-html"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blaze-html-truncate" = callPackage @@ -41160,6 +43384,8 @@ self: { ]; description = "A truncator for blaze-html"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blaze-json" = callPackage @@ -41181,6 +43407,8 @@ self: { ]; description = "tiny library for encoding json"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blaze-markup" = callPackage @@ -41259,6 +43487,8 @@ self: { ]; description = "Fast rendering of common datatypes (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blazeMarker" = callPackage @@ -41287,6 +43517,8 @@ self: { ]; description = "A true monad (transformer) version of the blaze-markup and blaze-html libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ble" = callPackage @@ -41318,6 +43550,7 @@ self: { ]; description = "Bluetooth Low Energy (BLE) peripherals"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "blindpass" = callPackage @@ -41351,6 +43584,7 @@ self: { ]; description = "Control library for blink(1) LED from ThingM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "blip" = callPackage @@ -41369,6 +43603,7 @@ self: { ]; description = "Python to bytecode compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bliplib" = callPackage @@ -41384,6 +43619,8 @@ self: { ]; description = "Support code for Blip"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blockchain" = callPackage @@ -41407,6 +43644,8 @@ self: { ]; description = "Generic blockchain implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blockhash" = callPackage @@ -41428,6 +43667,8 @@ self: { testHaskellDepends = [ base ]; description = "Blockhash perceptual image hash algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blocking-transactions" = callPackage @@ -41460,6 +43701,7 @@ self: { executableHaskellDepends = [ base ConfigFile haskell98 old-time ]; description = "Very simple static blog software"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bloodhound" = callPackage @@ -41488,6 +43730,8 @@ self: { ]; description = "Elasticsearch client library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bloodhound-amazonka-auth" = callPackage @@ -41510,6 +43754,7 @@ self: { ]; description = "Adds convenient Amazon ElasticSearch Service authentication to Bloodhound"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bloomfilter" = callPackage @@ -41548,6 +43793,8 @@ self: { benchmarkHaskellDepends = [ base criterion random ]; description = "Distributed bloom filters on Redis (using the Hedis client)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blosum" = callPackage @@ -41569,6 +43816,8 @@ self: { ]; description = "BLOSUM generator"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bloxorz" = callPackage @@ -41583,6 +43832,7 @@ self: { executableHaskellDepends = [ base GLFW OpenGL ]; description = "OpenGL Logic Game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "blubber" = callPackage @@ -41600,6 +43850,7 @@ self: { ]; description = "The blubber client; connects to the blubber server"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "blubber-server" = callPackage @@ -41621,6 +43872,8 @@ self: { ]; description = "The blubber server, serves blubber clients"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blucontrol" = callPackage @@ -41710,6 +43963,7 @@ self: { executablePkgconfigDepends = [ gtk2 ]; description = "full-featured tiling for the GNOME desktop environment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gtk2;}; "bluetileutils" = callPackage @@ -41723,6 +43977,8 @@ self: { executableHaskellDepends = [ base gtk ]; description = "Utilities for Bluetile"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blunk-hask-tests" = callPackage @@ -41738,6 +43994,8 @@ self: { executableHaskellDepends = [ base ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "blunt" = callPackage @@ -41759,6 +44017,7 @@ self: { executableHaskellDepends = [ base ]; description = "Convert between pointfree and pointful expressions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bmp" = callPackage @@ -41783,6 +44042,7 @@ self: { ]; description = "Library for communication with the Bosch BNO055 orientation sensor"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "board-games" = callPackage @@ -41851,6 +44111,8 @@ self: { ]; description = "Copy a directory tree, making zero-size sparse copies of big files"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bogre-banana" = callPackage @@ -41868,6 +44130,7 @@ self: { ]; executableHaskellDepends = [ base hogre hois random ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "boilerplate" = callPackage @@ -41896,6 +44159,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Generate Haskell boilerplate"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bolt" = callPackage @@ -41919,6 +44184,8 @@ self: { ]; description = "Bolt driver for Neo4j"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "boltzmann-brain" = callPackage @@ -41944,6 +44211,8 @@ self: { ]; description = "Analytic sampler compiler for combinatorial systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "boltzmann-samplers" = callPackage @@ -41994,6 +44263,8 @@ self: { ]; description = "Bond schema compiler and code generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bond-haskell" = callPackage @@ -42022,6 +44293,7 @@ self: { ]; description = "Runtime support for BOND serialization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bond-haskell-compiler" = callPackage @@ -42043,6 +44315,7 @@ self: { testHaskellDepends = [ base ]; description = "Bond code generator for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bookkeeper" = callPackage @@ -42070,6 +44343,8 @@ self: { ]; description = "Anonymous records and overloaded labels"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bookkeeper-permissions" = callPackage @@ -42081,6 +44356,7 @@ self: { libraryHaskellDepends = [ base bookkeeper type-level-sets ]; description = "Permissions for bookkeeper records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bookkeeping" = callPackage @@ -42177,6 +44453,8 @@ self: { ]; description = "Boolean normal form: NNF, DNF & CNF"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "boolector" = callPackage @@ -42208,6 +44486,8 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "Boolean expressions with various representations and search queries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bools" = callPackage @@ -42265,6 +44545,8 @@ self: { ]; description = "Chronokinetic stream sources and incremental consumers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "boomerang" = callPackage @@ -42299,6 +44581,7 @@ self: { ]; description = "Boomshine clone"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "boop" = callPackage @@ -42334,6 +44617,7 @@ self: { ]; description = "Mathematically sound sound synthesis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "boots" = callPackage @@ -42370,6 +44654,8 @@ self: { executableHaskellDepends = [ base time ]; description = "Factory for quickly building an application"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "boots-cloud" = callPackage @@ -42387,6 +44673,7 @@ self: { ]; description = "Factory for quickly building a microservice"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "boots-web" = callPackage @@ -42406,6 +44693,7 @@ self: { ]; description = "Factory for quickly building a web application"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bootstrap-types" = callPackage @@ -42460,6 +44748,7 @@ self: { ]; description = "Metering System for OpenStack metrics provided by Vaultaire"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "boring" = callPackage @@ -42500,6 +44789,8 @@ self: { executableHaskellDepends = [ base ]; description = "A boring window switcher"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bot" = callPackage @@ -42511,6 +44802,8 @@ self: { libraryHaskellDepends = [ arrows base Stream ]; description = "bots for functional reactive programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "both" = callPackage @@ -42535,6 +44828,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Build tool for Lambdabot"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bottom" = callPackage @@ -42559,6 +44854,8 @@ self: { ]; description = "Encoding and decoding for the Bottom spec"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bound" = callPackage @@ -42604,6 +44901,8 @@ self: { ]; description = "ScopeH and ScopeT extras for bound"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bound-gen" = callPackage @@ -42626,6 +44925,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Arrays with a value for every index"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bounded-queue" = callPackage @@ -42695,6 +44996,7 @@ self: { ]; description = "audio-visual pseudo-physical simulation of colliding circles"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "box" = callPackage @@ -42722,6 +45024,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "boxes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "box-csv" = callPackage @@ -42738,6 +45041,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "box-socket" = callPackage @@ -42761,6 +45065,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Box websockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "box-tuples" = callPackage @@ -42834,6 +45139,8 @@ self: { ]; description = "Types and functions to work with braids and Khovanov homology"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "brain-bleep" = callPackage @@ -42847,6 +45154,8 @@ self: { executableHaskellDepends = [ array base containers parsec ]; description = "primitive imperative language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "brainfuck" = callPackage @@ -42929,6 +45238,7 @@ self: { executableHaskellDepends = [ base haskgame mtl SDL ]; description = "A simple Breakout game implementation"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "breve" = callPackage @@ -42965,6 +45275,8 @@ self: { executableHaskellDepends = [ array base parallel random SDL ]; description = "A Haskell implementation of the Brian's Brain cellular automaton"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "brick" = callPackage @@ -43009,6 +45321,8 @@ self: { ]; description = "A drop-down menu widget for brick"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "brick-filetree" = callPackage @@ -43068,6 +45382,7 @@ self: { ]; description = "Bricks is a lazy functional language based on Nix"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bricks-internal" = callPackage @@ -43086,6 +45401,8 @@ self: { ]; description = "..."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bricks-internal-test" = callPackage @@ -43101,6 +45418,7 @@ self: { ]; description = "..."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bricks-parsec" = callPackage @@ -43121,6 +45439,7 @@ self: { ]; description = "..."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bricks-rendering" = callPackage @@ -43141,6 +45460,7 @@ self: { ]; description = "..."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bricks-syntax" = callPackage @@ -43161,6 +45481,7 @@ self: { ]; description = "..."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "brillig" = callPackage @@ -43181,6 +45502,8 @@ self: { ]; description = "Simple part of speech tagger"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "brittany" = callPackage @@ -43302,6 +45625,8 @@ self: { libraryHaskellDepends = [ base containers stm time ]; description = "Small library for interactive functional programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "brok" = callPackage @@ -43329,6 +45654,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Finds broken links in text files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "broker-haskell" = callPackage @@ -43342,6 +45669,8 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Haskell bindings to Broker, Bro's messaging library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {broker = null;}; "bronyradiogermany-common" = callPackage @@ -43359,6 +45688,8 @@ self: { ]; description = "Common types and URIs for the BronyRadioGermany API bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bronyradiogermany-streaming" = callPackage @@ -43379,6 +45710,7 @@ self: { ]; description = "Streaming interface for the BronyRadioGermany API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "brotli" = callPackage @@ -43398,6 +45730,8 @@ self: { ]; description = "Brotli (RFC7932) compression and decompression"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) brotli;}; "brotli-conduit" = callPackage @@ -43418,6 +45752,7 @@ self: { ]; description = "Conduit interface for Brotli (RFC7932) compression"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "brotli-streams" = callPackage @@ -43438,6 +45773,7 @@ self: { ]; description = "IO-Streams interface for Brotli (RFC7932) compression"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "browscap" = callPackage @@ -43454,6 +45790,8 @@ self: { ]; description = "A reader and interface for the Browser Capabilities Project data files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bsb-http-chunked" = callPackage @@ -43488,6 +45826,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Access to the BSD sysctl(3) interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bson" = callPackage @@ -43509,6 +45849,8 @@ self: { ]; description = "BSON documents are JSON-like objects with a standard binary encoding"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bson-generic" = callPackage @@ -43520,6 +45862,7 @@ self: { libraryHaskellDepends = [ base bson ghc-prim text ]; description = "Generic functionality for BSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bson-generics" = callPackage @@ -43531,6 +45874,7 @@ self: { libraryHaskellDepends = [ base bson ghc-prim ]; description = "Generics functionality for BSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bson-lens" = callPackage @@ -43542,6 +45886,7 @@ self: { libraryHaskellDepends = [ base bson lens text ]; description = "BSON lenses"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bson-mapping" = callPackage @@ -43588,6 +45933,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A simple unassuming parser for bytestring"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "btree" = callPackage @@ -43607,6 +45954,7 @@ self: { benchmarkHaskellDepends = [ base clock ghc-prim hashable ]; description = "B-Tree on Unmanaged Heap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "btree-concurrent" = callPackage @@ -43629,6 +45977,8 @@ self: { ]; description = "A backend agnostic, concurrent BTree"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "btrfs" = callPackage @@ -43680,6 +46030,7 @@ self: { ]; description = "Automates most of your plain text accounting data entry in ledger format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "buffer" = callPackage @@ -43701,6 +46052,8 @@ self: { benchmarkHaskellDepends = [ bug criterion rerebase ]; description = "Simple mutable low-level buffer for IO"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buffer-builder" = callPackage @@ -43753,6 +46106,8 @@ self: { ]; description = "Serialize Aeson values with Data.BufferBuilder"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buffer-pipe" = callPackage @@ -43795,6 +46150,8 @@ self: { doHaddock = false; description = "Assembles many Dockerfiles in one"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buffon" = callPackage @@ -43811,6 +46168,8 @@ self: { ]; description = "An implementation of Buffon machines"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buffon-machines" = callPackage @@ -43860,6 +46219,8 @@ self: { ]; description = "Bugsnag error reporter for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bugsnag-hs" = callPackage @@ -43897,6 +46258,8 @@ self: { ]; description = "A Haskell interface to the Bugzilla native REST API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bugzilla-redhat" = callPackage @@ -43934,6 +46297,8 @@ self: { testHaskellDepends = [ base containers extra mtl transformers ]; description = "Build systems a la carte"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buildable" = callPackage @@ -43945,6 +46310,8 @@ self: { libraryHaskellDepends = [ base bytestring containers dlist text ]; description = "Typeclass for builders of linear data structures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buildbox" = callPackage @@ -43961,6 +46328,8 @@ self: { ]; description = "Rehackable components for writing buildbots and test harnesses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buildbox-tools" = callPackage @@ -43974,6 +46343,7 @@ self: { executableHaskellDepends = [ base buildbox parseargs ]; description = "Tools for working with buildbox benchmark result files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "builder" = callPackage @@ -43988,6 +46358,8 @@ self: { ]; description = "bounded ByteArray builder type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buildwrapper" = callPackage @@ -44025,6 +46397,7 @@ self: { ]; description = "A library and an executable that provide an easy API for a Haskell IDE"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bullet" = callPackage @@ -44038,6 +46411,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "A wrapper for the Bullet physics engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) bullet;}; "bulletproofs" = callPackage @@ -44075,6 +46450,7 @@ self: { ]; description = "Bulletproofs are short zero-knowledge proofs without a trusted setup"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "bulmex" = callPackage @@ -44118,6 +46494,8 @@ self: { ]; description = "Automatically bump package versions, also transitively"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bunz" = callPackage @@ -44133,6 +46511,8 @@ self: { testHaskellDepends = [ base doctest hspec ]; description = "CLI tool to beautify JSON string"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "burnt-explorer" = callPackage @@ -44150,6 +46530,7 @@ self: { ]; description = "List OP_RETURN cryptocurrency transaction outputs"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "burrito" = callPackage @@ -44180,6 +46561,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Burst detection algorithms"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bus-pirate" = callPackage @@ -44196,6 +46579,7 @@ self: { ]; description = "Haskell interface to the Bus Pirate binary interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "buster" = callPackage @@ -44212,6 +46596,8 @@ self: { ]; description = "Almost but not quite entirely unlike FRP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "buster-gtk" = callPackage @@ -44228,6 +46614,7 @@ self: { ]; description = "Almost but not quite entirely unlike FRP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "buster-network" = callPackage @@ -44244,6 +46631,7 @@ self: { ]; description = "Almost but not quite entirely unlike FRP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bustle" = callPackage @@ -44319,6 +46707,8 @@ self: { ]; description = "Monad Transformer for Asyncronous Message Passing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "butterflies" = callPackage @@ -44340,6 +46730,7 @@ self: { ]; description = "butterfly tilings"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "buttplug-hs-core" = callPackage @@ -44442,6 +46833,8 @@ self: { ]; description = "a bitvector datatype that is parameterized by the vector width"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bv-sized-lens" = callPackage @@ -44453,6 +46846,7 @@ self: { libraryHaskellDepends = [ base bv-sized lens parameterized-utils ]; description = "Well-typed lenses for bv-sized bitvectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "byline" = callPackage @@ -44487,6 +46881,8 @@ self: { libraryHaskellDepends = [ base bytestring word24 ]; description = "data from/to ByteString"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "byte-count-reader" = callPackage @@ -44537,6 +46933,8 @@ self: { libraryHaskellDepends = [ base bytestring primitive text ]; description = "Parsing of bytearray-based data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytebuild" = callPackage @@ -44567,6 +46965,7 @@ self: { ]; description = "Serialize to a small byte arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bytedump" = callPackage @@ -44607,6 +47006,7 @@ self: { ]; description = "Universal hashing of bytes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bytelog" = callPackage @@ -44622,6 +47022,7 @@ self: { ]; description = "Fast logging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "byteorder" = callPackage @@ -44710,6 +47111,7 @@ self: { ]; description = "Nonresumable byte parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bytestring_0_11_1_0" = callPackage @@ -44749,6 +47151,8 @@ self: { ]; description = "Arbitrary instances for ByteStrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-builder" = callPackage @@ -44777,6 +47181,8 @@ self: { ]; description = "Variable-length integer encoding"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-class" = callPackage @@ -44790,6 +47196,8 @@ self: { libraryHaskellDepends = [ base bytestring utf8-string ]; description = "Classes for automatic conversion to and from strict and lazy bytestrings. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-conversion" = callPackage @@ -44825,6 +47233,8 @@ self: { libraryHaskellDepends = [ array base bytestring dlist ]; description = "Parse CSV formatted data efficiently"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-delta" = callPackage @@ -44957,6 +47367,8 @@ self: { ]; description = "Plain byte strings ('ForeignPtr'-less 'ByteString's)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-progress" = callPackage @@ -44996,6 +47408,7 @@ self: { ]; description = "fast ByteString to number converting library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bytestring-rematch" = callPackage @@ -45009,6 +47422,8 @@ self: { doHaddock = false; description = "Rematch support for ByteString"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-short" = callPackage @@ -45038,6 +47453,8 @@ self: { ]; description = "Efficient conversion of values into readable byte strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-strict-builder" = callPackage @@ -45068,6 +47485,8 @@ self: { libraryHaskellDepends = [ base bytestring pipes primitive ]; description = "break bytestrings up into substrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-time" = callPackage @@ -45084,6 +47503,8 @@ self: { ]; description = "Library for Time parsing from ByteString"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-to-vector" = callPackage @@ -45132,6 +47553,8 @@ self: { libraryHaskellDepends = [ base binary bytestring ]; description = "An efficient finite map from (byte)strings to values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-typenats" = callPackage @@ -45150,6 +47573,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion QuickCheck ]; description = "Bytestrings with typenat lengths"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestringparser" = callPackage @@ -45161,6 +47586,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator parsing with Data.ByteString.Lazy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestringparser-temporary" = callPackage @@ -45172,6 +47599,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator parsing with Data.ByteString.Lazy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestringreadp" = callPackage @@ -45183,6 +47612,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A ReadP style parser library for ByteString"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "byteunits" = callPackage @@ -45281,6 +47712,8 @@ self: { libraryHaskellDepends = [ base language-c ]; description = "A higher level DSL on top of language-c"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "c-enum" = callPackage @@ -45303,6 +47736,8 @@ self: { libraryHaskellDepends = [ base ]; description = "C IO"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "c-mosquitto" = callPackage @@ -45323,6 +47758,8 @@ self: { testHaskellDepends = [ base ]; description = "Simpe mosquito MQTT binding able to work with the Amazons IoT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) mosquitto;}; "c-storable" = callPackage @@ -45359,6 +47796,7 @@ self: { executableHaskellDepends = [ base c0parser ]; description = "Simple C0 Syntax Check"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "c0parser" = callPackage @@ -45370,6 +47808,8 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "Simple C0 Parser"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "c10k" = callPackage @@ -45381,6 +47821,8 @@ self: { libraryHaskellDepends = [ base network unix ]; description = "C10k server library using prefork"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "c14n" = callPackage @@ -45416,6 +47858,8 @@ self: { ]; description = "Translate C code into ATS"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "c2hs" = callPackage @@ -45569,6 +48013,8 @@ self: { ]; description = "Check how up-to-date your .cabal dependencies are."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-auto-expose" = callPackage @@ -45604,6 +48050,7 @@ self: { ]; description = "A command line program for managing the dependency versions in a cabal file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cabal-build-programs" = callPackage @@ -45631,6 +48078,8 @@ self: { ]; description = "Bundling C/C++ projects in Cabal package made easy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-cache" = callPackage @@ -45666,6 +48115,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "CI Assistant for Haskell projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cabal-cargs" = callPackage @@ -45688,6 +48138,7 @@ self: { testHaskellDepends = [ base filepath tasty tasty-golden ]; description = "A command line program for extracting compiler arguments from a cabal file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cabal-constraints" = callPackage @@ -45701,6 +48152,8 @@ self: { executableHaskellDepends = [ base Cabal optparse-applicative ]; description = "Repeatable builds for cabalized Haskell projects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-db" = callPackage @@ -45720,6 +48173,8 @@ self: { ]; description = "query tools for the local cabal database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-debian" = callPackage @@ -45759,6 +48214,8 @@ self: { ]; description = "Compose a list of a project's transitive dependencies with their licenses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-dev" = callPackage @@ -45781,6 +48238,8 @@ self: { executableToolDepends = [ cabal-install ]; description = "Manage sandboxed Haskell build environments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-dir" = callPackage @@ -45794,6 +48253,8 @@ self: { executableHaskellDepends = [ base Cabal directory filepath ]; description = "show dist dir of 'cabal copy/install'"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-doctest" = callPackage @@ -45828,6 +48289,8 @@ self: { ]; description = "Cabal utility"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-file" = callPackage @@ -45866,6 +48329,8 @@ self: { testHaskellDepends = [ base Cabal ]; description = "Template Haskell expressions for reading fields from a project's cabal file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-flatpak" = callPackage @@ -45929,6 +48394,8 @@ self: { libraryHaskellDepends = [ base Cabal ghc transformers ]; description = "Conveniently configure GHC's dynamic flags for use with Cabal projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-ghci" = callPackage @@ -45945,6 +48412,8 @@ self: { ]; description = "Set up ghci with options taken from a .cabal file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-graphdeps" = callPackage @@ -45962,6 +48431,8 @@ self: { ]; description = "Generate graphs of install-time Cabal dependencies"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-helper" = callPackage @@ -46012,6 +48483,8 @@ self: { ]; description = "Read information from cabal files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-install" = callPackage @@ -46062,6 +48535,8 @@ self: { executableSystemDepends = [ zlib ]; description = "The (bundled) command-line interface for Cabal and Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) zlib;}; "cabal-install-ghc72" = callPackage @@ -46081,6 +48556,8 @@ self: { ]; description = "Temporary version of cabal-install for ghc-7.2"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-install-ghc74" = callPackage @@ -46100,6 +48577,8 @@ self: { ]; description = "Temporary version of cabal-install for ghc-7.4"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-install-parsers" = callPackage @@ -46146,6 +48625,8 @@ self: { ]; description = "Lenses and traversals for the Cabal library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-macosx" = callPackage @@ -46193,6 +48674,8 @@ self: { ]; description = "build multiple packages at once"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-mon" = callPackage @@ -46210,6 +48693,8 @@ self: { ]; description = "A monitor for cabal builds"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-nirvana" = callPackage @@ -46227,6 +48712,8 @@ self: { ]; description = "Avoid Cabal dependency hell by constraining to known good versions. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-plan" = callPackage @@ -46267,6 +48754,8 @@ self: { executableHaskellDepends = [ base Cabal directory filepath ]; description = "Show dependencies of program being built in current directory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-query" = callPackage @@ -46283,6 +48772,7 @@ self: { ]; description = "Helpers for quering .cabal files or hackageDB's 00-index.tar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cabal-rpm" = callPackage @@ -46330,6 +48820,8 @@ self: { executableHaskellDepends = [ base Cabal ]; description = "The user interface for building and installing Cabal packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-sign" = callPackage @@ -46366,6 +48858,8 @@ self: { ]; description = "Topologically sort cabal packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-src" = callPackage @@ -46387,6 +48881,8 @@ self: { ]; description = "Alternative install procedure to avoid the diamond dependency issue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-test" = callPackage @@ -46402,6 +48898,7 @@ self: { ]; description = "Automated test tool for cabal projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cabal-test-bin" = callPackage @@ -46443,6 +48940,8 @@ self: { libraryHaskellDepends = [ base Cabal QuickCheck ]; description = "QuickCheck for Cabal"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal-toolkit" = callPackage @@ -46484,6 +48983,8 @@ self: { executableHaskellDepends = [ base filepath HTTP network ]; description = "Command-line tool for uploading packages to Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal2arch" = callPackage @@ -46503,6 +49004,7 @@ self: { ]; description = "Create Arch Linux packages from Cabal packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cabal2doap" = callPackage @@ -46518,6 +49020,8 @@ self: { ]; description = "Cabal to Description-of-a-Project (DOAP)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal2ebuild" = callPackage @@ -46532,6 +49036,8 @@ self: { executableHaskellDepends = [ base curl directory ]; description = "make gentoo's .ebuild file from .cabal file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal2ghci" = callPackage @@ -46550,6 +49056,8 @@ self: { ]; description = "A tool to generate .ghci file from .cabal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabal2nix" = callPackage @@ -46627,6 +49135,8 @@ self: { ]; description = "A simple tool to query cabal files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabalg" = callPackage @@ -46661,6 +49171,8 @@ self: { ]; description = "Generate pretty graphs of module trees from cabal files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabalish" = callPackage @@ -46679,6 +49191,8 @@ self: { ]; description = "Provides access to the cabal file data for shell scripts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabalmdvrpm" = callPackage @@ -46693,6 +49207,7 @@ self: { executableHaskellDepends = [ base Cabal cabalrpmdeps haskell98 ]; description = "Create mandriva rpm from cabal package"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "cabalrpmdeps" = callPackage @@ -46707,6 +49222,7 @@ self: { executableHaskellDepends = [ base Cabal filepath haskell98 ]; description = "Autogenerate rpm dependencies from cabal files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "cabalvchk" = callPackage @@ -46720,6 +49236,8 @@ self: { executableHaskellDepends = [ base Cabal ]; description = "Verify installed package version against user-specified constraints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabin" = callPackage @@ -46738,6 +49256,8 @@ self: { ]; description = "Cabal binary sandboxes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cabocha" = callPackage @@ -46750,6 +49270,8 @@ self: { librarySystemDepends = [ cabocha ]; testHaskellDepends = [ base text-format ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {cabocha = null;}; "cache" = callPackage @@ -46784,6 +49306,8 @@ self: { ]; description = "cached hashmaps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cached" = callPackage @@ -46801,6 +49325,8 @@ self: { ]; description = "Cache values to disk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cached-io" = callPackage @@ -46848,6 +49374,8 @@ self: { ]; description = "Cache combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "caching-vault" = callPackage @@ -46962,6 +49490,8 @@ self: { ]; description = "A library implementing the Noise protocol"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "caerbannog" = callPackage @@ -47000,6 +49530,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Prelude subsets—take only what you want!"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "caffegraph" = callPackage @@ -47018,6 +49550,8 @@ self: { protocol-buffers-descriptor template-haskell temporary text ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cairo" = callPackage @@ -47083,6 +49617,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Cairo Haskell binding (partial)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) cairo;}; "cake" = callPackage @@ -47105,6 +49641,7 @@ self: { ]; description = "A build-system library and driver"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "cake3" = callPackage @@ -47134,6 +49671,8 @@ self: { ]; description = "Third cake the Makefile EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cakyrespa" = callPackage @@ -47151,6 +49690,7 @@ self: { ]; description = "run turtle like LOGO with lojban"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cal-layout" = callPackage @@ -47165,6 +49705,8 @@ self: { executableHaskellDepends = [ base ]; description = "Calendar Layout Algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cal3d" = callPackage @@ -47177,6 +49719,8 @@ self: { librarySystemDepends = [ cal3d ]; description = "Haskell binding to the Cal3D animation library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {cal3d = null;}; "cal3d-examples" = callPackage @@ -47191,6 +49735,7 @@ self: { executableHaskellDepends = [ base cal3d cal3d-opengl OpenGL SDL ]; description = "Examples for the Cal3d animation library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "cal3d-opengl" = callPackage @@ -47202,6 +49747,7 @@ self: { libraryHaskellDepends = [ base cal3d OpenGL ]; description = "OpenGL rendering for the Cal3D animation library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "calamity" = callPackage @@ -47231,6 +49777,8 @@ self: { ]; description = "A library for writing discord bots in haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "calamity-commands" = callPackage @@ -47260,6 +49808,7 @@ self: { executableHaskellDepends = [ array base harpy haskell98 mtl ]; description = "A small compiler for arithmetic expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "calculator" = callPackage @@ -47281,6 +49830,7 @@ self: { ]; description = "A calculator repl, with variables, functions & Mathematica like dynamic plots"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "caldims" = callPackage @@ -47301,6 +49851,7 @@ self: { ]; description = "Calculation tool and library supporting units"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "caledon" = callPackage @@ -47318,6 +49869,8 @@ self: { ]; description = "a logic programming language based on the calculus of constructions"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "calendar-recycling" = callPackage @@ -47348,6 +49901,8 @@ self: { ]; description = "Commandline tool to get week of the year"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "call" = callPackage @@ -47373,6 +49928,7 @@ self: { ]; description = "The call game engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "call-alloy" = callPackage @@ -47394,6 +49950,8 @@ self: { ]; description = "A simple library to call Alloy given a specification"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "call-haskell-from-anything" = callPackage @@ -47412,6 +49970,8 @@ self: { executableHaskellDepends = [ base bytestring data-msgpack mtl ]; description = "Call Haskell functions from other languages via serialization and dynamic libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "call-stack" = callPackage @@ -47461,6 +50021,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "CamFort - Cambridge Fortran infrastructure"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) flint;}; "camh" = callPackage @@ -47493,6 +50054,7 @@ self: { ]; description = "Haskell implementation of the Campfire API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "can-i-haz" = callPackage @@ -47537,6 +50099,7 @@ self: { ]; description = "Candid integration"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "canon" = callPackage @@ -47548,6 +50111,8 @@ self: { libraryHaskellDepends = [ arithmoi array base containers random ]; description = "Arithmetic for Psychedelically Large Numbers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "canonical-filepath" = callPackage @@ -47559,6 +50124,8 @@ self: { libraryHaskellDepends = [ base deepseq directory filepath ]; description = "Abstract data type for canonical file paths"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "canonical-json" = callPackage @@ -47582,6 +50149,8 @@ self: { benchmarkHaskellDepends = [ base bytestring containers criterion ]; description = "Canonical JSON for signing and hashing JSON values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "canteven-config" = callPackage @@ -47612,6 +50181,7 @@ self: { ]; description = "Utilities for HTTP programming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "canteven-listen-http" = callPackage @@ -47623,6 +50193,8 @@ self: { libraryHaskellDepends = [ aeson base ]; description = "data types to describe HTTP services"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "canteven-log" = callPackage @@ -47640,6 +50212,8 @@ self: { ]; description = "A canteven way of setting up logging for your program"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "canteven-parsedate" = callPackage @@ -47655,6 +50229,8 @@ self: { ]; description = "Date / time parsing utilities that try to guess the date / time format"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "canteven-template" = callPackage @@ -47693,6 +50269,8 @@ self: { ]; description = "Application for analysis of java source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cantor-pairing" = callPackage @@ -47731,6 +50309,7 @@ self: { executableToolDepends = [ alex happy ]; description = "CAO Compiler"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "cap" = callPackage @@ -47745,6 +50324,7 @@ self: { executableHaskellDepends = [ array base containers haskell98 ]; description = "Interprets and debug the cap language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "capability" = callPackage @@ -47831,6 +50411,8 @@ self: { ]; description = "Cap'n Proto for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "capped-list" = callPackage @@ -47842,6 +50424,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A list-like type for lazy sequences, with a user-defined termination value"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "capri" = callPackage @@ -47857,6 +50441,8 @@ self: { ]; description = "A simple wrapper over cabal-install to operate in project-private mode"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "caps" = callPackage @@ -47895,6 +50481,7 @@ self: { ]; description = "Simple web-server for organizing car-pooling for an event"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "caramia" = callPackage @@ -47919,6 +50506,8 @@ self: { ]; description = "High-level OpenGL bindings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "carbonara" = callPackage @@ -47933,6 +50522,8 @@ self: { ]; description = "some spaghetti code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "carboncopy" = callPackage @@ -47950,6 +50541,7 @@ self: { ]; description = "Drop emails from threads being watched into special CC folder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cardano-coin-selection" = callPackage @@ -48027,6 +50619,8 @@ self: { ]; description = "A presentation tool written with Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "carray" = callPackage @@ -48062,6 +50656,8 @@ self: { ]; description = "Carte: A commandline pastebin server"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cartel" = callPackage @@ -48090,6 +50686,7 @@ self: { ]; description = "Specify Cabal files in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cas-hashable" = callPackage @@ -48171,6 +50768,8 @@ self: { ]; description = "CASA Abbreviations and Acronyms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "casa-client" = callPackage @@ -48232,6 +50831,7 @@ self: { ]; description = "mid-level bindings to CasADi"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {casadi = null;}; "casadi-bindings-control" = callPackage @@ -48248,6 +50848,7 @@ self: { libraryPkgconfigDepends = [ casadi_control ]; description = "low level bindings to casadi-control"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {casadi_control = null;}; "casadi-bindings-core" = callPackage @@ -48264,6 +50865,7 @@ self: { librarySystemDepends = [ casadi ]; description = "autogenerated low level bindings to casadi"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {casadi = null;}; "casadi-bindings-internal" = callPackage @@ -48276,6 +50878,8 @@ self: { librarySystemDepends = [ casadi ]; description = "low level bindings to CasADi"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {casadi = null;}; "casadi-bindings-ipopt-interface" = callPackage @@ -48292,6 +50896,7 @@ self: { libraryPkgconfigDepends = [ casadi_ipopt_interface ]; description = "low level bindings to casadi-ipopt_interface"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {casadi_ipopt_interface = null;}; "casadi-bindings-snopt-interface" = callPackage @@ -48308,6 +50913,7 @@ self: { libraryPkgconfigDepends = [ casadi_snopt_interface ]; description = "low level bindings to casadi-snopt_interface"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {casadi_snopt_interface = null;}; "cascading" = callPackage @@ -48324,6 +50930,8 @@ self: { ]; description = "DSL for HTML CSS (Cascading Style Sheets)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "case-conversion" = callPackage @@ -48400,6 +51008,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Combinators for casing on constructors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cases" = callPackage @@ -48431,6 +51041,7 @@ self: { ]; description = "the Computer Algebra SHell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "casing" = callPackage @@ -48637,6 +51248,7 @@ self: { ]; description = "Haskell client for Cassandra's CQL protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cassandra-thrift" = callPackage @@ -48696,6 +51308,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Conduit interface for cassava package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cassava-embed" = callPackage @@ -48770,6 +51384,8 @@ self: { ]; description = "Auto-generation of records data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cassava-streams" = callPackage @@ -48802,6 +51418,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A combinator library for simultaneously defining parsers and pretty printers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cassy" = callPackage @@ -48829,6 +51447,7 @@ self: { ]; description = "A high level driver for the Cassandra datastore"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cast" = callPackage @@ -48900,6 +51519,8 @@ self: { ]; description = "A tool to manage shared cabal-install sandboxes"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "casui" = callPackage @@ -48914,6 +51535,7 @@ self: { executableHaskellDepends = [ base gtk haskell98 mtl parsec ]; description = "Equation Manipulator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "catalyst" = callPackage @@ -48937,6 +51559,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Exposes a Template Haskell function for generating catamorphisms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "catch-fd" = callPackage @@ -48948,6 +51572,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "MonadThrow and MonadCatch, using functional dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "categorical-algebra" = callPackage @@ -48959,6 +51585,7 @@ self: { libraryHaskellDepends = [ base newtype pointless-haskell void ]; description = "Categorical Monoids and Semirings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "categories" = callPackage @@ -49008,6 +51635,7 @@ self: { doHaddock = false; description = "A meta-package documenting various packages inspired by category theory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "category-printf" = callPackage @@ -49032,6 +51660,8 @@ self: { libraryHaskellDepends = [ base categories ]; description = "Traced monoidal categories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "catnplus" = callPackage @@ -49051,6 +51681,8 @@ self: { ]; description = "Simple tool to display text files with line numbers and paging"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cautious" = callPackage @@ -49080,6 +51712,8 @@ self: { ]; description = "Ways to write a file cautiously, to reduce the chances of problems such as data loss due to crashes or power failures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cautious-gen" = callPackage @@ -49096,6 +51730,8 @@ self: { hspec QuickCheck ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cayene-lpp" = callPackage @@ -49112,6 +51748,8 @@ self: { testHaskellDepends = [ base base16-bytestring hspec ]; description = "Cayenne Low Power Payload"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cayenne-lpp" = callPackage @@ -49149,6 +51787,8 @@ self: { testHaskellDepends = [ aeson base hspec unordered-containers ]; description = "A Haskell client for the Cayley graph database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cayley-dickson" = callPackage @@ -49285,6 +51925,8 @@ self: { ]; description = "Bindings for the CCI networking library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {cci = null;}; "ccnx" = callPackage @@ -49296,6 +51938,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "A Haskell implementation of the CCNx network protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cctools-workqueue" = callPackage @@ -49312,6 +51956,7 @@ self: { librarySystemDepends = [ dttools ]; description = "High-level interface to CCTools' WorkQueue library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {dttools = null;}; "cdeps" = callPackage @@ -49350,6 +51995,8 @@ self: { ]; description = "Convenient Chinese phrase & character lookup"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cef" = callPackage @@ -49364,6 +52011,8 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "CEF log format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cef3-raw" = callPackage @@ -49377,6 +52026,8 @@ self: { libraryPkgconfigDepends = [ gtk2 ]; description = "Raw CEF3 bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {cef = null; inherit (pkgs) gtk2;}; "cef3-simple" = callPackage @@ -49388,6 +52039,7 @@ self: { libraryHaskellDepends = [ base cef3-raw ]; description = "Simple wrapper around cef3-raw"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ceilometer-common" = callPackage @@ -49411,6 +52063,7 @@ self: { ]; description = "Common Haskell types and encoding for OpenStack Ceilometer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cellrenderer-cairo" = callPackage @@ -49424,6 +52077,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Cairo-based CellRenderer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtk2;}; "celtchar" = callPackage @@ -49448,6 +52103,7 @@ self: { testHaskellDepends = [ base hspec raw-strings-qq ]; description = "A tool to build a novel"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cerberus" = callPackage @@ -49475,6 +52131,8 @@ self: { testHaskellDepends = [ base ]; description = "Protect and control API access with cerberus"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cereal" = callPackage @@ -49536,6 +52194,8 @@ self: { libraryHaskellDepends = [ base cereal ghc-prim ]; description = "Automatic deriving of Serialize using GHC.Generics"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cereal-enumerator" = callPackage @@ -49547,6 +52207,7 @@ self: { libraryHaskellDepends = [ base bytestring cereal enumerator ]; description = "Deserialize things with cereal and enumerator"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "cereal-ieee754" = callPackage @@ -49558,6 +52219,8 @@ self: { libraryHaskellDepends = [ array base cereal ]; description = "Floating point support for the 'cereal' serialization library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cereal-io-streams" = callPackage @@ -49580,6 +52243,7 @@ self: { ]; description = "io-streams support for the cereal binary serialization library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cereal-plus" = callPackage @@ -49603,6 +52267,8 @@ self: { ]; description = "An extended serialization library on top of \"cereal\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cereal-streams" = callPackage @@ -49625,6 +52291,7 @@ self: { ]; description = "Use cereal to encode/decode io-streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cereal-text" = callPackage @@ -49705,6 +52372,7 @@ self: { ]; description = "Certificates and Key Reader/Writer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cf" = callPackage @@ -49722,6 +52390,8 @@ self: { ]; description = "Exact real arithmetic using continued fractions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cfenv" = callPackage @@ -49738,6 +52408,8 @@ self: { ]; description = "A library getting the environment when running on Cloud Foundry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cfipu" = callPackage @@ -49755,6 +52427,7 @@ self: { ]; description = "cfipu processor for toy brainfuck-like language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cflp" = callPackage @@ -49773,6 +52446,7 @@ self: { ]; description = "Constraint Functional-Logic Programming in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cfopu" = callPackage @@ -49790,6 +52464,7 @@ self: { ]; description = "cfopu processor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cg" = callPackage @@ -49810,6 +52485,8 @@ self: { ]; description = "Parser for categorial grammars"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cgen" = callPackage @@ -49829,6 +52506,8 @@ self: { doHaddock = false; description = "generates Haskell bindings and C wrappers for C++ libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cgi" = callPackage @@ -49871,6 +52550,8 @@ self: { libraryHaskellDepends = [ base cgi containers mtl random ]; description = "Simple modular utilities for CGI/FastCGI (sessions, etc.)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cgrep" = callPackage @@ -49896,6 +52577,7 @@ self: { ]; description = "Command line tool"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "chain-codes" = callPackage @@ -49934,6 +52616,7 @@ self: { ]; description = "Mining Client for Kadena Chainweb"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chakra" = callPackage @@ -49981,6 +52664,7 @@ self: { ]; description = "A REST Web Api server template for building (micro)services"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "chalk" = callPackage @@ -50010,6 +52694,8 @@ self: { ]; description = "Combinators for building and processing 2D images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chalkboard-viewer" = callPackage @@ -50021,6 +52707,7 @@ self: { libraryHaskellDepends = [ array base chalkboard GLUT OpenGL time ]; description = "OpenGL based viewer for chalkboard rendered images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chalmers-lava2000" = callPackage @@ -50143,6 +52830,8 @@ self: { ]; description = "Exposes subspecies types of Char. And naming cases."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "charade" = callPackage @@ -50166,6 +52855,7 @@ self: { ]; description = "Rapid prototyping websites with Snap and Heist"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "charset" = callPackage @@ -50222,6 +52912,7 @@ self: { ]; description = "Command-line utility to draw charts from input data easily"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chart-histogram" = callPackage @@ -50233,6 +52924,8 @@ self: { libraryHaskellDepends = [ base Chart ]; description = "Easily render histograms with Chart"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chart-svg" = callPackage @@ -50262,6 +52955,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Charting library targetting SVGs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chart-svg-various" = callPackage @@ -50285,6 +52979,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chart-unit" = callPackage @@ -50309,6 +53004,7 @@ self: { ]; description = "Native haskell charts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "charter" = callPackage @@ -50336,6 +53032,8 @@ self: { process scientific text wai warp ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chaselev-deque" = callPackage @@ -50441,6 +53139,8 @@ self: { libraryHaskellDepends = [ base chatty transformers ]; description = "Provides some classes and types for dealing with text, using the fundaments of Chatty"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chatty-utils" = callPackage @@ -50480,6 +53180,8 @@ self: { ]; description = "The ChatWork API in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cheapskate" = callPackage @@ -50557,6 +53259,7 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "check-email" = callPackage @@ -50588,6 +53291,7 @@ self: { ]; description = "Check whether module and package imports conform to the PVP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "checked" = callPackage @@ -50601,6 +53305,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Bounds-checking integer types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "checkers" = callPackage @@ -50644,6 +53350,8 @@ self: { ]; description = "Generate checklists relevant to a given patch"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "checksum" = callPackage @@ -50695,6 +53403,8 @@ self: { libraryHaskellDepends = [ base chell QuickCheck random ]; description = "QuickCheck support for the Chell testing library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cherry-core-alpha" = callPackage @@ -50787,6 +53497,7 @@ self: { ]; description = "Query interface for Chevalier"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chiasma" = callPackage @@ -50880,6 +53591,7 @@ self: { testHaskellDepends = [ base ]; description = "Helper for the Major System"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "choice" = callPackage @@ -50902,6 +53614,8 @@ self: { libraryHaskellDepends = [ base MonadRandom ]; description = "Choose random elements from a stream"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "choose-exe" = callPackage @@ -50918,6 +53632,7 @@ self: { ]; description = "Command-line program to choose random element from a stream"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "chorale" = callPackage @@ -50935,6 +53650,8 @@ self: { ]; description = "A module containing basic functions that the prelude does not offer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chorale-geo" = callPackage @@ -50952,6 +53669,7 @@ self: { ]; description = "A module containing basic geo functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "chp" = callPackage @@ -50967,6 +53685,8 @@ self: { ]; description = "An implementation of concurrency ideas from Communicating Sequential Processes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chp-mtl" = callPackage @@ -50978,6 +53698,7 @@ self: { libraryHaskellDepends = [ base chp chp-plus mtl ]; description = "MTL class instances for the CHP library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chp-plus" = callPackage @@ -50994,6 +53715,7 @@ self: { ]; description = "A set of high-level concurrency utilities built on Communicating Haskell Processes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chp-spec" = callPackage @@ -51009,6 +53731,8 @@ self: { ]; description = "A mirror implementation of chp that generates a specification of the program"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chp-transformers" = callPackage @@ -51020,6 +53744,7 @@ self: { libraryHaskellDepends = [ base chp chp-plus transformers ]; description = "Transformers instances for the CHP library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chr-core" = callPackage @@ -51036,6 +53761,7 @@ self: { ]; description = "Constraint Handling Rules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chr-data" = callPackage @@ -51073,6 +53799,7 @@ self: { executableHaskellDepends = [ base chr-data ]; description = "AST + surface language around chr"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chr-parse" = callPackage @@ -51086,6 +53813,8 @@ self: { libraryHaskellDepends = [ base containers uulib ]; description = "Parsing for chr library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chr-pretty" = callPackage @@ -51147,6 +53876,8 @@ self: { ]; description = "measure timings of data evaluation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "chronologique" = callPackage @@ -51286,6 +54017,7 @@ self: { ]; description = "FFI for Chu2 Agda Web Server Interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "chuchu" = callPackage @@ -51330,6 +54062,7 @@ self: { libraryHaskellDepends = [ base haskell98 parsec template-haskell ]; description = "Simple template library with static safety"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "chunky" = callPackage @@ -51345,6 +54078,8 @@ self: { testHaskellDepends = [ base binary bytestring HUnit text ]; description = "Human-readable storage of text/binary objects"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "church" = callPackage @@ -51356,6 +54091,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Automatically convert Generic instances to and from church representations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "church-list" = callPackage @@ -51379,6 +54116,8 @@ self: { libraryHaskellDepends = [ base deepseq semigroupoids semigroups ]; description = "Church encoded Maybe"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "church-pair" = callPackage @@ -51432,6 +54171,8 @@ self: { ]; description = "Cielo API v3 Bindings for Haskell"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cil" = callPackage @@ -51443,6 +54184,8 @@ self: { libraryHaskellDepends = [ base bytestring language-c ]; description = "An interface to CIL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cimple" = callPackage @@ -51475,6 +54218,8 @@ self: { librarySystemDepends = [ cinvoke ]; description = "A binding to cinvoke"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {cinvoke = null;}; "cio" = callPackage @@ -51486,6 +54231,8 @@ self: { libraryHaskellDepends = [ base monad-stm mtl parallel-io stm ]; description = "A monad for concurrent IO on a thread pool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cipher-aes" = callPackage @@ -51559,6 +54306,8 @@ self: { ]; description = "Blowfish cipher"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cipher-camellia" = callPackage @@ -51659,6 +54408,7 @@ self: { executableHaskellDepends = [ array base bytestring parseargs ]; description = "Implementation of CipherSaber2 RC4 cryptography"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "circ" = callPackage @@ -51700,6 +54450,8 @@ self: { ]; description = "The CircleCI REST API for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "circuit-breaker" = callPackage @@ -51745,6 +54497,8 @@ self: { benchmarkHaskellDepends = [ base criterion vector ]; description = "Circular fixed-sized mutable vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cirru-parser" = callPackage @@ -51807,6 +54561,7 @@ self: { ]; description = "convert document IDs such as DOI, ISBN, arXiv ID to bibliographic reference"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "citeproc" = callPackage @@ -51852,6 +54607,8 @@ self: { ]; description = "A Citation Style Language implementation in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "citeproc-hs-pandoc-filter" = callPackage @@ -51871,6 +54628,7 @@ self: { ]; description = "A Pandoc filter for processing bibliographic references with citeproc-hs"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "cityhash" = callPackage @@ -51910,6 +54668,8 @@ self: { ]; description = "A new Haskeleton package"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cjk" = callPackage @@ -51927,6 +54687,8 @@ self: { testHaskellDepends = [ base ]; description = "Data about Chinese, Japanese and Korean characters and languages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cl3" = callPackage @@ -51980,6 +54742,7 @@ self: { ]; description = "Simple CLI RPN calculator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "clafer" = callPackage @@ -52014,6 +54777,7 @@ self: { ]; description = "Compiles Clafer models to other formats: Alloy, JavaScript, JSON, HTML, Dot"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "claferIG" = callPackage @@ -52046,6 +54810,7 @@ self: { ]; description = "claferIG is an interactive tool that generates instances of Clafer models"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "claferwiki" = callPackage @@ -52065,6 +54830,7 @@ self: { ]; description = "A wiki-based IDE for literate modeling with Clafer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "clang-compilation-database" = callPackage @@ -52077,6 +54843,8 @@ self: { testHaskellDepends = [ aeson base bytestring ]; description = "JSON Compilation Database Format encoding and decoding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clang-pure" = callPackage @@ -52099,6 +54867,8 @@ self: { testHaskellDepends = [ base bytestring lens ]; description = "Pure C++ code analysis with libclang"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (self.llvmPackages) clang;}; "clanki" = callPackage @@ -52114,6 +54884,8 @@ self: { ]; description = "Command-line spaced-repetition software"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clarifai" = callPackage @@ -52131,6 +54903,8 @@ self: { ]; description = "API Client for the Clarifai API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clash" = callPackage @@ -52150,6 +54924,7 @@ self: { ]; description = "CAES Language for Synchronous Hardware (CLaSH)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clash-ghc" = callPackage @@ -52179,6 +54954,7 @@ self: { executableHaskellDepends = [ base ]; description = "CAES Language for Synchronous Hardware"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "clash-ghc_1_4_1" = callPackage @@ -52249,6 +55025,7 @@ self: { ]; description = "CAES Language for Synchronous Hardware - As a Library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "clash-lib_1_4_1" = callPackage @@ -52306,6 +55083,7 @@ self: { base clash-prelude deepseq ghc-typelits-knownnat QuickCheck ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clash-prelude" = callPackage @@ -52344,6 +55122,8 @@ self: { ]; description = "CAES Language for Synchronous Hardware - Prelude library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clash-prelude_1_4_1" = callPackage @@ -52385,6 +55165,7 @@ self: { description = "Clash: a functional hardware description language - Prelude library"; license = lib.licenses.bsd2; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clash-prelude-quickcheck" = callPackage @@ -52415,6 +55196,7 @@ self: { ]; description = "CAES Language for Synchronous Hardware - SystemVerilog backend"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "clash-verilog" = callPackage @@ -52432,6 +55214,7 @@ self: { ]; description = "CAES Language for Synchronous Hardware - Verilog backend"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "clash-vhdl" = callPackage @@ -52449,6 +55232,7 @@ self: { ]; description = "CAES Language for Synchronous Hardware - VHDL backend"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "classify" = callPackage @@ -52491,6 +55275,7 @@ self: { ]; description = "Classify sounds produced by Xenopus laevis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "classy-influxdb-simple" = callPackage @@ -52507,6 +55292,8 @@ self: { ]; description = "Super simple InfluxDB package in Classy-MTL style"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "classy-miso" = callPackage @@ -52527,6 +55314,7 @@ self: { testHaskellDepends = [ base miso rfc ]; description = "Typeclass based support for Miso, the Tasty Web Framework for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "classy-parallel" = callPackage @@ -52542,6 +55330,8 @@ self: { ]; description = "Fork of the monad-parallel package using monad-control"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "classy-prelude" = callPackage @@ -52619,6 +55409,8 @@ self: { benchmarkHaskellDepends = [ base criterion parallel uniplate ]; description = "Fuseable type-class based generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clay" = callPackage @@ -52666,6 +55458,7 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "A secure, reliable content management system (CMS) and blogging platform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) openssl;}; "clckwrks-cli" = callPackage @@ -52688,6 +55481,7 @@ self: { ]; description = "a command-line interface for adminstrating some aspects of clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-dot-com" = callPackage @@ -52709,6 +55503,7 @@ self: { executableToolDepends = [ hsx2hs ]; description = "clckwrks.com"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-bugs" = callPackage @@ -52734,6 +55529,7 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "bug tracking plugin for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-ircbot" = callPackage @@ -52757,6 +55553,7 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "ircbot plugin for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-mailinglist" = callPackage @@ -52781,6 +55578,7 @@ self: { ]; description = "mailing list plugin for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-media" = callPackage @@ -52803,6 +55601,7 @@ self: { ]; description = "media plugin for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-page" = callPackage @@ -52828,6 +55627,7 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "support for CMS/Blogging in clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-redirect" = callPackage @@ -52852,6 +55652,7 @@ self: { ]; description = "support redirects for CMS/Blogging in clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-theme-bootstrap" = callPackage @@ -52869,6 +55670,7 @@ self: { ]; description = "simple bootstrap based template for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-theme-clckwrks" = callPackage @@ -52886,6 +55688,7 @@ self: { ]; description = "simple bootstrap based template for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-theme-geo-bootstrap" = callPackage @@ -52898,6 +55701,7 @@ self: { libraryHaskellDepends = [ base clckwrks hsp text ]; description = "geo bootstrap based template for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cld2" = callPackage @@ -52909,6 +55713,8 @@ self: { libraryHaskellDepends = [ base bytestring hashable text ]; description = "Haskell bindings to Google's Compact Language Detector 2"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clean-home" = callPackage @@ -52937,6 +55743,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Open unions without need for Typeable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cless" = callPackage @@ -52955,6 +55763,7 @@ self: { ]; description = "Colorized LESS"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "clevercss" = callPackage @@ -52969,6 +55778,8 @@ self: { executableHaskellDepends = [ parsec ]; description = "A CSS preprocessor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clexer" = callPackage @@ -52980,6 +55791,8 @@ self: { libraryHaskellDepends = [ base containers mtl parsec ]; description = "Lexes C++ code into simple tokens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cli" = callPackage @@ -53012,6 +55825,8 @@ self: { testHaskellDepends = [ base doctest filemanip hspec QuickCheck ]; description = "Simple project template from stack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cli-extras" = callPackage @@ -53129,6 +55944,8 @@ self: { ]; description = "A Haskell library as database client for Clickhouse"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clientsession" = callPackage @@ -53171,6 +55988,8 @@ self: { benchmarkHaskellDepends = [ base time ]; description = "A Clifford algebra number type for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clifford" = callPackage @@ -53203,6 +56022,7 @@ self: { ]; description = "A Clifford algebra library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clifm" = callPackage @@ -53222,6 +56042,8 @@ self: { ]; description = "Command Line Interface File Manager"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "climb" = callPackage @@ -53263,6 +56085,8 @@ self: { librarySystemDepends = [ clingo ]; description = "Haskell bindings to the Clingo ASP solver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) clingo;}; "clippard" = callPackage @@ -53274,6 +56098,8 @@ self: { libraryHaskellDepends = [ base process ]; description = "A simple Haskell library for copying text to the clipboard in a cross-platform way"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clipper" = callPackage @@ -53285,6 +56111,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell API to clipper (2d polygon union/intersection/xor/clipping API)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clippings" = callPackage @@ -53310,6 +56138,7 @@ self: { ]; description = "A parser/generator for Kindle-format clipping files (`My Clippings.txt`),"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "clisparkline" = callPackage @@ -53322,6 +56151,8 @@ self: { testHaskellDepends = [ base ]; description = "Tiny library to pretty print sparklines onto the CLI"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clist" = callPackage @@ -53356,6 +56187,8 @@ self: { executableHaskellDepends = [ base ]; description = "Post tweets from stdin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cloben" = callPackage @@ -53428,6 +56261,7 @@ self: { libraryPkgconfigDepends = [ QtCore ]; description = "timer functionality to clock IO commands"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {QtCore = null;}; "clogparse" = callPackage @@ -53444,6 +56278,8 @@ self: { ]; description = "Parse IRC logs such as the #haskell logs on tunes.org"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clone-all" = callPackage @@ -53463,6 +56299,8 @@ self: { ]; description = "Clone all github repositories from a given user"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "closed" = callPackage @@ -53510,6 +56348,8 @@ self: { libraryHaskellDepends = [ base hashable unordered-containers ]; description = "Depth- and breadth-first set closures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cloud-haskell" = callPackage @@ -53533,6 +56373,7 @@ self: { doHaddock = false; description = "The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cloud-seeder" = callPackage @@ -53561,6 +56402,7 @@ self: { ]; description = "A tool for interacting with AWS CloudFormation"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "cloudfront-signer" = callPackage @@ -53577,6 +56419,8 @@ self: { ]; description = "CloudFront URL signer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cloudi" = callPackage @@ -53677,6 +56521,8 @@ self: { ]; description = "Quasiquoters for inline C# and F#"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clr-marshal" = callPackage @@ -53745,6 +56591,7 @@ self: { ]; description = "C to Lua data wrapper generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clumpiness" = callPackage @@ -53767,6 +56614,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "simple alternative to type classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clustering" = callPackage @@ -53792,6 +56641,8 @@ self: { ]; description = "High performance clustering algorithms"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clustertools" = callPackage @@ -53810,6 +56661,7 @@ self: { ]; description = "Tools for manipulating sequence clusters"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "clutterhs" = callPackage @@ -53827,6 +56679,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to the Clutter animation library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) clutter; inherit (pkgs) pango;}; "cmaes" = callPackage @@ -53912,6 +56765,8 @@ self: { ]; description = "Code highlighting for cmark"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmark-lucid" = callPackage @@ -53936,6 +56791,8 @@ self: { libraryHaskellDepends = [ base cmark ]; description = "Pattern synonyms for cmark"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmark-sections" = callPackage @@ -53954,6 +56811,8 @@ self: { ]; description = "Represent cmark-parsed Markdown as a tree of sections"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmath" = callPackage @@ -53965,6 +56824,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A binding to the standard C math library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmathml3" = callPackage @@ -53984,6 +56845,7 @@ self: { executableHaskellDepends = [ base Cabal filepath ]; description = "Data model, parser, serialiser and transformations for Content MathML 3"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cmd-item" = callPackage @@ -54000,6 +56862,8 @@ self: { ]; description = "Library to compose and reuse command line fragments"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmdargs" = callPackage @@ -54050,6 +56914,8 @@ self: { libraryHaskellDepends = [ base mtl split syb transformers ]; description = "a library for command line parsing & online help"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmdtheline" = callPackage @@ -54071,6 +56937,8 @@ self: { ]; description = "Declarative command-line option parsing and documentation library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmf" = callPackage @@ -54083,6 +56951,8 @@ self: { testHaskellDepends = [ base containers hedgehog ]; description = "(C)oncurrent (M)onoidal (F)olds"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cml" = callPackage @@ -54105,6 +56975,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "A library for C-like programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmph" = callPackage @@ -54123,6 +56995,8 @@ self: { testSystemDepends = [ cmph ]; description = "low level interface to CMPH"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {cmph = null;}; "cmptype" = callPackage @@ -54137,6 +57011,7 @@ self: { ]; description = "Compare types of any kinds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cmt" = callPackage @@ -54163,6 +57038,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Write consistent git commit messages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cmu" = callPackage @@ -54205,6 +57082,7 @@ self: { ]; description = "Detailed visualization of CMs, HMMs and their comparisions"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "cnc-spec-compiler" = callPackage @@ -54226,6 +57104,7 @@ self: { ]; description = "Compiler/Translator for CnC Specification Files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cndict" = callPackage @@ -54317,6 +57196,8 @@ self: { executableHaskellDepends = [ base co-log-core polysemy ]; description = "Composable Contravariant Comonadic Logging Library"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "co-log-polysemy-formatting" = callPackage @@ -54340,6 +57221,7 @@ self: { ]; description = "A Polysemy logging effect for high quality (unstructured) logs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "co-log-sys" = callPackage @@ -54360,6 +57242,8 @@ self: { ]; description = "Syslog implementation on top of 'co-log-core'"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "coalpit" = callPackage @@ -54378,6 +57262,8 @@ self: { ]; description = "Command-line options and DSV parsing and printing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cobot" = callPackage @@ -54426,6 +57312,8 @@ self: { ]; description = "Biological data file formats and IO"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cobot-tools" = callPackage @@ -54449,6 +57337,8 @@ self: { ]; description = "Biological data file formats and IO"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {RNA = null;}; "code-builder" = callPackage @@ -54460,6 +57350,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple system for generating code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "code-conjure" = callPackage @@ -54510,6 +57402,7 @@ self: { ]; description = "Simple bidirectional serialization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "codec-beam" = callPackage @@ -54524,6 +57417,8 @@ self: { testHaskellDepends = [ base bytestring filepath process text ]; description = "Erlang VM byte code assembler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "codec-libevent" = callPackage @@ -54546,6 +57441,8 @@ self: { ]; description = "Cross-platform structure serialisation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "codec-mbox" = callPackage @@ -54580,6 +57477,7 @@ self: { ]; description = "A library for manipulating RPM files"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "codecov-haskell" = callPackage @@ -54603,6 +57501,8 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Codecov.io support for Haskell."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "codemonitor" = callPackage @@ -54621,6 +57521,7 @@ self: { ]; description = "Tool that automatically runs arbitrary commands when files change on disk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "codepad" = callPackage @@ -54634,6 +57535,8 @@ self: { libraryHaskellDepends = [ base curl mtl network tagsoup ]; description = "Submit and retrieve paste output from CodePad.org."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "codeworld-api" = callPackage @@ -54663,6 +57566,8 @@ self: { ]; description = "Graphics library for CodeWorld"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "codex" = callPackage @@ -54688,6 +57593,8 @@ self: { ]; description = "A ctags file generator for cabal project dependencies"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "codo-notation" = callPackage @@ -54703,6 +57610,8 @@ self: { ]; description = "A notation for comonads, analogous to the do-notation for monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "coerce-role" = callPackage @@ -54865,6 +57774,8 @@ self: { ]; description = "Simple account manager"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "coinbase-exchange" = callPackage @@ -54903,6 +57814,7 @@ self: { ]; description = "Connector library for the coinbase exchange"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "coinbase-pro" = callPackage @@ -54935,6 +57847,8 @@ self: { ]; description = "Client for Coinbase Pro"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "coincident-root-loci" = callPackage @@ -54953,6 +57867,8 @@ self: { ]; description = "Equivariant CSM classes of coincident root loci"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "colada" = callPackage @@ -54976,6 +57892,7 @@ self: { ]; description = "Colada implements incremental word class class induction using online LDA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "colchis" = callPackage @@ -54993,6 +57910,8 @@ self: { ]; description = "Rudimentary JSON-RPC 2.0 client over raw TCP."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cold-widow" = callPackage @@ -55025,6 +57944,8 @@ self: { ]; description = "Generate animated 3d objects in COLLADA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "collada-types" = callPackage @@ -55058,6 +57979,7 @@ self: { ]; description = "Collapse the duplication output into clones and return their frequencies"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "collapse-util" = callPackage @@ -55071,6 +57993,8 @@ self: { executableHaskellDepends = [ base ]; description = "utility for collapsing adjacent writes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "collect-errors" = callPackage @@ -55104,6 +58028,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Collection+JSON—Hypermedia Type Tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "collections" = callPackage @@ -55117,6 +58042,8 @@ self: { ]; description = "Useful standard collections types and related functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "collections-api" = callPackage @@ -55130,6 +58057,8 @@ self: { libraryHaskellDepends = [ array base QuickCheck ]; description = "API for collection data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "collections-base-instances" = callPackage @@ -55145,6 +58074,7 @@ self: { ]; description = "Useful standard collections types and related functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "colock" = callPackage @@ -55177,6 +58107,8 @@ self: { ]; description = "Generic types and functions for columnar encoding and decoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "color-counter" = callPackage @@ -55201,6 +58133,7 @@ self: { ]; description = "Count colors in images"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "colorful-monoids" = callPackage @@ -55249,6 +58182,8 @@ self: { ]; description = "Colorless | The Programmatic IDL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "colorless-http-client" = callPackage @@ -55265,6 +58200,7 @@ self: { ]; description = "Http Client addon for Colorless"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "colorless-scotty" = callPackage @@ -55278,6 +58214,7 @@ self: { ]; description = "Scotty server add-on for Colorless"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "colors" = callPackage @@ -55336,6 +58273,7 @@ self: { ]; description = "Instances of the manifold-classes for colour types"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "colourista" = callPackage @@ -55368,6 +58306,8 @@ self: { ]; description = "A jazzy, minimal web framework for Haskell, inspired by Sinatra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "columbia" = callPackage @@ -55388,6 +58328,7 @@ self: { doHaddock = false; description = "Enhanced serialization using seeking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "columnar" = callPackage @@ -55416,6 +58357,8 @@ self: { doHaddock = false; description = "Haskell COM support library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "comark" = callPackage @@ -55494,6 +58437,8 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "Definitions of AST that represents a Commonmark (markdown) document"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "combinat" = callPackage @@ -55550,6 +58495,8 @@ self: { ]; description = "Graphical representations for various combinatorial objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "combinator-interactive" = callPackage @@ -55571,6 +58518,8 @@ self: { ]; description = "SKI Combinator interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "combinatorial" = callPackage @@ -55604,6 +58553,8 @@ self: { ]; description = "A number of data structures to represent and allow the manipulation of standard combinatorial problems, used as test problems in computer science"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "combinatorics" = callPackage @@ -55630,6 +58581,8 @@ self: { ]; description = "Various buffer implementations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "comfort-array" = callPackage @@ -55687,6 +58640,7 @@ self: { ]; description = "A format for describing comics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "comma" = callPackage @@ -55742,6 +58696,8 @@ self: { testHaskellDepends = [ base ]; description = "pattern matching against string based commands"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "commander-cli" = callPackage @@ -55793,6 +58749,8 @@ self: { ]; description = "Library for working with commoditized amounts and price histories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "commonmark" = callPackage @@ -55889,6 +58847,8 @@ self: { ]; description = "Provide communications security using symmetric ephemeral keys"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "commsec-keyexchange" = callPackage @@ -55907,6 +58867,7 @@ self: { ]; description = "Key agreement for commsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "commutative" = callPackage @@ -56017,6 +58978,8 @@ self: { testHaskellDepends = [ base ]; description = "An append only list in a compact region"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compact-map" = callPackage @@ -56030,6 +58993,8 @@ self: { ]; description = "Compact Data.Map implementation using Data.Binary"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compact-mutable" = callPackage @@ -56049,6 +59014,7 @@ self: { ]; description = "Mutable arrays living on the compact heap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "compact-mutable-vector" = callPackage @@ -56062,6 +59028,8 @@ self: { testHaskellDepends = [ base compact hspec ]; description = "Mutable vector with different GC characteristics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compact-sequences" = callPackage @@ -56092,6 +59060,8 @@ self: { ]; description = "Socket functions for compact normal form"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compact-string" = callPackage @@ -56105,6 +59075,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Fast, packed and strict strings with Unicode support, based on bytestrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compact-string-fix" = callPackage @@ -56118,6 +59090,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Same as compact-string except with a small fix so it builds on ghc-6.12"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compact-word-vectors" = callPackage @@ -56145,6 +59119,8 @@ self: { libraryHaskellDepends = [ base containers transformers vector ]; description = "A typeclass for structures which can be catMaybed, filtered, and partitioned"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compactmap" = callPackage @@ -56231,6 +59207,8 @@ self: { ]; description = "Compositional Data Types on DAGs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compdata-fixplate" = callPackage @@ -56266,6 +59244,8 @@ self: { ]; description = "Parametric Compositional Data Types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compdoc" = callPackage @@ -56346,6 +59326,8 @@ self: { libraryHaskellDepends = [ base filepath parsec ]; description = "Helpers and runners for code competitions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compilation" = callPackage @@ -56357,6 +59339,8 @@ self: { libraryHaskellDepends = [ base MissingH ]; description = "Haskell functionality for quickly assembling simple compilers"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compiler-warnings" = callPackage @@ -56386,6 +59370,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "complex numbers with non-mandatory RealFloat"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "complex-integrate" = callPackage @@ -56413,6 +59399,7 @@ self: { ]; description = "Empirical algorithmic complexity"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "componentm" = callPackage @@ -56500,6 +59487,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Composable monad transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "composite-aeson" = callPackage @@ -56678,6 +59667,8 @@ self: { ]; description = "Opaleye SQL for Vinyl records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "composite-swagger" = callPackage @@ -56765,6 +59756,8 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "Composition trees for arbitrary monoids"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compositional-data" = callPackage @@ -56812,6 +59805,8 @@ self: { testHaskellDepends = [ base ]; description = "Plugin to generalize comprehensions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compressed" = callPackage @@ -56831,6 +59826,8 @@ self: { ]; description = "Compressed containers and reducers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "compression" = callPackage @@ -56858,6 +59855,8 @@ self: { ]; description = "Strategy combinators for compositional data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "comptrans" = callPackage @@ -56875,6 +59874,8 @@ self: { ]; description = "Automatically converting ASTs into compositional data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "computational-algebra" = callPackage @@ -56926,6 +59927,7 @@ self: { ]; description = "Well-kinded computational algebra library, currently supporting Groebner basis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "computational-geometry" = callPackage @@ -56942,6 +59944,8 @@ self: { ]; description = "Collection of algorithms in Computational Geometry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "computations" = callPackage @@ -56953,6 +59957,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Advanced notions of computation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "concatenative" = callPackage @@ -57030,6 +60036,7 @@ self: { ]; description = "Morphological disambiguation based on constrained CRFs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "concraft-hr" = callPackage @@ -57051,6 +60058,7 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "Part-of-speech tagger for Croatian"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "concraft-pl" = callPackage @@ -57079,6 +60087,7 @@ self: { ]; description = "Morphological tagger for Polish"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "concrete-haskell" = callPackage @@ -57122,6 +60131,7 @@ self: { ]; description = "Library for the Concrete data format"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "concrete-haskell-autogen" = callPackage @@ -57138,6 +60148,7 @@ self: { ]; description = "Automatically generated Thrift definitions for the Concrete data format"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "concrete-relaxng-parser" = callPackage @@ -57157,6 +60168,8 @@ self: { ]; description = "A parser driven by a standard RELAX NG schema with concrete syntax extensions"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "concrete-typerep" = callPackage @@ -57176,6 +60189,8 @@ self: { ]; description = "Binary and Hashable instances for TypeRep"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "concur-core" = callPackage @@ -57270,6 +60285,8 @@ self: { benchmarkHaskellDepends = [ bug criterion rerebase ]; description = "Concurrent expanding buffer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "concurrent-dns-cache" = callPackage @@ -57443,6 +60460,8 @@ self: { libraryHaskellDepends = [ base exceptions mtl stm transformers ]; description = "MTL-like library using TVars"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "concurrent-supply" = callPackage @@ -57513,6 +60532,7 @@ self: { ]; description = "Information retrieval library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "condorcet" = callPackage @@ -57524,6 +60544,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Library for Condorcet voting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conductive-base" = callPackage @@ -57535,6 +60557,8 @@ self: { libraryHaskellDepends = [ array base containers random stm time ]; description = "a library for live coding and real-time musical applications"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conductive-clock" = callPackage @@ -57562,6 +60586,7 @@ self: { ]; description = "a library with examples of using Conductive with hsc3"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "conductive-song" = callPackage @@ -57573,6 +60598,7 @@ self: { libraryHaskellDepends = [ base conductive-base random ]; description = "a library of functions which are useful for composing music"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "conduino" = callPackage @@ -57684,6 +60710,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "conduit-audio interface to the LAME MP3 library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {mp3lame = null;}; "conduit-audio-samplerate" = callPackage @@ -57703,6 +60731,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "conduit-audio interface to the libsamplerate resampling library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {samplerate = null;}; "conduit-audio-sndfile" = callPackage @@ -57829,6 +60859,8 @@ self: { ]; description = "A file-finding conduit that allows user control over traversals"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conduit-iconv" = callPackage @@ -57849,6 +60881,8 @@ self: { ]; description = "Conduit for character encoding conversion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conduit-merge" = callPackage @@ -57875,6 +60909,8 @@ self: { ]; description = "A base layer for network protocols using Conduits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conduit-parse" = callPackage @@ -57913,6 +60949,8 @@ self: { ]; description = "Allows conduit to resume sinks to feed multiple sources into it"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conduit-throttle" = callPackage @@ -57936,6 +60974,8 @@ self: { ]; description = "Throttle Conduit Producers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conduit-tokenize-attoparsec" = callPackage @@ -57955,6 +60995,8 @@ self: { testHaskellDepends = [ attoparsec base conduit hspec resourcet ]; description = "Conduits for tokenizing streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conduit-vfs" = callPackage @@ -57979,6 +61021,8 @@ self: { ]; description = "Virtual file system for Conduit; disk, pure, and in-memory impls"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conduit-vfs-zip" = callPackage @@ -58005,6 +61049,7 @@ self: { ]; description = "Zip archive interface for the Conduit Virtual File System"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "conduit-zstd" = callPackage @@ -58039,6 +61084,8 @@ self: { ]; description = "Parser for Haskell-based configuration files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conf-json" = callPackage @@ -58090,6 +61137,7 @@ self: { text transformers ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "conferer" = callPackage @@ -58197,6 +61245,7 @@ self: { ]; description = "Configuration for reading dhall files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "conferer-provider-json" = callPackage @@ -58217,6 +61266,8 @@ self: { ]; description = "conferer's provider for reading json files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conferer-provider-yaml" = callPackage @@ -58235,6 +61286,7 @@ self: { ]; description = "Configuration for reading yaml files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "conferer-snap" = callPackage @@ -58255,6 +61307,8 @@ self: { ]; description = "conferer's FromConfig instances for snap Config"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conferer-source-dhall" = callPackage @@ -58275,6 +61329,7 @@ self: { ]; description = "Configuration for reading dhall files"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "conferer-source-json" = callPackage @@ -58295,6 +61350,8 @@ self: { ]; description = "conferer's source for reading json files"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conferer-source-yaml" = callPackage @@ -58312,6 +61369,7 @@ self: { ]; description = "Configuration for reading yaml files"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "conferer-warp" = callPackage @@ -58379,6 +61437,7 @@ self: { ]; description = "A .conf file formatter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "confide" = callPackage @@ -58393,6 +61452,8 @@ self: { testHaskellDepends = [ base deiko-config tasty tasty-hunit text ]; description = "derive typeclass instances for decoding types from HOCON conf"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "config-ini" = callPackage @@ -58446,6 +61507,8 @@ self: { testHaskellDepends = [ base extra hspec lens parsec text ]; description = "Parse config files using parsec and generate parse errors on unhandled keys"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "config-schema" = callPackage @@ -58481,6 +61544,7 @@ self: { ]; description = "A small program for swapping out dot files"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "config-value" = callPackage @@ -58511,6 +61575,8 @@ self: { libraryHaskellDepends = [ base config-value text ]; description = "Interface between config-value and System.GetOpt"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "configifier" = callPackage @@ -58539,6 +61605,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "parser for config files, shell variables, command line args"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "configuration" = callPackage @@ -58550,6 +61617,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple data type for application configuration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "configuration-tools" = callPackage @@ -58645,6 +61714,7 @@ self: { ]; description = "The next generation of configuration management"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "configurator-pg" = callPackage @@ -58683,6 +61753,8 @@ self: { ]; description = "A command line tool for resolving conflicts of file synchronizers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "congruence-relation" = callPackage @@ -58694,6 +61766,8 @@ self: { libraryHaskellDepends = [ array base containers ]; description = "Decidable congruence relations for Haskell: up to you whether this is a joke"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conjugateGradient" = callPackage @@ -58725,6 +61799,8 @@ self: { ]; description = "A BitTorrent client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conkin" = callPackage @@ -58742,6 +61818,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Tools for functors from Hask^k to Hask"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conlogger" = callPackage @@ -58756,6 +61834,8 @@ self: { executableHaskellDepends = [ base text ]; description = "A logger for a concurrent program"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "connection" = callPackage @@ -58808,6 +61888,8 @@ self: { testHaskellDepends = [ base doctest text ]; description = "A library for parsing connection strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "connections" = callPackage @@ -58840,6 +61922,8 @@ self: { testHaskellDepends = [ base lifted-async transformers ]; description = "Eventually consistent STM transactions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "console-program" = callPackage @@ -58857,6 +61941,8 @@ self: { ]; description = "Interpret the command line and a config file as commands and options"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "console-prompt" = callPackage @@ -58902,6 +61988,8 @@ self: { testHaskellDepends = [ base directory process ]; description = "Compiler plugin for constant math elimination"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constaparser" = callPackage @@ -58924,6 +62012,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Equality by only Constructor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constrained" = callPackage @@ -58950,6 +62040,8 @@ self: { ]; description = "Constrained clones of the category-theory type classes, using ConstraintKinds"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constrained-category" = callPackage @@ -58969,6 +62061,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Constrained Categories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constrained-dynamic" = callPackage @@ -58981,6 +62075,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Dynamic typing with retained constraints"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constrained-monads" = callPackage @@ -59004,6 +62100,8 @@ self: { ]; description = "Typeclasses and instances for monads with constraints"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constrained-normal" = callPackage @@ -59065,6 +62163,7 @@ self: { libraryHaskellDepends = [ base indextype ]; description = "Some conviencience type functions for manipulating constraints"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "constraint-reflection" = callPackage @@ -59141,6 +62240,8 @@ self: { testHaskellDepends = [ base constraints hspec transformers ]; description = "Defer instance lookups until runtime"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constraints-extras" = callPackage @@ -59207,6 +62308,7 @@ self: { ]; description = "Exact computation with constructible real numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "constructive-algebra" = callPackage @@ -59218,6 +62320,8 @@ self: { libraryHaskellDepends = [ base QuickCheck type-level ]; description = "A library of constructive algebra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "consul-haskell" = callPackage @@ -59242,6 +62346,8 @@ self: { ]; description = "A consul client for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "consumers" = callPackage @@ -59268,6 +62374,7 @@ self: { ]; description = "Concurrent PostgreSQL data consumers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "container" = callPackage @@ -59281,6 +62388,7 @@ self: { ]; description = "Containers abstraction and utilities"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "container-builder" = callPackage @@ -59351,6 +62459,8 @@ self: { ]; description = "Extensive benchmark suite for containers package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "containers-deepseq" = callPackage @@ -59384,6 +62494,8 @@ self: { libraryHaskellDepends = [ containers ]; description = "Formally verified drop-in replacement of containers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "content-store" = callPackage @@ -59408,6 +62520,8 @@ self: { ]; description = "Store and retrieve data from an on-disk store"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "context" = callPackage @@ -59469,6 +62583,8 @@ self: { ]; description = "Basic algorithms on context-free grammars"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "context-http-client" = callPackage @@ -59513,6 +62629,8 @@ self: { ]; description = "An abstraction of a stack and stack-based monadic context"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "context-wai-middleware" = callPackage @@ -59565,6 +62683,8 @@ self: { libraryHaskellDepends = [ base contiguous primitive ]; description = "contiguous with bounds checks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "contiguous-fft" = callPackage @@ -59592,6 +62712,8 @@ self: { ]; description = "Monads with suspension and arbitrary-spot reentry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "continued-fraction" = callPackage @@ -59638,6 +62760,7 @@ self: { base bytestring cereal containers mtl nanomsg-haskell time ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "continuum-client" = callPackage @@ -59652,6 +62775,7 @@ self: { base bytestring cereal containers mtl nanomsg-haskell time ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "contra-tracer" = callPackage @@ -59722,6 +62846,7 @@ self: { ]; description = "Class of monad transformers which control operations can be lifted thru"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "control-bool" = callPackage @@ -59789,6 +62914,8 @@ self: { ]; description = "A typeclass for type isomorphisms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "control-monad-attempt" = callPackage @@ -59800,6 +62927,7 @@ self: { libraryHaskellDepends = [ attempt base transformers ]; description = "Monad transformer for attempt. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "control-monad-exception" = callPackage @@ -59831,6 +62959,7 @@ self: { ]; description = "Monads-fd instances for the EMT exceptions monad transformer"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "control-monad-exception-monadstf" = callPackage @@ -59869,6 +62998,8 @@ self: { libraryHaskellDepends = [ base failure transformers ]; description = "A class for monads which can fail with an error. (deprecated)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "control-monad-failure-mtl" = callPackage @@ -59880,6 +63011,8 @@ self: { libraryHaskellDepends = [ base failure mtl ]; description = "A class for monads which can fail with an error for mtl 1 (deprecated)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "control-monad-free" = callPackage @@ -59957,6 +63090,8 @@ self: { libraryHaskellDepends = [ base contstuff monads-tf ]; description = "ContStuff instances for monads-tf transformers (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "contstuff-transformers" = callPackage @@ -59968,6 +63103,8 @@ self: { libraryHaskellDepends = [ base contstuff transformers ]; description = "Deprecated interface between contstuff 0.7.0 and the transformers package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "converge" = callPackage @@ -60050,6 +63187,7 @@ self: { ]; description = "Injective explicit total and partial conversions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "convert" = callPackage @@ -60067,6 +63205,7 @@ self: { ]; description = "Safe and unsafe data conversion utilities with strong type-level operation. checking."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "convert-annotation" = callPackage @@ -60090,6 +63229,8 @@ self: { ]; description = "Convert the annotation of a gene to another in a delimited file using a variety of different databases"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "convertible" = callPackage @@ -60123,6 +63264,7 @@ self: { ]; description = "convertible instances for ascii"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "convertible-text" = callPackage @@ -60143,6 +63285,7 @@ self: { ]; description = "Typeclasses and instances for converting between types (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cookbook" = callPackage @@ -60199,6 +63342,7 @@ self: { testHaskellDepends = [ base HUnit lens ]; description = "A representation of latitude and longitude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "copilot" = callPackage @@ -60218,6 +63362,7 @@ self: { ]; description = "A stream DSL for writing embedded C programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "copilot-c99" = callPackage @@ -60240,6 +63385,7 @@ self: { ]; description = "A compiler for Copilot targeting C99"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "copilot-cbmc" = callPackage @@ -60256,6 +63402,7 @@ self: { ]; description = "Copilot interface to a C model-checker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "copilot-core" = callPackage @@ -60283,6 +63430,7 @@ self: { ]; description = "A Haskell-embedded DSL for monitoring hard real-time distributed systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "copilot-libraries" = callPackage @@ -60298,6 +63446,7 @@ self: { ]; description = "Libraries for the Copilot language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "copilot-sbv" = callPackage @@ -60313,6 +63462,8 @@ self: { ]; description = "A compiler for CoPilot targeting SBV"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "copilot-theorem" = callPackage @@ -60332,6 +63483,7 @@ self: { ]; description = "k-induction for Copilot"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "copr" = callPackage @@ -60351,6 +63503,8 @@ self: { testHaskellDepends = [ base hlint ]; description = "Haskell interface to the Fedora Copr system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "coquina" = callPackage @@ -60388,6 +63542,8 @@ self: { libraryHaskellDepends = [ base bytestring parsec pretty ]; description = "External core parser and pretty printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "core-compiler" = callPackage @@ -60439,6 +63595,8 @@ self: { ]; description = "A subset of Haskell using in UCC for teaching purpose"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "core-program" = callPackage @@ -60503,6 +63661,8 @@ self: { ]; description = "A bliki written using yesod. Uses pandoc to process files stored in git."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "corecursive-main" = callPackage @@ -60572,6 +63732,7 @@ self: { libraryHaskellDepends = [ base enumerator monad-coroutine ]; description = "Bridge between the monad-coroutine and enumerator packages"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "coroutine-iteratee" = callPackage @@ -60583,6 +63744,7 @@ self: { libraryHaskellDepends = [ base iteratee monad-coroutine ]; description = "Bridge between the monad-coroutine and iteratee packages"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "coroutine-object" = callPackage @@ -60594,6 +63756,8 @@ self: { libraryHaskellDepends = [ base either free mtl transformers ]; description = "Object-oriented programming realization using coroutine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "couch-hs" = callPackage @@ -60612,6 +63776,8 @@ self: { ]; description = "A CouchDB view server for Haskell"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "couch-simple" = callPackage @@ -60668,6 +63834,8 @@ self: { ]; description = "Couch DB client library using http-conduit and aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "couchdb-enumerator" = callPackage @@ -60695,6 +63863,7 @@ self: { ]; description = "Couch DB client library using http-enumerator and aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "count" = callPackage @@ -60749,6 +63918,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "An object frequency counter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "country" = callPackage @@ -60809,6 +63980,8 @@ self: { ]; description = "A message-passing library for simplifying network applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "court" = callPackage @@ -60828,6 +64001,8 @@ self: { ]; description = "Simple and flexible CI system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "coverage" = callPackage @@ -60840,6 +64015,8 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck ]; description = "Exhaustivity Checking Library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "coya" = callPackage @@ -60869,6 +64046,8 @@ self: { ]; description = "A simple C++ parser with preprocessor features. C++ refactorings included."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cpio-conduit" = callPackage @@ -60888,6 +64067,8 @@ self: { ]; description = "Conduit-based CPIO"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cpkg" = callPackage @@ -60952,6 +64133,8 @@ self: { testHaskellDepends = [ base process QuickCheck ]; description = "C++ Foreign Import Generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cppfilt" = callPackage @@ -61016,6 +64199,7 @@ self: { ]; description = "Run random effect using cprng-aes, a crypto pseudo number generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cps-except" = callPackage @@ -61092,6 +64276,8 @@ self: { executableHaskellDepends = [ base mtl process ]; description = "Modify the cpu frequency on OpenBSD systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cpython" = callPackage @@ -61107,6 +64293,8 @@ self: { testPkgconfigDepends = [ python3 ]; description = "Bindings for libpython"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {python3 = null;}; "cql" = callPackage @@ -61156,6 +64344,8 @@ self: { doHaddock = false; description = "Cassandra CQL client"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cql-io-tinylog" = callPackage @@ -61167,6 +64357,7 @@ self: { libraryHaskellDepends = [ base bytestring cql-io tinylog ]; description = "Tinylog integration for cql-io"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "cqrs" = callPackage @@ -61195,6 +64386,8 @@ self: { ]; description = "Command-Query Responsibility Segregation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cqrs-example" = callPackage @@ -61216,6 +64409,7 @@ self: { ]; description = "Example for cqrs package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cqrs-memory" = callPackage @@ -61232,6 +64426,7 @@ self: { testHaskellDepends = [ base cqrs-core cqrs-testkit hspec random ]; description = "Memory backend for the cqrs package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cqrs-postgresql" = callPackage @@ -61255,6 +64450,7 @@ self: { ]; description = "PostgreSQL backend for the cqrs package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cqrs-sqlite3" = callPackage @@ -61275,6 +64471,7 @@ self: { ]; description = "SQLite3 backend for the cqrs package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cqrs-test" = callPackage @@ -61291,6 +64488,7 @@ self: { ]; description = "Command-Query Responsibility Segregation Test Support"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cqrs-testkit" = callPackage @@ -61308,6 +64506,7 @@ self: { ]; description = "Command-Query Responsibility Segregation Test Support"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cqrs-types" = callPackage @@ -61338,6 +64537,8 @@ self: { ]; description = "Code review tool"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crack" = callPackage @@ -61350,6 +64551,8 @@ self: { librarySystemDepends = [ crack ]; description = "A haskell binding to cracklib"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {crack = null;}; "crackNum" = callPackage @@ -61413,6 +64616,7 @@ self: { ]; description = "A UNIX configuration management library in Haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "craftwerk" = callPackage @@ -61426,6 +64630,8 @@ self: { libraryHaskellDepends = [ base colour mtl vector-space ]; description = "2D graphics library with integrated TikZ output"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "craftwerk-cairo" = callPackage @@ -61437,6 +64643,7 @@ self: { libraryHaskellDepends = [ base cairo craftwerk mtl ]; description = "Cairo backend for Craftwerk"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "craftwerk-gtk" = callPackage @@ -61454,6 +64661,7 @@ self: { ]; description = "Gtk UI for Craftwerk"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "crawlchain" = callPackage @@ -61474,6 +64682,8 @@ self: { ]; description = "Simulation user crawl paths"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "craze" = callPackage @@ -61506,6 +64716,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "HTTP Racing Library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "crc" = callPackage @@ -61523,6 +64734,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "Implements various Cyclic Redundancy Checks (CRC)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crc16" = callPackage @@ -61534,6 +64747,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Calculate the crc16-ccitt"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crc16-table" = callPackage @@ -61596,6 +64811,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Garbage collected event folding CRDT"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "creatur" = callPackage @@ -61621,6 +64838,8 @@ self: { ]; description = "Framework for artificial life experiments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "credential-store" = callPackage @@ -61640,6 +64859,8 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hunit ]; description = "Library to access secure credential storage providers"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "credentials" = callPackage @@ -61703,6 +64924,7 @@ self: { ]; description = "First-order, linear-chain conditional random fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "crf-chain1-constrained" = callPackage @@ -61722,6 +64944,7 @@ self: { ]; description = "First-order, constrained, linear-chain conditional random fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "crf-chain2-generic" = callPackage @@ -61739,6 +64962,7 @@ self: { ]; description = "Second-order, generic, constrained, linear conditional random fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "crf-chain2-tiers" = callPackage @@ -61757,6 +64981,7 @@ self: { ]; description = "Second-order, tiered, constrained, linear conditional random fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "critbit" = callPackage @@ -61785,6 +65010,8 @@ self: { ]; description = "Crit-bit maps and sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "criterion" = callPackage @@ -61863,6 +65090,8 @@ self: { ]; description = "A simple tool for visualising differences in Criterion benchmark results"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "criterion-measurement" = callPackage @@ -61905,6 +65134,8 @@ self: { ]; description = "Enhancement of the \"criterion\" benchmarking library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "criterion-to-html" = callPackage @@ -61923,6 +65154,8 @@ self: { ]; description = "Convert criterion output to HTML reports"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "criu-rpc" = callPackage @@ -61939,6 +65172,7 @@ self: { ]; description = "CRIU RPC client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "criu-rpc-types" = callPackage @@ -61952,6 +65186,8 @@ self: { libraryPkgconfigDepends = [ protobuf ]; description = "Criu RPC protocol buffer types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) protobuf;}; "crjdt-haskell" = callPackage @@ -61967,6 +65203,8 @@ self: { testHaskellDepends = [ base containers hedgehog hspec mtl ]; description = "A Conflict-Free Replicated JSON Datatype for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crockford" = callPackage @@ -61978,6 +65216,7 @@ self: { libraryHaskellDepends = [ base digits QuickCheck safe ]; description = "An implementation of Douglas Crockford's base32 encoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "crocodile" = callPackage @@ -61996,6 +65235,8 @@ self: { ]; description = "An offline renderer supporting ray tracing and photon mapping"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cron" = callPackage @@ -62039,6 +65280,7 @@ self: { ]; description = "Cron datatypes and Attoparsec parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "cronus" = callPackage @@ -62068,6 +65310,8 @@ self: { testHaskellDepends = [ base hlint ]; description = "Request and Response types for Eval.so's API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crunghc" = callPackage @@ -62086,6 +65330,8 @@ self: { ]; description = "A runghc replacement with transparent caching"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypt-sha512" = callPackage @@ -62159,6 +65405,8 @@ self: { ]; description = "Generic cryptography cipher benchmarks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypto-cipher-tests" = callPackage @@ -62210,6 +65458,8 @@ self: { testHaskellDepends = [ base bytestring QuickCheck ]; description = "An educational tool for studying classical cryptography schemes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypto-conduit" = callPackage @@ -62231,6 +65481,7 @@ self: { ]; description = "Conduit interface for cryptographic operations (from crypto-api)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "crypto-enigma" = callPackage @@ -62265,6 +65516,8 @@ self: { ]; description = "Like crypto-pubkey-openssh but not dependent on any specific crypto library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypto-multihash" = callPackage @@ -62285,6 +65538,8 @@ self: { testHaskellDepends = [ base bytestring hspec QuickCheck ]; description = "Multihash library on top of cryptonite crypto library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypto-numbers" = callPackage @@ -62357,6 +65612,8 @@ self: { ]; description = "OpenSSH keys decoder/encoder"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypto-pubkey-types" = callPackage @@ -62410,6 +65667,8 @@ self: { ]; description = "A random effect using crypto-random"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypto-rng" = callPackage @@ -62440,6 +65699,8 @@ self: { ]; description = "A simple high level encryption interface based on cryptonite"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypto-sodium" = callPackage @@ -62503,6 +65764,7 @@ self: { ]; description = "Symmetrical block and stream ciphers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cryptocompare" = callPackage @@ -62521,6 +65783,8 @@ self: { testHaskellDepends = [ base hspec hspec-expectations MissingH ]; description = "Haskell wrapper for the cryptocompare API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cryptoconditions" = callPackage @@ -62544,6 +65808,8 @@ self: { ]; description = "Interledger Crypto-Conditions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cryptohash" = callPackage @@ -62701,6 +65967,7 @@ self: { ]; description = "Reversable and secure encoding of object ids as a bytestring"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cryptoids-class" = callPackage @@ -62714,6 +65981,7 @@ self: { libraryHaskellDepends = [ base cryptoids-types exceptions ]; description = "Typeclass-based interface to cryptoids"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cryptoids-types" = callPackage @@ -62731,6 +65999,8 @@ self: { ]; description = "Shared types for encrypting internal object identifiers before exposure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cryptol" = callPackage @@ -62768,6 +66038,7 @@ self: { ]; description = "Cryptol: The Language of Cryptography"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cryptonite" = callPackage @@ -62875,6 +66146,8 @@ self: { ]; description = "Bindings for Cryptsy cryptocurrency exchange API"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crystalfontz" = callPackage @@ -62886,6 +66159,7 @@ self: { libraryHaskellDepends = [ base crc16-table MaybeT serialport ]; description = "Control Crystalfontz LCD displays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "csa" = callPackage @@ -62913,6 +66187,8 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Compiler plugin for common subexpression elimination"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "csg" = callPackage @@ -62944,6 +66220,7 @@ self: { ]; description = "Analytical CSG (Constructive Solid Geometry) library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "csound-catalog" = callPackage @@ -63082,6 +66359,7 @@ self: { ]; description = "A command line type checker for CSPM files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cspretty" = callPackage @@ -63093,6 +66371,8 @@ self: { libraryHaskellDepends = [ base containers pretty ]; description = "AST and pretty printer for CSPm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "css" = callPackage @@ -63104,6 +66384,8 @@ self: { libraryHaskellDepends = [ base mtl text ]; description = "Minimal monadic CSS DSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "css-easings" = callPackage @@ -63120,6 +66402,8 @@ self: { ]; description = "Defining and manipulating css easing strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "css-selectors" = callPackage @@ -63143,6 +66427,8 @@ self: { ]; description = "Parsing, rendering and manipulating css selectors in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "css-syntax" = callPackage @@ -63230,6 +66516,7 @@ self: { ]; description = "A flexible, fast, enumerator-based CSV parser library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "csv-nptools" = callPackage @@ -63247,6 +66534,8 @@ self: { ]; description = "A collection of CSV tools"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "csv-table" = callPackage @@ -63291,6 +66580,8 @@ self: { librarySystemDepends = [ ctemplate ]; description = "Binding to the Google ctemplate library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {ctemplate = null;}; "ctkl" = callPackage @@ -63302,6 +66593,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "packaging of Manuel Chakravarty's CTK Light for Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ctpl" = callPackage @@ -63318,6 +66611,7 @@ self: { executableHaskellDepends = [ array base chatty-text chatty-utils ]; description = "A programming language for text modification"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "ctrie" = callPackage @@ -63358,6 +66652,7 @@ self: { ]; description = "Cubic DSL for 3D printing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cubical" = callPackage @@ -63376,6 +66671,8 @@ self: { executableToolDepends = [ alex happy ]; description = "Implementation of Univalence in Cubical Sets"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cubicbezier" = callPackage @@ -63436,6 +66733,8 @@ self: { executableHaskellDepends = [ base GLUT Yampa ]; description = "3D Yampa/GLUT Puzzle Game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cuckoo" = callPackage @@ -63458,6 +66757,8 @@ self: { doHaddock = false; description = "Haskell Implementation of Cuckoo Filters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cuckoo-filter" = callPackage @@ -63633,6 +66934,8 @@ self: { ]; description = "A framework for declaratively writing curl based API tests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "curlhs" = callPackage @@ -63703,6 +67006,7 @@ self: { testHaskellDepends = [ aeson base bson hspec QuickCheck ]; description = "ISO-4217 Currency Codes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "currency-convert" = callPackage @@ -63718,6 +67022,8 @@ self: { ]; description = "Typesafe currency conversion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "current-locale" = callPackage @@ -63786,6 +67092,8 @@ self: { ]; description = "Compile the functional logic language Curry to several intermediate formats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "curryer" = callPackage @@ -63833,6 +67141,8 @@ self: { ]; description = "Fast, Haskell RPC"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "curryrs" = callPackage @@ -63866,6 +67176,7 @@ self: { ]; description = "Terminal tool for viewing tabular data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cursor" = callPackage @@ -63992,6 +67303,8 @@ self: { ]; description = "Library for drawing curve based images"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cusolver" = callPackage @@ -64037,6 +67350,8 @@ self: { libraryHaskellDepends = [ base basic-prelude monad-loops ]; description = "An enhanced prelude, serving as a foundation for my projects"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cut-the-crap" = callPackage @@ -64113,6 +67428,7 @@ self: { ]; description = "Functional Combinators for Computer Vision"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "cve" = callPackage @@ -64161,6 +67477,7 @@ self: { ]; description = "Haskell bindings for the neo4j \"cypher\" query language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "czipwith" = callPackage @@ -64203,6 +67520,8 @@ self: { ]; description = "Permissively licensed D-Bus client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "d10" = callPackage @@ -64247,6 +67566,8 @@ self: { libraryHaskellDepends = [ base mtl random text ]; description = "Declarative visualization on a web browser with DSL approach"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "daemonize-doublefork" = callPackage @@ -64303,6 +67624,8 @@ self: { ]; description = "Compile-time, type-safe directed acyclic graphs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "damnpacket" = callPackage @@ -64321,6 +67644,8 @@ self: { testHaskellDepends = [ base bytestring hspec HUnit QuickCheck ]; description = "Parsing dAmn messages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "danibot" = callPackage @@ -64343,6 +67668,8 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Basic Slack bot framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dao" = callPackage @@ -64373,6 +67700,8 @@ self: { ]; description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dapi" = callPackage @@ -64391,6 +67720,7 @@ self: { ]; description = "Prints a series of dates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "darcs" = callPackage @@ -64462,6 +67792,7 @@ self: { ]; description = "Comparative benchmark suite for darcs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "darcs-beta" = callPackage @@ -64493,6 +67824,7 @@ self: { executableSystemDepends = [ curl ]; description = "a distributed, interactive, smart revision control system"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) curl;}; "darcs-buildpackage" = callPackage @@ -64511,6 +67843,8 @@ self: { ]; description = "Tools to help manage Debian packages with Darcs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "darcs-cabalized" = callPackage @@ -64532,6 +67866,8 @@ self: { executableSystemDepends = [ curl ncurses zlib ]; description = "David's Advanced Version Control System"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) curl; inherit (pkgs) ncurses; inherit (pkgs) zlib;}; @@ -64552,6 +67888,7 @@ self: { ]; description = "Import/export git fast-import streams to/from darcs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "darcs-graph" = callPackage @@ -64570,6 +67907,8 @@ self: { ]; description = "Generate graphs of darcs repository activity"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "darcs-monitor" = callPackage @@ -64587,6 +67926,8 @@ self: { ]; description = "Darcs repository monitor (sends email)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "darcs-scripts" = callPackage @@ -64617,6 +67958,8 @@ self: { ]; description = "Outputs dependencies of darcs patches in dot format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "darcsden" = callPackage @@ -64644,6 +67987,7 @@ self: { ]; description = "Darcs repository UI and hosting/collaboration app (hub.darcs.net branch)."; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "darcswatch" = callPackage @@ -64666,6 +68010,7 @@ self: { ]; description = "Track application of Darcs patches"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "darkplaces-demo" = callPackage @@ -64693,6 +68038,7 @@ self: { ]; description = "Utility and parser for DarkPlaces demo files"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "darkplaces-rcon" = callPackage @@ -64709,6 +68055,8 @@ self: { testHaskellDepends = [ base bytestring hspec hspec-core ]; description = "Darkplaces rcon client library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "darkplaces-rcon-util" = callPackage @@ -64738,6 +68086,7 @@ self: { ]; description = "Darplaces rcon utility"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "darkplaces-text" = callPackage @@ -64755,6 +68104,8 @@ self: { testHaskellDepends = [ base bytestring hspec QuickCheck ]; description = "Parser for darkplaces colorful text"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dash-haskell" = callPackage @@ -64775,6 +68126,7 @@ self: { ]; description = "Convert package Haddock to Dash docsets (IDE docs)"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "data-accessor" = callPackage @@ -64811,6 +68163,7 @@ self: { ]; description = "Use Accessor to access state in monads-fd State monad class"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-accessor-monads-tf" = callPackage @@ -64824,6 +68177,8 @@ self: { ]; description = "Use Accessor to access state in monads-tf State monad type family"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-accessor-mtl" = callPackage @@ -64900,6 +68255,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator birds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-base" = callPackage @@ -64911,6 +68268,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Utilities for accessing and comparing types based on so called bases - representations with limited polymorphism"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-basic" = callPackage @@ -64934,6 +68293,7 @@ self: { ]; description = "A database library with a focus on ease of use, type safety and useful error messages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "data-binary-ieee754" = callPackage @@ -65003,6 +68363,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Library for checking and normalization of data (e.g. from web forms)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-checked" = callPackage @@ -65038,6 +68400,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Generate a special combinator from any data type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-compat" = callPackage @@ -65060,6 +68424,8 @@ self: { libraryHaskellDepends = [ base stm ]; description = "A Library for directional queues"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-construction" = callPackage @@ -65071,6 +68437,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Data construction abstractions including Constructor, Destructor, Maker, Destroyer, Producer and Consumer"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-constructors" = callPackage @@ -65100,6 +68468,7 @@ self: { ]; description = "a cyclic doubly linked list"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-default" = callPackage @@ -65318,6 +68687,8 @@ self: { ]; description = "Space-efficient and privacy-preserving data dispersal algorithms"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-diverse" = callPackage @@ -65351,6 +68722,8 @@ self: { testHaskellDepends = [ base data-diverse hspec lens tagged ]; description = "Isos & Lens for Data.Diverse.Many and Prisms for Data.Diverse.Which"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-dword" = callPackage @@ -65385,6 +68758,8 @@ self: { ]; description = "Consistent set of utility functions for Maybe, Either, List and Monoids"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-elf" = callPackage @@ -65398,6 +68773,7 @@ self: { ]; description = "Executable and Linkable Format (ELF) data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-embed" = callPackage @@ -65422,6 +68798,8 @@ self: { ]; description = "Embed files and other binary blobs inside executables without Template Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-emoticons" = callPackage @@ -65433,6 +68811,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Combinator emoticons: data-aviary in the flavor of emoticons"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-endian" = callPackage @@ -65484,6 +68864,8 @@ self: { ]; description = "A type safe file path data structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-files-gen" = callPackage @@ -65530,6 +68912,8 @@ self: { ]; description = "Finite totally ordered sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-fin-simple" = callPackage @@ -65542,6 +68926,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Simple integral finite set"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-fix" = callPackage @@ -65586,6 +68972,8 @@ self: { libraryHaskellDepends = [ base ]; description = "An efficient data type for sets of flags"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-foldapp" = callPackage @@ -65726,6 +69114,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Write-once variables with concurrency support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-json-token" = callPackage @@ -65756,6 +69146,8 @@ self: { ]; description = "Sculpt mutable recursive data with reference equality; bake it using a data kiln into an immutable lazy structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-layer" = callPackage @@ -65767,6 +69159,7 @@ self: { libraryHaskellDepends = [ base convert data-construction lens ]; description = "Data layering utilities. Layer is a data-type which wrapps other one, but keeping additional information. If you want to access content of simple newtype object, use Lens.Wrapper instead."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "data-layout" = callPackage @@ -65793,6 +69186,8 @@ self: { ]; description = "Used to be Haskell 98 Lenses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-lens-fd" = callPackage @@ -65806,6 +69201,7 @@ self: { ]; description = "Lenses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-lens-ixset" = callPackage @@ -65818,6 +69214,7 @@ self: { testHaskellDepends = [ QuickCheck ]; description = "A Lens for IxSet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-lens-light" = callPackage @@ -65840,6 +69237,7 @@ self: { libraryHaskellDepends = [ base data-lens template-haskell ]; description = "Utilities for Data.Lens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-list-sequences" = callPackage @@ -65873,6 +69271,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Data.Map with multiple, unique keys"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-memocombinators" = callPackage @@ -65949,6 +69349,8 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "data Nat = Zero | Succ Nat"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-object" = callPackage @@ -65960,6 +69362,8 @@ self: { libraryHaskellDepends = [ base bytestring failure text time ]; description = "Represent hierachichal structures, called objects in JSON. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-object-json" = callPackage @@ -65976,6 +69380,7 @@ self: { ]; description = "Serialize JSON data to/from Haskell using the data-object library. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-object-yaml" = callPackage @@ -65994,6 +69399,7 @@ self: { ]; description = "Serialize data to and from Yaml files (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "data-or" = callPackage @@ -66040,6 +69446,8 @@ self: { libraryHaskellDepends = [ base deepseq mtl parallel pretty time ]; description = "Prettyprint and compare Data values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-quotientref" = callPackage @@ -66051,6 +69459,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Reference cells that need two independent indices to be accessed"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-r-tree" = callPackage @@ -66069,6 +69479,8 @@ self: { ]; description = "R-Tree is a spatial data structure similar to Quadtrees or B-Trees"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-ref" = callPackage @@ -66110,6 +69522,8 @@ self: { libraryHaskellDepends = [ base containers data-reify ]; description = "Common Sub-Expression Elimination for graphs generated by Data.Reify."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-repr" = callPackage @@ -66121,6 +69535,8 @@ self: { libraryHaskellDepends = [ base generic-deriving lens ]; description = "Alternative to Show data printing utility"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-result" = callPackage @@ -66132,6 +69548,7 @@ self: { libraryHaskellDepends = [ base poly-control prologue ]; description = "Data types for returning results distinguishable by types"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "data-rev" = callPackage @@ -66143,6 +69560,8 @@ self: { libraryHaskellDepends = [ base bytestring containers text vector ]; description = "A typeclass for reversing order of contents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-rope" = callPackage @@ -66154,6 +69573,8 @@ self: { libraryHaskellDepends = [ base bytestring bytestring-mmap unix ]; description = "Ropes, an alternative to (Byte)Strings"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-rtuple" = callPackage @@ -66165,6 +69586,7 @@ self: { libraryHaskellDepends = [ base lens typelevel ]; description = "Recursive tuple data structure. It is very usefull when implementing some lo-level operations, allowing to traverse different elements using Haskell's type classes."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "data-serializer" = callPackage @@ -66196,6 +69618,8 @@ self: { ]; description = "Profiling of data structures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-spacepart" = callPackage @@ -66207,6 +69631,8 @@ self: { libraryHaskellDepends = [ base vector-space ]; description = "Deprecated. Now called \"spacepart\". Space partitioning data structures."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-standards" = callPackage @@ -66218,6 +69644,8 @@ self: { libraryHaskellDepends = [ base hashable unordered-containers ]; description = "A collection of standards representable by simple data types"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-stm32" = callPackage @@ -66271,6 +69699,8 @@ self: { ]; description = "Type safe, in-memory dictionary with multidimensional keys"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-stringmap" = callPackage @@ -66289,6 +69719,8 @@ self: { ]; description = "An efficient implementation of maps from strings to arbitrary values"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-structure-inferrer" = callPackage @@ -66309,6 +69741,7 @@ self: { executableToolDepends = [ alex happy ]; description = "Program that infers the fastest data structure available for your program"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "data-sword" = callPackage @@ -66325,6 +69758,8 @@ self: { testHaskellDepends = [ base tasty tasty-quickcheck ]; description = "Shorter binary words"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-tensor" = callPackage @@ -66417,6 +69852,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Basic type wrangling types and classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-util" = callPackage @@ -66428,6 +69865,8 @@ self: { libraryHaskellDepends = [ base ]; description = "utilities for handle data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-validation" = callPackage @@ -66444,6 +69883,8 @@ self: { ]; description = "A library for creating type safe validations"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-variant" = callPackage @@ -66455,6 +69896,8 @@ self: { libraryHaskellDepends = [ base safe ]; description = "A variant data type, useful for modeling dynamically-typed programming languages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-vector-growable" = callPackage @@ -66497,6 +69940,8 @@ self: { ]; description = "HasId/Groundhog interop"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "database-migrate" = callPackage @@ -66525,6 +69970,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Demonstrate how a database can be implemented the functional way"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "datadog" = callPackage @@ -66552,6 +69999,8 @@ self: { ]; description = "Datadog client for Haskell. Supports both the HTTP API and StatsD."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "datadog-tracing" = callPackage @@ -66587,6 +70036,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "Datadog tracing client and mock agent"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dataenc" = callPackage @@ -66632,6 +70082,8 @@ self: { ]; description = "Fixing data-flow problems"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dataflow" = callPackage @@ -66655,6 +70107,7 @@ self: { ]; description = "Generate Graphviz documents from a Haskell representation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dataflower" = callPackage @@ -66699,6 +70152,8 @@ self: { ]; description = "An implementation of datalog in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "datapacker" = callPackage @@ -66716,6 +70171,8 @@ self: { ]; description = "Tool to help pack files into the minimum number of CDs/DVDs/etc"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "datarobot" = callPackage @@ -66808,6 +70265,7 @@ self: { testHaskellDepends = [ base dates hspec QuickCheck time ]; description = "Date conversions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "dates" = callPackage @@ -66824,6 +70282,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Small library for parsing different dates formats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "datetime" = callPackage @@ -66842,6 +70302,8 @@ self: { ]; description = "Utilities to make Data.Time.* easier to use"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "datetime-sb" = callPackage @@ -66860,6 +70322,8 @@ self: { ]; description = "Utilities to make Data.Time.* easier to use."; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dawdle" = callPackage @@ -66874,6 +70338,8 @@ self: { executableHaskellDepends = [ base filepath parsec pretty text ]; description = "Generates DDL suggestions based on a CSV file"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dawg" = callPackage @@ -66889,6 +70355,8 @@ self: { ]; description = "Directed acyclic word graphs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dawg-ord" = callPackage @@ -66921,6 +70389,8 @@ self: { testHaskellDepends = [ base hspec postgresql-simple text ]; description = "Clean database tables automatically around hspec tests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbf" = callPackage @@ -66934,6 +70404,8 @@ self: { ]; description = "Read and write XBase \".dbf\" files"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbjava" = callPackage @@ -66954,6 +70426,7 @@ self: { ]; description = "Decompiler Bytecode Java"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dbm" = callPackage @@ -66972,6 +70445,8 @@ self: { ]; description = "A *simple* database migration tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbmigrations" = callPackage @@ -67019,6 +70494,8 @@ self: { ]; description = "The dbmigrations tool built for MySQL databases"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbmigrations-postgresql" = callPackage @@ -67037,6 +70514,8 @@ self: { ]; description = "The dbmigrations tool built for PostgreSQL databases"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbmigrations-sqlite" = callPackage @@ -67051,6 +70530,8 @@ self: { testHaskellDepends = [ base dbmigrations HDBC HDBC-sqlite3 HUnit ]; description = "The dbmigrations tool built for SQLite databases"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbus" = callPackage @@ -67121,6 +70602,7 @@ self: { ]; description = "Monadic and object-oriented interfaces to DBus"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "dbus-core" = callPackage @@ -67138,6 +70620,8 @@ self: { ]; description = "Low-level D-Bus protocol implementation"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbus-hslogger" = callPackage @@ -67170,6 +70654,8 @@ self: { testHaskellDepends = [ base containers dbus QuickCheck ]; description = "Quasi-quoter for DBus functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dbus-th" = callPackage @@ -67227,6 +70713,8 @@ self: { ]; description = "This packge is deprecated. See the the \"LIO.DCLabel\" in the \"lio\" package."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dclabel-eci11" = callPackage @@ -67238,6 +70726,8 @@ self: { libraryHaskellDepends = [ base pretty QuickCheck ]; description = "The Disjunction Category Label Format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dcpu16" = callPackage @@ -67257,6 +70747,8 @@ self: { testHaskellDepends = [ base ]; description = "DCPU-16 Emulator & Assembler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ddate" = callPackage @@ -67268,6 +70760,7 @@ self: { libraryHaskellDepends = [ base dates time ]; description = "Discordian Date Types for Haskell"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-base" = callPackage @@ -67283,6 +70776,8 @@ self: { ]; description = "Disciplined Disciple Compiler common utilities"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ddc-build" = callPackage @@ -67302,6 +70797,7 @@ self: { ]; description = "Disciplined Disciple Compiler build framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-code" = callPackage @@ -67314,6 +70810,8 @@ self: { libraryHaskellDepends = [ base filepath ]; description = "Disciplined Disciple Compiler base libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ddc-core" = callPackage @@ -67330,6 +70828,7 @@ self: { ]; description = "Disciplined Disciple Compiler core language and type checker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-core-babel" = callPackage @@ -67343,6 +70842,7 @@ self: { ]; description = "Disciplined Disciple Compiler PHP code generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-core-eval" = callPackage @@ -67358,6 +70858,7 @@ self: { ]; description = "Disciplined Disciple Compiler semantic evaluator for the core language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-core-flow" = callPackage @@ -67375,6 +70876,7 @@ self: { ]; description = "Disciplined Disciple Compiler data flow compiler"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-core-llvm" = callPackage @@ -67391,6 +70893,7 @@ self: { ]; description = "Disciplined Disciple Compiler LLVM code generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-core-salt" = callPackage @@ -67406,6 +70909,7 @@ self: { ]; description = "Disciplined Disciple Compiler C code generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-core-simpl" = callPackage @@ -67421,6 +70925,7 @@ self: { ]; description = "Disciplined Disciple Compiler code transformations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-core-tetra" = callPackage @@ -67437,6 +70942,7 @@ self: { ]; description = "Disciplined Disciple Compiler intermediate language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-driver" = callPackage @@ -67456,6 +70962,7 @@ self: { ]; description = "Disciplined Disciple Compiler top-level driver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-interface" = callPackage @@ -67467,6 +70974,7 @@ self: { libraryHaskellDepends = [ base containers ddc-base directory ]; description = "Disciplined Disciple Compiler user interface support"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-source-tetra" = callPackage @@ -67483,6 +70991,7 @@ self: { ]; description = "Disciplined Disciple Compiler source language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-tools" = callPackage @@ -67505,6 +71014,7 @@ self: { ]; description = "Disciplined Disciple Compiler command line tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddc-war" = callPackage @@ -67522,6 +71032,7 @@ self: { ]; description = "Disciplined Disciple Compiler test driver and buildbot"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ddci-core" = callPackage @@ -67540,6 +71051,7 @@ self: { ]; description = "Disciple Core language interactive interpreter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "dde" = callPackage @@ -67591,6 +71103,8 @@ self: { ]; description = "detect dead code in haskell projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dead-simple-json" = callPackage @@ -67606,6 +71120,8 @@ self: { ]; description = "Dead simple JSON parser, with some Template Haskell sugar"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "debian" = callPackage @@ -67695,6 +71211,7 @@ self: { ]; description = "Simple trace-based debugger"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "debug-diff" = callPackage @@ -67745,6 +71262,8 @@ self: { ]; description = "secure remote debugging"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "debug-pp" = callPackage @@ -67786,6 +71305,7 @@ self: { libraryHaskellDepends = [ base template-haskell unicode-show ]; description = "You do not have to write variable names twice in Debug.Trace"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "debug-tracy" = callPackage @@ -67800,6 +71320,8 @@ self: { executableHaskellDepends = [ base ]; description = "More useful trace functions for investigating bugs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deburr" = callPackage @@ -67834,6 +71356,8 @@ self: { libraryHaskellDepends = [ base comonad-transformers ]; description = "The categorical dual of transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "decidable" = callPackage @@ -67849,6 +71373,7 @@ self: { ]; description = "Combinators for manipulating dependently-typed predicates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "decimal-arithmetic" = callPackage @@ -67863,6 +71388,7 @@ self: { testHaskellDepends = [ base binary doctest hspec QuickCheck ]; description = "An implementation of the General Decimal Arithmetic Specification"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "decimal-literals" = callPackage @@ -67877,6 +71403,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Preprocessing decimal literals more or less as they are (instead of via fractions)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "declarative" = callPackage @@ -67923,6 +71451,8 @@ self: { libraryHaskellDepends = [ base binary bytestring conduit ]; description = "Conduit for decoding ByteStrings using Data.Binary.Get"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dedukti" = callPackage @@ -67945,6 +71475,7 @@ self: { ]; description = "A type-checker for the λΠ-modulo calculus"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "deep-transformations" = callPackage @@ -67963,6 +71494,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Deep natural and unnatural tree transformations, including attribute grammars"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deepcontrol" = callPackage @@ -67979,6 +71512,8 @@ self: { ]; description = "A library that provides deep-level programming style and(or) notation on Applicative and Monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deepl" = callPackage @@ -68029,6 +71564,7 @@ self: { ]; description = "Deep Learning in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "deepseq_1_4_5_0" = callPackage @@ -68069,6 +71605,8 @@ self: { ]; description = "Bounded deepseq, including support for generic deriving"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deepseq-generics" = callPackage @@ -68109,6 +71647,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Deep evaluation of data structures without NFData"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deepseq-th" = callPackage @@ -68121,6 +71661,8 @@ self: { testHaskellDepends = [ base deepseq template-haskell ]; description = "Template Haskell based deriver for optimised NFData instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deepzoom" = callPackage @@ -68132,6 +71674,7 @@ self: { libraryHaskellDepends = [ base directory filepath hsmagick ]; description = "A DeepZoom image slicer. Only known to work on 32bit Linux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "defargs" = callPackage @@ -68143,6 +71686,7 @@ self: { libraryHaskellDepends = [ base cluss ]; description = "default arguments in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "deferred-folds" = callPackage @@ -68326,6 +71870,8 @@ self: { librarySystemDepends = [ mpdec ]; description = "Decimal floating point arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {mpdec = null;}; "deka-tests" = callPackage @@ -68346,6 +71892,7 @@ self: { testHaskellDepends = [ base bytestring deka QuickCheck quickpull ]; description = "Tests for deka, decimal floating point arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "delaunay" = callPackage @@ -68362,6 +71909,7 @@ self: { testHaskellDepends = [ AC-Vector base HUnit QuickCheck ]; description = "Build a Delaunay triangulation of a set of points"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "delay" = callPackage @@ -68392,6 +71940,7 @@ self: { ]; description = "Accessing the del.icio.us APIs from Haskell (v2)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "delimited-text" = callPackage @@ -68407,6 +71956,7 @@ self: { ]; description = "Parse character delimited textual data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "delimiter-separated" = callPackage @@ -68419,6 +71969,7 @@ self: { libraryHaskellDepends = [ base uhc-util uulib ]; description = "Library for dealing with tab and/or comma (or other) separated files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "delta" = callPackage @@ -68442,6 +71993,7 @@ self: { testHaskellDepends = [ base directory filepath hspec ]; description = "A library for detecting file changes"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "delta-h" = callPackage @@ -68463,6 +72015,7 @@ self: { ]; description = "Online entropy-based model of lexical category acquisition"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "delude" = callPackage @@ -68474,6 +72027,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Generalized the Prelude more functionally"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "demarcate" = callPackage @@ -68486,6 +72041,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Demarcating transformed monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "denominate" = callPackage @@ -68500,6 +72057,8 @@ self: { executableHaskellDepends = [ base directory filepath ]; description = "Functions supporting bulk file and directory name normalization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dense" = callPackage @@ -68545,6 +72104,8 @@ self: { ]; description = "Dense int-set"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dense-linear-algebra" = callPackage @@ -68580,6 +72141,8 @@ self: { ]; description = "Reader-like monad transformer for dependency injection"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dep-t-advice" = callPackage @@ -68602,6 +72165,7 @@ self: { ]; description = "Giving good advice to functions in a DepT environment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dependency" = callPackage @@ -68638,6 +72202,8 @@ self: { ]; description = "Dependent hash maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dependent-map_0_2_4_0" = callPackage @@ -68684,6 +72250,8 @@ self: { ]; description = "Dependent map that uses semigroup mappend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dependent-state" = callPackage @@ -68695,6 +72263,7 @@ self: { libraryHaskellDepends = [ base lens mtl prologue ]; description = "Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "dependent-sum_0_4" = callPackage @@ -68773,6 +72342,8 @@ self: { ]; description = "A simple configuration management tool for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dephd" = callPackage @@ -68791,6 +72362,7 @@ self: { ]; description = "Analyze quality of nucleotide sequences"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "depq" = callPackage @@ -68818,6 +72390,8 @@ self: { libraryHaskellDepends = [ base containers dlist mtl parsec ]; description = "DepTrack Core types and model"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deptrack-devops" = callPackage @@ -68836,6 +72410,7 @@ self: { ]; description = "DepTrack applied to DevOps"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "deptrack-dot" = callPackage @@ -68848,6 +72423,7 @@ self: { testHaskellDepends = [ base containers deptrack-core dotgen ]; description = "Facilitate Graphviz representations of DepTrack dependencies"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "deque" = callPackage @@ -68880,6 +72456,7 @@ self: { testHaskellDepends = [ base Cabal cabal-test-quickcheck ]; description = "A typeclass and an implementation for double-ended queues"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "derangement" = callPackage @@ -68891,6 +72468,8 @@ self: { libraryHaskellDepends = [ base fgl ]; description = "Find derangements of lists"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "derivation-trees" = callPackage @@ -68904,6 +72483,8 @@ self: { ]; description = "Typeset Derivation Trees via MetaPost"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "derive" = callPackage @@ -68924,6 +72505,8 @@ self: { executableHaskellDepends = [ base ]; description = "A program and library to derive instances for data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "derive-IG" = callPackage @@ -68935,6 +72518,7 @@ self: { libraryHaskellDepends = [ base instant-generics template-haskell ]; description = "Macro to derive instances for Instant-Generics using Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "derive-enumerable" = callPackage @@ -68946,6 +72530,8 @@ self: { libraryHaskellDepends = [ base data-default ]; description = "Generic instances for enumerating complex data types"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "derive-gadt" = callPackage @@ -68967,6 +72553,8 @@ self: { ]; description = "Instance deriving for (a subset of) GADTs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "derive-lifted-instances" = callPackage @@ -68995,6 +72583,8 @@ self: { testHaskellDepends = [ base semigroups ]; description = "derive Semigroup/Monoid/IsList"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "derive-storable" = callPackage @@ -69053,6 +72643,8 @@ self: { libraryHaskellDepends = [ array base containers template-haskell ]; description = "Automatic derivation of Trie implementations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deriveJsonNoPrefix" = callPackage @@ -69138,6 +72730,8 @@ self: { libraryHaskellDepends = [ base derp ]; description = "combinators based on parsing with derivatives (derp) package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "derulo" = callPackage @@ -69174,6 +72768,8 @@ self: { ]; description = "Combinators for describing binary data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "descrilo" = callPackage @@ -69219,6 +72815,8 @@ self: { ]; description = "Library, interpreter, and CLI for Descript programming language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "descriptive" = callPackage @@ -69281,6 +72879,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Simple deterministic game engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "detour-via-sci" = callPackage @@ -69324,6 +72924,7 @@ self: { ]; description = "JSON and CSV encoding for quantities"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "detrospector" = callPackage @@ -69355,6 +72956,8 @@ self: { executableHaskellDepends = [ base bytestring utf8-string ]; description = "Get rid of unicode (utf-8) symbols in Haskell sources"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "devil" = callPackage @@ -69373,6 +72976,8 @@ self: { ]; description = "A small tool to make it easier to update program managed by Angel"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "devtools" = callPackage @@ -69394,6 +72999,7 @@ self: { ]; description = "Haskell development tool agregate"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dewdrop" = callPackage @@ -69407,6 +73013,7 @@ self: { ]; description = "Find gadgets for return-oriented programming on x86"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "df1" = callPackage @@ -69481,6 +73088,7 @@ self: { ]; description = "A generic data integrity layer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) leveldb;}; "dfrac" = callPackage @@ -69511,6 +73119,8 @@ self: { ]; description = "Build Debian From Scratch CD/DVD images"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dgim" = callPackage @@ -69523,6 +73133,8 @@ self: { testHaskellDepends = [ base Cabal QuickCheck ]; description = "Implementation of DGIM algorithm"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dgs" = callPackage @@ -69534,6 +73146,8 @@ self: { libraryHaskellDepends = [ base HTTP mtl network split ]; description = "Haskell front-end for DGS' bot interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dhall_1_29_0" = callPackage @@ -69680,6 +73294,8 @@ self: { ]; description = "Check all dhall files in a project"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dhall-docs" = callPackage @@ -69708,6 +73324,7 @@ self: { ]; description = "Generate HTML docs from a dhall package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dhall-fly" = callPackage @@ -69740,6 +73357,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Translate concourse config from Dhall to YAML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dhall-json" = callPackage @@ -69922,6 +73541,8 @@ self: { ]; description = "Template text using Dhall"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dhall-to-cabal" = callPackage @@ -69950,6 +73571,8 @@ self: { ]; description = "Compile Dhall expressions to Cabal files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dhall-yaml" = callPackage @@ -69996,6 +73619,7 @@ self: { ]; description = "Parse a DHCP lease file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dhrun" = callPackage @@ -70029,6 +73653,8 @@ self: { doHaddock = false; description = "Dhall/YAML configurable concurrent integration test executor"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "di" = callPackage @@ -70136,6 +73762,8 @@ self: { libraryHaskellDepends = [ base deepseq ]; description = "An EDSL for teaching Haskell with diagrams - data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dia-functions" = callPackage @@ -70153,6 +73781,7 @@ self: { ]; description = "An EDSL for teaching Haskell with diagrams - functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams" = callPackage @@ -70182,6 +73811,8 @@ self: { libraryHaskellDepends = [ base cubicbezier diagrams-lib ]; description = "deprecated, part of diagrams-contrib since 1.4"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-braille" = callPackage @@ -70207,6 +73838,7 @@ self: { ]; description = "Braille diagrams with plain text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-builder" = callPackage @@ -70235,6 +73867,7 @@ self: { ]; description = "hint-based build service for the diagrams graphics EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-cairo" = callPackage @@ -70275,6 +73908,8 @@ self: { ]; description = "HTML5 canvas backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-contrib" = callPackage @@ -70337,6 +73972,8 @@ self: { ]; description = "Graph layout and drawing with GraphViz and diagrams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-gtk" = callPackage @@ -70352,6 +73989,8 @@ self: { ]; description = "Backend for rendering diagrams directly to GTK windows"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-haddock" = callPackage @@ -70382,6 +74021,7 @@ self: { ]; description = "Preprocessor for embedding diagrams in Haddock documentation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-hsqml" = callPackage @@ -70417,6 +74057,7 @@ self: { ]; description = "HTML5 canvas backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-lib" = callPackage @@ -70475,6 +74116,7 @@ self: { ]; description = "A Pandoc filter to express diagrams inline using the Haskell EDSL _Diagrams_"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-pdf" = callPackage @@ -70492,6 +74134,8 @@ self: { ]; description = "PDF backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-pgf" = callPackage @@ -70511,6 +74155,7 @@ self: { ]; description = "PGF backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-postscript" = callPackage @@ -70545,6 +74190,8 @@ self: { ]; description = "Draw QR codes to SVG, PNG, PDF or PS files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-rasterific" = callPackage @@ -70567,6 +74214,8 @@ self: { testHaskellDepends = [ base diagrams-core diagrams-lib ]; description = "Rasterific backend for diagrams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-reflex" = callPackage @@ -70650,6 +74299,8 @@ self: { ]; description = "TikZ backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams-wx" = callPackage @@ -70667,6 +74318,7 @@ self: { ]; description = "Backend for rendering diagrams in wxWidgets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dialog" = callPackage @@ -70728,6 +74380,8 @@ self: { ]; description = "A simple, forward build system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dice" = callPackage @@ -70773,6 +74427,8 @@ self: { executableHaskellDepends = [ base ]; description = "Convert a Diceware wordlist into a printer-ready LaTeX file"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dicom" = callPackage @@ -70786,6 +74442,8 @@ self: { ]; description = "A library for reading and writing DICOM files in the Explicit VR Little Endian transfer syntax"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dictionaries" = callPackage @@ -70814,6 +74472,8 @@ self: { ]; description = "Tools to handle StarDict dictionaries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dictionary-sharing" = callPackage @@ -70842,6 +74502,8 @@ self: { testHaskellDepends = [ base hspec parsec ]; description = "Parsec parsers for the DICT format produced by dictfmt -t"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diet" = callPackage @@ -70859,6 +74521,8 @@ self: { ]; description = "Discrete Interval Encoding Trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diff" = callPackage @@ -70870,6 +74534,8 @@ self: { libraryHaskellDepends = [ base Enum util ]; description = "Diff and patch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diff-gestalt" = callPackage @@ -70942,6 +74608,8 @@ self: { ]; description = "Diff two .cabal files syntactically"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diffdump" = callPackage @@ -70980,6 +74648,7 @@ self: { groups hedgehog hedgehog-checkers QuickCheck semigroupoids ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "differential" = callPackage @@ -71018,6 +74687,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "diff on maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "difftodo" = callPackage @@ -71043,6 +74714,8 @@ self: { ]; description = "Generate todo lists from source code"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digamma" = callPackage @@ -71109,6 +74782,8 @@ self: { ]; description = "Speed up form designing using digestive functors and bootstrap"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digestive-foundation-lucid" = callPackage @@ -71125,6 +74800,8 @@ self: { ]; description = "Speed up form designing using digestive functors and foundation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digestive-functors" = callPackage @@ -71167,6 +74844,8 @@ self: { ]; description = "Run digestive-functors forms against JSON"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digestive-functors-blaze" = callPackage @@ -71197,6 +74876,8 @@ self: { ]; description = "Happstack backend for the digestive-functors library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digestive-functors-heist" = callPackage @@ -71225,6 +74906,7 @@ self: { libraryToolDepends = [ trhsx ]; description = "HSP support for digestive-functors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "digestive-functors-lucid" = callPackage @@ -71308,6 +74990,8 @@ self: { testHaskellDepends = [ base doctest hspec ]; description = "digitalocean api for haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digits" = callPackage @@ -71320,6 +75004,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Converts integers to lists of digits and back"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digraph" = callPackage @@ -71410,6 +75096,8 @@ self: { libraryHaskellDepends = [ base numtype-tf time ]; description = "Statically checked physical dimensions, implemented using type families"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dimensions" = callPackage @@ -71448,6 +75136,7 @@ self: { ]; description = "Dingo is a Rich Internet Application platform based on the Warp web server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "dingo-example" = callPackage @@ -71467,6 +75156,7 @@ self: { ]; description = "Dingo Example"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "dingo-widgets" = callPackage @@ -71485,6 +75175,7 @@ self: { ]; description = "Dingo Widgets"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "dino" = callPackage @@ -71530,6 +75221,8 @@ self: { ]; description = "Gemini client"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diophantine" = callPackage @@ -71542,6 +75235,8 @@ self: { libraryToolDepends = [ happy ]; description = "A quadratic diophantine equation solving library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diplomacy" = callPackage @@ -71557,6 +75252,7 @@ self: { ]; description = "Diplomacy board game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diplomacy-server" = callPackage @@ -71580,6 +75276,7 @@ self: { ]; description = "Play Diplomacy over HTTP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dir-traverse" = callPackage @@ -71607,6 +75304,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl ]; description = "Serialization and deserialization monads for streams and ByteStrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "direct-daemonize" = callPackage @@ -71633,6 +75332,8 @@ self: { ]; description = "Native implementation of the FastCGI protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "direct-http" = callPackage @@ -71651,6 +75352,8 @@ self: { ]; description = "Native webserver that acts as a library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "direct-murmur-hash" = callPackage @@ -71673,6 +75376,8 @@ self: { libraryHaskellDepends = [ base ghc ghc-paths ]; description = "Lightweight replacement for Plugins, specific to GHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "direct-rocksdb" = callPackage @@ -71692,6 +75397,8 @@ self: { ]; description = "Bindings to RocksDB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "direct-sqlite" = callPackage @@ -71724,6 +75431,8 @@ self: { ]; description = "Finite directed cubical complexes and associated algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "directory_1_3_6_1" = callPackage @@ -71758,6 +75467,8 @@ self: { testHaskellDepends = [ base filepath ]; description = "Recursively build, navigate, and operate on a tree of directory contents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "directory-layout" = callPackage @@ -71821,6 +75532,8 @@ self: { executableHaskellDepends = [ base directory ]; description = "Deletes a directory and retains its contents in the parent directory"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dirfiles" = callPackage @@ -71836,6 +75549,7 @@ self: { unordered-containers ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dirichlet" = callPackage @@ -71925,6 +75639,7 @@ self: { ]; description = "Client for Discogs REST API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "discokitty" = callPackage @@ -71953,6 +75668,7 @@ self: { ]; description = "An API wrapper for Discord in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "discord-haskell" = callPackage @@ -71992,6 +75708,7 @@ self: { ]; description = "An API wrapper for Discord in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "discord-register" = callPackage @@ -72023,6 +75740,7 @@ self: { ]; description = "Discord verification bot"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "discord-rest" = callPackage @@ -72042,6 +75760,7 @@ self: { ]; description = "An API wrapper for Discord in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "discord-types" = callPackage @@ -72060,6 +75779,8 @@ self: { ]; description = "Type information for discord-hs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "discordian-calendar" = callPackage @@ -72071,6 +75792,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "library for handling Discordian calendar dates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "discount" = callPackage @@ -72096,6 +75819,8 @@ self: { libraryHaskellDepends = [ base ]; description = "replacement for enum"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "discrete-intervals" = callPackage @@ -72169,6 +75894,8 @@ self: { ]; description = "Disjoint containers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "disjoint-set" = callPackage @@ -72185,6 +75912,8 @@ self: { ]; description = "Persistent disjoint-sets, a.k.a union-find."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "disjoint-set-stateful" = callPackage @@ -72197,6 +75926,8 @@ self: { testHaskellDepends = [ base hspec primitive ref-tf vector ]; description = "Monadic disjoint set"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "disjoint-sets-st" = callPackage @@ -72286,6 +76017,8 @@ self: { doHaddock = false; description = "Generate/Upload cabal package to Hackage"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "distance" = callPackage @@ -72299,6 +76032,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Useful distance datatype and functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "distance-of-time" = callPackage @@ -72374,6 +76109,8 @@ self: { ]; description = "AWS Lambda backend for distributed-fork"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "distributed-process" = callPackage @@ -72398,6 +76135,8 @@ self: { ]; description = "Cloud Haskell: Erlang-style concurrency in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "distributed-process-async" = callPackage @@ -72425,6 +76164,7 @@ self: { ]; description = "Cloud Haskell Async API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-azure" = callPackage @@ -72447,6 +76187,7 @@ self: { ]; description = "Microsoft Azure backend for Cloud Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-client-server" = callPackage @@ -72476,6 +76217,7 @@ self: { ]; description = "The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-ekg" = callPackage @@ -72491,6 +76233,7 @@ self: { ]; description = "Collect node stats for EKG"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-execution" = callPackage @@ -72526,6 +76269,7 @@ self: { ]; description = "Execution Framework for The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-extras" = callPackage @@ -72556,6 +76300,7 @@ self: { ]; description = "Cloud Haskell Extras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-fsm" = callPackage @@ -72588,6 +76333,7 @@ self: { ]; description = "The Cloud Haskell implementation of Erlang/OTP gen_statem"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-lifted" = callPackage @@ -72613,6 +76359,7 @@ self: { ]; description = "monad-control style typeclass and transformer instances for Process monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-monad-control" = callPackage @@ -72629,6 +76376,7 @@ self: { ]; description = "Orphan instances for MonadBase and MonadBaseControl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-p2p" = callPackage @@ -72649,6 +76397,7 @@ self: { executableHaskellDepends = [ base distributed-process mtl ]; description = "Peer-to-peer node discovery for Cloud Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-platform" = callPackage @@ -72679,6 +76428,7 @@ self: { ]; description = "The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-registry" = callPackage @@ -72711,6 +76461,7 @@ self: { ]; description = "Cloud Haskell Extended Process Registry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-simplelocalnet" = callPackage @@ -72733,6 +76484,7 @@ self: { ]; description = "Simple zero-configuration backend for Cloud Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-supervisor" = callPackage @@ -72764,6 +76516,7 @@ self: { ]; description = "Supervisors for The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-systest" = callPackage @@ -72783,6 +76536,7 @@ self: { ]; description = "Cloud Haskell Test Support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-task" = callPackage @@ -72819,6 +76573,7 @@ self: { ]; description = "Task Framework for The Cloud Haskell Application Platform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-tests" = callPackage @@ -72842,6 +76597,7 @@ self: { ]; description = "Tests and test support tools for distributed-process"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-process-zookeeper" = callPackage @@ -72870,6 +76626,7 @@ self: { ]; description = "A Zookeeper back-end for Cloud Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "distributed-static" = callPackage @@ -72898,6 +76655,8 @@ self: { ]; description = "Finite discrete probability distributions"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "distribution-nixpkgs" = callPackage @@ -72953,6 +76712,7 @@ self: { ]; description = "Easily plot distributions from the distribution package.."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "distributive" = callPackage @@ -73051,6 +76811,7 @@ self: { ]; description = "A wiki implemented with a firm theoretical foundation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "djembe" = callPackage @@ -73066,6 +76827,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Hit drums with haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "djinn" = callPackage @@ -73122,6 +76885,8 @@ self: { ]; description = "Generate executable Haskell code from a type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dl-fedora" = callPackage @@ -73144,6 +76909,7 @@ self: { testHaskellDepends = [ base simple-cmd ]; description = "Fedora image download tool"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "dlist" = callPackage @@ -73244,6 +77010,8 @@ self: { ]; description = "AVAYA DMCC API bindings and WebSockets server for AVAYA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dmenu" = callPackage @@ -73259,6 +77027,8 @@ self: { ]; description = "Complete bindings to the dmenu and dmenu2 command line tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dmenu-pkill" = callPackage @@ -73276,6 +77046,7 @@ self: { ]; description = "dmenu script for killing applications. Sortable by process id or CPU/MEM usage."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dmenu-pmount" = callPackage @@ -73293,6 +77064,7 @@ self: { ]; description = "Mounting and unmounting linux devices as user with dmenu and pmount"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dmenu-search" = callPackage @@ -73310,6 +77082,7 @@ self: { ]; description = "dmenu script for searching the web with customizable search engines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dns" = callPackage @@ -73352,6 +77125,8 @@ self: { executableHaskellDepends = [ base ]; description = "Caching DNS resolver library and mass DNS resolver utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dnsrbl" = callPackage @@ -73364,6 +77139,8 @@ self: { libraryHaskellDepends = [ base containers hsdns HUnit network ]; description = "Asynchronous DNS RBL lookup"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dnssd" = callPackage @@ -73376,6 +77153,8 @@ self: { librarySystemDepends = [ dns_sd ]; description = "DNS service discovery bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {dns_sd = null;}; "do-list" = callPackage @@ -73454,6 +77233,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Creates the time intervals for CLI changing messages on the screen"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dobutokO" = callPackage @@ -73616,6 +77397,7 @@ self: { ]; description = "Document review Web application, like http://book.realworldhaskell.org/"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "doccheck" = callPackage @@ -73634,6 +77416,8 @@ self: { ]; description = "Checks Haddock comments for pitfalls and version changes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "docidx" = callPackage @@ -73652,6 +77436,8 @@ self: { ]; description = "Generate an HTML index of installed Haskell packages and their documentation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "docker" = callPackage @@ -73685,6 +77471,8 @@ self: { ]; description = "An API client for docker written in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "docker-build-cacher" = callPackage @@ -73707,6 +77495,8 @@ self: { ]; description = "Builds a docker image and caches all of its intermediate stages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dockercook" = callPackage @@ -73740,6 +77530,8 @@ self: { testHaskellDepends = [ base HTF text vector ]; description = "A build tool for multiple docker image layers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dockerfile" = callPackage @@ -73773,6 +77565,8 @@ self: { th-lift th-lift-instances time ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "doclayout" = callPackage @@ -73811,6 +77605,8 @@ self: { ]; description = "A command-line interface parser that will make you smile"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "docrecords" = callPackage @@ -73831,6 +77627,8 @@ self: { ]; description = "Vinyl-based records with hierarchical field names, default values and documentation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "docstrings" = callPackage @@ -73975,6 +77773,8 @@ self: { doHaddock = false; description = "Easy way to run doctests via cabal (no aeson dependency, uses configurator instead)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "doctest-driver-gen" = callPackage @@ -74046,6 +77846,8 @@ self: { testHaskellDepends = [ base doctest HUnit QuickCheck ]; description = "Allow QuickCheck-style property testing within doctest"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "docusign-base" = callPackage @@ -74115,6 +77917,8 @@ self: { ]; description = "DocuSign examples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "docvim" = callPackage @@ -74141,6 +77945,8 @@ self: { ]; description = "Documentation generator for Vim plug-ins"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "doi" = callPackage @@ -74169,6 +77975,7 @@ self: { ]; description = "Automatic Bibtex and fulltext of scientific articles"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "doldol" = callPackage @@ -74291,6 +78098,7 @@ self: { ]; description = "Codegen helping you define domain models"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "domain-auth" = callPackage @@ -74325,6 +78133,7 @@ self: { ]; description = "Low-level API of \"domain\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "domain-optics" = callPackage @@ -74343,6 +78152,7 @@ self: { testHaskellDepends = [ domain optics rerebase ]; description = "Integration of domain with optics"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "dominion" = callPackage @@ -74374,6 +78184,8 @@ self: { ]; description = "A simple templating library using HTML5 as its template language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dormouse-client" = callPackage @@ -74466,6 +78278,8 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dot2graphml" = callPackage @@ -74538,6 +78352,8 @@ self: { doHaddock = false; description = "Filesystem to manage and parse dotfiles"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dotgen" = callPackage @@ -74628,6 +78444,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Doublify API toolkit for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dove" = callPackage @@ -74684,6 +78502,7 @@ self: { ]; description = "Dungeons of Wor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "download" = callPackage @@ -74726,6 +78545,7 @@ self: { ]; description = "Simple tool to download images from RSS feeds (e.g. Flickr, Picasa)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "downloader" = callPackage @@ -74742,6 +78562,8 @@ self: { ]; description = "A small, low-dependency library that provides turn-key file download over HTTP and HTTPS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dozenal" = callPackage @@ -74753,6 +78575,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A Haskell library for using Dozenal (Duodecimal - Base 12) numbers"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dozens" = callPackage @@ -74772,6 +78596,8 @@ self: { ]; description = "dozens api library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dph-base" = callPackage @@ -74785,6 +78611,8 @@ self: { ]; description = "Data Parallel Haskell common config and debugging functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dph-examples" = callPackage @@ -74803,6 +78631,7 @@ self: { ]; description = "Data Parallel Haskell example programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dph-lifted-base" = callPackage @@ -74819,6 +78648,7 @@ self: { ]; description = "Data Parallel Haskell common definitions used by other dph-lifted packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dph-lifted-copy" = callPackage @@ -74834,6 +78664,7 @@ self: { ]; description = "Data Parallel Haskell lifted array combinators. (deprecated version)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dph-lifted-vseg" = callPackage @@ -74850,6 +78681,7 @@ self: { ]; description = "Data Parallel Haskell lifted array combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dph-par" = callPackage @@ -74872,6 +78704,7 @@ self: { libraryHaskellDepends = [ base dph-base random vector ]; description = "Data Parallel Haskell segmented arrays. (abstract interface)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dph-prim-par" = callPackage @@ -74888,6 +78721,7 @@ self: { ]; description = "Data Parallel Haskell segmented arrays. (production version)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dph-prim-seq" = callPackage @@ -74903,6 +78737,7 @@ self: { ]; description = "Data Parallel Haskell segmented arrays. (sequential implementation)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dph-seq" = callPackage @@ -74934,6 +78769,8 @@ self: { testPkgconfigDepends = [ libdpkg ]; description = "libdpkg bindings"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) dpkg; libdpkg = null;}; "dpor" = callPackage @@ -74947,6 +78784,8 @@ self: { ]; description = "A generic implementation of dynamic partial-order reduction (DPOR) for testing arbitrary models of concurrency"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dprox" = callPackage @@ -74983,6 +78822,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Monadic FRP"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dragen" = callPackage @@ -75003,6 +78844,8 @@ self: { ]; description = "Automatic derivation of optimized QuickCheck random generators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "drama" = callPackage @@ -75048,6 +78891,8 @@ self: { testHaskellDepends = [ base containers hspec QuickCheck ]; description = "A port of asciimoo's drawille to haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dresdner-verkehrsbetriebe" = callPackage @@ -75070,6 +78915,8 @@ self: { ]; description = "Library and program for querying DVB (Dresdner Verkehrsbetriebe AG)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "drifter" = callPackage @@ -75106,6 +78953,8 @@ self: { ]; description = "PostgreSQL support for the drifter schema migration tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "drifter-sqlite" = callPackage @@ -75149,6 +78998,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "A Haskell bindings to the DRMAA C library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {drmaa = null;}; "drone" = callPackage @@ -75167,6 +79018,8 @@ self: { microlens req servant-server text warp ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dropbox" = callPackage @@ -75216,6 +79069,7 @@ self: { ]; description = "A library to access the Dropbox HTTP API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "dropsolve" = callPackage @@ -75234,6 +79088,7 @@ self: { ]; description = "A command line tool for resolving dropbox conflicts. Deprecated! Please use confsolve."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "drunken-bishop" = callPackage @@ -75263,6 +79118,8 @@ self: { testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; description = "A subset of the miniKanren language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dsc" = callPackage @@ -75282,6 +79139,8 @@ self: { ]; description = "Helper functions for setting up Double Submit Cookie defense for forms"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dsh-sql" = callPackage @@ -75309,6 +79168,7 @@ self: { ]; description = "SQL backend for Database Supported Haskell (DSH)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dsmc" = callPackage @@ -75326,6 +79186,8 @@ self: { ]; description = "DSMC library for rarefied gas dynamics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dsmc-tools" = callPackage @@ -75345,6 +79207,7 @@ self: { ]; description = "DSMC toolkit for rarefied gas dynamics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dson" = callPackage @@ -75356,6 +79219,8 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "Haskell Doge Serialized Object Notation Parser"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dson-parsec" = callPackage @@ -75367,6 +79232,8 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "DSON parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dsp" = callPackage @@ -75392,6 +79259,8 @@ self: { libraryHaskellDepends = [ base base-unicode-symbols dlist ]; description = "Difference strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dsv" = callPackage @@ -75453,6 +79322,7 @@ self: { ]; description = "Parse and render DTD files (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dtd-text" = callPackage @@ -75468,6 +79338,8 @@ self: { ]; description = "Parse and render XML DTDs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dtd-types" = callPackage @@ -75509,6 +79381,8 @@ self: { ]; description = "(Fast) Dynamic Time Warping"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dual" = callPackage @@ -75575,6 +79449,8 @@ self: { ]; description = "Automatically generate dual constructions"; license = "AGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dublincore-xml-conduit" = callPackage @@ -75659,6 +79535,8 @@ self: { ]; description = "A tiny language, a subset of Haskell (with type classes) aimed at aiding teachers to teach Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dumb-cas" = callPackage @@ -75676,6 +79554,7 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "A computer “algebra” system that knows nothing about algebra, at the core"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "dump" = callPackage @@ -75713,6 +79592,8 @@ self: { ]; description = "A plug-in for rendering GHC core"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dunai" = callPackage @@ -75744,6 +79625,8 @@ self: { ]; description = "Generalised reactive framework supporting classic, arrowized and monadic FRP. (Core library fork.)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dunai-test" = callPackage @@ -75793,6 +79676,8 @@ self: { ]; description = "Frontend development build tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dura" = callPackage @@ -75806,6 +79691,8 @@ self: { libraryHaskellDepends = [ base bytestring directory filepath ]; description = "durable/atomic file system writes (from rio package)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "duration" = callPackage @@ -75862,6 +79749,8 @@ self: { ]; description = "Dead simple password manager"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dvda" = callPackage @@ -75884,6 +79773,7 @@ self: { ]; description = "Efficient automatic differentiation and code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dvdread" = callPackage @@ -75897,6 +79787,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "A monadic interface to libdvdread"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {dvdread = null;}; "dvi-processing" = callPackage @@ -75908,6 +79800,8 @@ self: { libraryHaskellDepends = [ base bytestring filepath transformers ]; description = "Read/write DVI and TFM file"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dvorak" = callPackage @@ -75932,6 +79826,8 @@ self: { libraryHaskellDepends = [ base binary bytestring containers ]; description = "Parser for DWARF debug format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dwarf-el" = callPackage @@ -75966,6 +79862,8 @@ self: { executableHaskellDepends = [ base containers dwarf-el ]; description = "High-level wrapper around the dwarf library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dwergaz" = callPackage @@ -76032,6 +79930,8 @@ self: { testHaskellDepends = [ ansi-terminal base hspec text ]; description = "A library for working with binary Dyck words"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dyepack" = callPackage @@ -76045,6 +79945,8 @@ self: { libraryHaskellDepends = [ base generics-sop ]; description = "Programatically identify space leaks in your program"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dynamic" = callPackage @@ -76082,6 +79984,7 @@ self: { ]; description = "Access the functions from the Cabal library without depending on it"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dynamic-graph" = callPackage @@ -76125,6 +80028,8 @@ self: { benchmarkHaskellDepends = [ base criterion primitive ]; description = "Dynamic graph algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dynamic-linker-template" = callPackage @@ -76163,6 +80068,8 @@ self: { libraryHaskellDepends = [ base primitive vector ]; description = "A wrapper around MVector that enables pushing, popping and extending"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dynamic-object" = callPackage @@ -76181,6 +80088,8 @@ self: { ]; description = "Object-oriented programming with duck typing and singleton classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dynamic-plot" = callPackage @@ -76207,6 +80116,7 @@ self: { ]; description = "Interactive diagram windows"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "dynamic-pp" = callPackage @@ -76227,6 +80137,8 @@ self: { ]; description = "A pretty-print library that employs a dynamic programming algorithm for optimal rendering"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dynamic-state" = callPackage @@ -76269,6 +80181,8 @@ self: { ]; description = "Typesafe library for working with DynamoDB database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dynloader" = callPackage @@ -76281,6 +80195,8 @@ self: { testHaskellDepends = [ base ghc ghc-paths hspec ]; description = "Dynamically runtime loading packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dynobud" = callPackage @@ -76312,6 +80228,7 @@ self: { ]; description = "your dynamic optimization buddy"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "dyre" = callPackage @@ -76357,6 +80274,8 @@ self: { libraryHaskellDepends = [ base bytestring transformers ]; description = "Bindings to the dywapitchtrack pitch tracking library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dzen-dhall" = callPackage @@ -76392,6 +80311,8 @@ self: { ]; description = "Configure dzen2 bars in Dhall language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dzen-utils" = callPackage @@ -76403,6 +80324,8 @@ self: { libraryHaskellDepends = [ base colour process ]; description = "Utilities for creating inputs for dzen"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "each" = callPackage @@ -76416,6 +80339,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Template Haskell library for writing monadic expressions more easily"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eager-sockets" = callPackage @@ -76462,6 +80387,8 @@ self: { testHaskellDepends = [ base filepath hspec ]; description = "Ear Clipping Triangulation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "earcut" = callPackage @@ -76494,6 +80421,8 @@ self: { testHaskellDepends = [ base ]; description = "Early return syntax in do-notation (GHC plugin)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ease" = callPackage @@ -76520,6 +80449,8 @@ self: { ]; description = "Utility code for building HTTP API bindings more quickly"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "easy-args" = callPackage @@ -76549,6 +80480,8 @@ self: { ]; description = "types and functions for bitcoin applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "easy-file" = callPackage @@ -76575,6 +80508,8 @@ self: { ]; description = "Haskell JSON library with an emphasis on simplicity, minimal dependencies, and ease of use"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "easyplot" = callPackage @@ -76586,6 +80521,8 @@ self: { libraryHaskellDepends = [ base process ]; description = "A tiny plotting library, utilizes gnuplot for plotting"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "easyrender" = callPackage @@ -76648,6 +80585,8 @@ self: { ]; description = "Simple, expressive testing library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ebeats" = callPackage @@ -76659,6 +80598,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "Time in ebeats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ebnf-bff" = callPackage @@ -76677,6 +80618,8 @@ self: { ]; description = "Parser combinators & EBNF, BFFs!"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ec2-signature" = callPackage @@ -76733,6 +80676,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion random ]; description = "Elliptic Curve Cryptography for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eccrypto-ed25519-bindings" = callPackage @@ -76744,6 +80689,7 @@ self: { libraryHaskellDepends = [ base bytestring eccrypto ]; description = "provides \"ed25519\" API using \"eccrypto\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ecdsa" = callPackage @@ -76791,6 +80737,8 @@ self: { executableHaskellDepends = [ base ]; description = "A ECMA-262 interpreter library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ecstasy" = callPackage @@ -76824,6 +80772,8 @@ self: { executableSystemDepends = [ canlib ]; description = "Tools for automotive ECU development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {canlib = null;}; "ed25519" = callPackage @@ -76871,6 +80821,8 @@ self: { ]; description = "Command line file filtering with haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ede" = callPackage @@ -76902,6 +80854,8 @@ self: { ]; description = "Templating language with similar syntax and features to Liquid or Jinja2"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "edenmodules" = callPackage @@ -76913,6 +80867,8 @@ self: { libraryHaskellDepends = [ base containers deepseq parallel ]; description = "Semi-explicit parallel programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "edenskel" = callPackage @@ -76924,6 +80880,7 @@ self: { libraryHaskellDepends = [ base edenmodules parallel ]; description = "Semi-explicit parallel programming skeleton library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "edentv" = callPackage @@ -76944,6 +80901,7 @@ self: { ]; description = "A Tool to Visualize Parallel Functional Program Executions"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "edf" = callPackage @@ -76973,6 +80931,7 @@ self: { ]; description = "Top view space combat arcade game"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "edges" = callPackage @@ -77000,6 +80959,7 @@ self: { ]; description = "Tools for efficient immutable graphs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "edis" = callPackage @@ -77011,6 +80971,8 @@ self: { libraryHaskellDepends = [ base bytestring cereal hedis ]; description = "Statically typechecked client for Redis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "edit" = callPackage @@ -77031,6 +80993,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "A monad for rewriting things"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "edit-distance" = callPackage @@ -77102,6 +81066,8 @@ self: { ]; description = "Symmetric, stateful edit lenses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "edit-lenses-demo" = callPackage @@ -77126,6 +81092,7 @@ self: { libraryHaskellDepends = [ base text vty vty-ui ]; description = "Interactive editors for Generics"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "editline" = callPackage @@ -77137,6 +81104,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Bindings to the editline library (libedit)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "editor-open" = callPackage @@ -77194,6 +81163,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A library for writing extensible algebraic effects and handlers. Similar to extensible-effects but with deep handlers."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "effect-monad" = callPackage @@ -77205,6 +81176,8 @@ self: { libraryHaskellDepends = [ base type-level-sets ]; description = "Embeds effect systems and program logics into Haskell using graded monads and parameterised monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "effect-stack" = callPackage @@ -77216,6 +81189,8 @@ self: { libraryHaskellDepends = [ base constraints mtl transformers ]; description = "Reducing the pain of transformer stacks with duplicated effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "effective-aspects" = callPackage @@ -77311,6 +81286,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A Typeable-free implementation of extensible effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "egison" = callPackage @@ -77346,6 +81323,7 @@ self: { benchmarkHaskellDepends = [ base criterion transformers ]; description = "Programming language with non-linear pattern-matching against non-free data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "egison-pattern-src" = callPackage @@ -77367,6 +81345,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Manipulating Egison patterns: abstract syntax, parser, and pretty-printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "egison-pattern-src-haskell-mode" = callPackage @@ -77386,6 +81366,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "Parser and pretty printer for Egison pattern expressions in Haskell source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "egison-pattern-src-th-mode" = callPackage @@ -77408,6 +81389,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "Parser and pretty printer for Egison pattern expressions to use with TH"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "egison-quote" = callPackage @@ -77421,6 +81403,7 @@ self: { ]; description = "A quasi quotes for using Egison expression in Haskell code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "egison-tutorial" = callPackage @@ -77439,6 +81422,7 @@ self: { ]; description = "A tutorial program for the Egison programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "egyptian-fractions" = callPackage @@ -77468,6 +81452,8 @@ self: { ]; description = "like eruby, ehaskell is embedded haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ehs" = callPackage @@ -77488,6 +81474,8 @@ self: { ]; description = "Embedded haskell template using quasiquotes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eibd-client-simple" = callPackage @@ -77506,6 +81494,8 @@ self: { librarySystemDepends = [ eibclient ]; description = "EIBd Client"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {eibclient = null;}; "eigen" = callPackage @@ -77525,6 +81515,8 @@ self: { ]; description = "Eigen C++ library (linear algebra: matrices, sparse matrices, vectors, numerical solvers)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eio" = callPackage @@ -77540,6 +81532,8 @@ self: { executableToolDepends = [ markdown-unlit ]; description = "IO with Exceptions tracked on the type-level"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "either" = callPackage @@ -77612,6 +81606,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Functions for probing and unwrapping values inside of Either"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eithers" = callPackage @@ -77643,6 +81639,8 @@ self: { ]; description = "Binding to EJDB2 C library, an embedded JSON noSQL database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {ejdb2 = null; libejdb2 = null;}; "ekg" = callPackage @@ -77680,6 +81678,8 @@ self: { ]; description = "Send ekg metrics to a Bosun instance"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ekg-carbon" = callPackage @@ -77696,6 +81696,8 @@ self: { ]; description = "An EKG backend to send statistics to Carbon (part of Graphite monitoring tools)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ekg-cloudwatch" = callPackage @@ -77747,6 +81749,8 @@ self: { ]; description = "Push metrics to elastic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ekg-elasticsearch" = callPackage @@ -77764,6 +81768,8 @@ self: { ]; description = "Push metrics to elasticsearch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ekg-influxdb" = callPackage @@ -77812,6 +81818,8 @@ self: { ]; description = "Push metrics to a log file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ekg-prometheus-adapter" = callPackage @@ -77848,6 +81856,8 @@ self: { ]; description = "Small framework to push metric deltas to a broadcast channel using the ekg-core library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ekg-rrd" = callPackage @@ -77868,6 +81878,8 @@ self: { ]; description = "Passes ekg statistics to rrdtool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ekg-statsd" = callPackage @@ -77903,6 +81915,8 @@ self: { ]; description = "Remote monitoring of processes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "elbow" = callPackage @@ -77965,6 +81979,7 @@ self: { executableHaskellDepends = [ base elerea GLFW OpenGL ]; description = "Example applications for Elerea"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "elerea-sdl" = callPackage @@ -77988,6 +82003,8 @@ self: { libraryHaskellDepends = [ base extensible transformers ]; description = "Immediately lifts to a desired level"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "elf" = callPackage @@ -78053,6 +82070,8 @@ self: { executableHaskellDepends = [ base ]; description = "Arrows with holes"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "elliptic-curve" = callPackage @@ -78078,6 +82097,7 @@ self: { ]; description = "Elliptic curve library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "elm-bridge" = callPackage @@ -78401,6 +82421,8 @@ self: { doHaddock = false; description = "Crossing the road between Haskell and Elm"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "elm-syntax" = callPackage @@ -78450,6 +82472,8 @@ self: { ]; description = "Generate ELM code from a Wai websocket application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "elm-yesod" = callPackage @@ -78564,6 +82588,7 @@ self: { testHaskellDepends = [ base directory filepath tasty tasty-hunit ]; description = "A tiny language for understanding the lambda-calculus"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "elynx" = callPackage @@ -78729,6 +82754,7 @@ self: { ]; description = "library to parse emacs style keybinding into the modifiers and the chars"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "emacs-module" = callPackage @@ -78748,6 +82774,8 @@ self: { ]; description = "Utilities to write Emacs dynamic modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "email" = callPackage @@ -78764,6 +82792,7 @@ self: { ]; description = "Sending eMail in Haskell made easy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "email-header" = callPackage @@ -78785,6 +82814,8 @@ self: { ]; description = "Parsing and rendering of email and MIME headers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "email-postmark" = callPackage @@ -78800,6 +82831,8 @@ self: { ]; description = "A simple wrapper to send emails via the api of the service postmark (http://postmarkapp.com/)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "email-validate" = callPackage @@ -78872,6 +82905,8 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "Wrapper around email-validate library adding instances for common type classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "emailparse" = callPackage @@ -78894,6 +82929,7 @@ self: { ]; description = "An email parser that will parse everything"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "embeddock" = callPackage @@ -78910,6 +82946,7 @@ self: { ]; description = "Embed the values in scope in the haddock documentation of the module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "embeddock-example" = callPackage @@ -78921,6 +82958,7 @@ self: { libraryHaskellDepends = [ base embeddock time ]; description = "Example of using embeddock"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "embla" = callPackage @@ -78932,6 +82970,8 @@ self: { libraryHaskellDepends = [ base chronos ]; description = "execute actions periodically while avoiding drift"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "embroidery" = callPackage @@ -78950,6 +82990,7 @@ self: { executableHaskellDepends = [ base ]; description = "support for embroidery formats in haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "emd" = callPackage @@ -78992,6 +83033,8 @@ self: { testHaskellDepends = [ base HUnit QuickCheck syb ]; description = "Extensible and Modular Generics for the Masses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "emoji" = callPackage @@ -79044,6 +83087,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A container that always has no values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "enchant" = callPackage @@ -79060,6 +83105,8 @@ self: { testHaskellDepends = [ base ]; description = "Binding to the Enchant library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) enchant;}; "enclosed-exceptions" = callPackage @@ -79117,6 +83164,8 @@ self: { testHaskellDepends = [ base bytestring HUnit QuickCheck ]; description = "A library for various character encodings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "encoding-io" = callPackage @@ -79130,6 +83179,8 @@ self: { ]; description = "Encoding-aware file I/O"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "encryptable" = callPackage @@ -79153,6 +83204,8 @@ self: { ]; description = "Typed encryption with persistent support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "endo" = callPackage @@ -79225,6 +83278,7 @@ self: { unordered-containers wai wai-websockets websockets ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "engine-io-snap" = callPackage @@ -79241,6 +83295,8 @@ self: { snap-core unordered-containers websockets websockets-snap ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "engine-io-wai" = callPackage @@ -79259,6 +83315,8 @@ self: { ]; description = "An @engine-io@ @ServerAPI@ that is compatible with @Wai@"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "engine-io-yesod" = callPackage @@ -79275,6 +83333,8 @@ self: { unordered-containers wai wai-websockets websockets yesod-core ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "engineering-units" = callPackage @@ -79302,6 +83362,7 @@ self: { executableHaskellDepends = [ base matrix quipper-core ]; description = "An application (and library) to convert quipper circuits into Qpmc models"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "entropy" = callPackage @@ -79345,6 +83406,8 @@ self: { ]; description = "entwine - Concurrency tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "enum-subset-generate" = callPackage @@ -79420,6 +83483,8 @@ self: { ]; description = "An experimental Utf8 parsing toolkit for enumerated types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "enumerable" = callPackage @@ -79450,6 +83515,7 @@ self: { executableHaskellDepends = [ base ]; description = "enumerate all the values in a finite type (automatically)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "enumerate-function" = callPackage @@ -79470,6 +83536,7 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "simple package for inverting functions and testing totality, via brute enumeration of the domain"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "enumeration" = callPackage @@ -79502,6 +83569,8 @@ self: { ]; description = "Reliable, high-performance processing with left-fold enumerators"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "enumerator-fd" = callPackage @@ -79513,6 +83582,7 @@ self: { libraryHaskellDepends = [ base enumerator mtl ]; description = "Enumerator instances for monads-fd classes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "enumerator-tf" = callPackage @@ -79524,6 +83594,7 @@ self: { libraryHaskellDepends = [ base enumerator monads-tf ]; description = "Enumerator instances for monads-tf classes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "enumfun" = callPackage @@ -79535,6 +83606,8 @@ self: { libraryHaskellDepends = [ base enummapset-th ]; description = "Finitely represented /total/ EnumMaps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "enummapmap" = callPackage @@ -79559,6 +83632,8 @@ self: { ]; description = "Map of maps using Enum types as keys"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "enummaps" = callPackage @@ -79662,6 +83737,8 @@ self: { ]; description = "Pull configuration information from the ENV"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "envelope" = callPackage @@ -79709,6 +83786,8 @@ self: { ]; description = "Display efficiently the state of the local environment"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "envy" = callPackage @@ -79758,6 +83837,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell binding for EPANET"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "epass" = callPackage @@ -79769,6 +83850,8 @@ self: { libraryHaskellDepends = [ base stm time ]; description = "Baisc, Erlang-like message passing supporting sockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ephemeral" = callPackage @@ -79791,6 +83874,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "epi-sim" = callPackage @@ -79826,6 +83910,8 @@ self: { ]; description = "Compiler for a simple functional language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "epoll" = callPackage @@ -79839,6 +83925,8 @@ self: { libraryHaskellDepends = [ base unix ]; description = "epoll bindings"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eprocess" = callPackage @@ -79851,6 +83939,8 @@ self: { libraryHaskellDepends = [ base exceptions mtl ]; description = "Basic Erlang-like process support for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "epub" = callPackage @@ -79928,6 +84018,8 @@ self: { ]; description = "Rename epub ebook files based on meta information"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eq" = callPackage @@ -79987,6 +84079,8 @@ self: { ]; description = "Proof assistant for Haskell using DataKinds & PolyKinds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "equeue" = callPackage @@ -80008,6 +84102,8 @@ self: { ]; description = "Application level triggered, and edge triggered event multiqueues"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "equivalence" = callPackage @@ -80073,6 +84169,7 @@ self: { libraryHaskellDepends = [ base polynomial ]; description = "Native Haskell implementation of the interface from the erf package"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "erlang" = callPackage @@ -80088,6 +84185,8 @@ self: { ]; description = "FFI interface to Erlang"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "erlang-ffi" = callPackage @@ -80107,6 +84206,8 @@ self: { ]; description = "Send messages to an Erlang node using Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eros" = callPackage @@ -80119,6 +84220,8 @@ self: { libraryHaskellDepends = [ aeson base bytestring containers text ]; description = "A text censorship library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eros-client" = callPackage @@ -80137,6 +84240,7 @@ self: { ]; description = "DEPRECATED in favor of eros-http"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "eros-http" = callPackage @@ -80156,6 +84260,7 @@ self: { ]; description = "JSON HTTP interface to Eros"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "errata" = callPackage @@ -80174,6 +84279,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Source code error pretty printing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "errno" = callPackage @@ -80231,6 +84338,8 @@ self: { ]; description = "Provides API for enriching errors with contexts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "error-continuations" = callPackage @@ -80242,6 +84351,8 @@ self: { libraryHaskellDepends = [ base either mtl transformers ]; description = "Error Continuations"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "error-list" = callPackage @@ -80253,6 +84364,8 @@ self: { libraryHaskellDepends = [ base mtl text text-render ]; description = "A useful type for collecting error messages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "error-loc" = callPackage @@ -80264,6 +84377,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "An error replacement with call-site metadata"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "error-location" = callPackage @@ -80290,6 +84405,7 @@ self: { ]; description = "Composable error messages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "error-or" = callPackage @@ -80323,6 +84439,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Set of utils and operators for error handling"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "errorcall-eq-instance" = callPackage @@ -80369,6 +84487,7 @@ self: { ]; description = "`bracket`-like functions for `ExceptT` over `IO` monad"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "ersaconcat" = callPackage @@ -80392,6 +84511,8 @@ self: { ]; description = "A script to concatenate AIP ERSA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ersatz" = callPackage @@ -80416,6 +84537,8 @@ self: { testHaskellDepends = [ array base ]; description = "A monad for expressing SAT or QSAT problems using observable sharing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ersatz-toysat" = callPackage @@ -80433,6 +84556,7 @@ self: { ]; description = "toysat driver as backend for ersatz"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ert" = callPackage @@ -80455,6 +84579,8 @@ self: { ]; description = "Easy Runtime Templates"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "escape-artist" = callPackage @@ -80471,6 +84597,8 @@ self: { ]; description = "ANSI Escape Sequence Text Decoration Made Easy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "escaped" = callPackage @@ -80518,6 +84646,8 @@ self: { doHaddock = false; description = "Terminal fuzzy selector"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "esotericbot" = callPackage @@ -80541,6 +84671,7 @@ self: { doHaddock = false; description = "Esotericbot is a sophisticated, lightweight IRC bot"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "espial" = callPackage @@ -80605,6 +84736,8 @@ self: { ]; description = "Espial is an open-source, web-based bookmarking server"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "esqueleto" = callPackage @@ -80677,6 +84810,8 @@ self: { libraryHaskellDepends = [ base ]; description = "The type-level S combinator in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "essence-of-live-coding" = callPackage @@ -80832,6 +84967,8 @@ self: { ]; description = "Tool for managing probability estimation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "estreps" = callPackage @@ -80848,6 +84985,7 @@ self: { ]; description = "Repeats from ESTs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "etc" = callPackage @@ -80900,6 +85038,8 @@ self: { ]; description = "everything breaking the Fairbairn threshold"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eternity" = callPackage @@ -80920,6 +85060,7 @@ self: { ]; description = "Native event-sourcing database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "eternity-timestamped" = callPackage @@ -80937,6 +85078,7 @@ self: { ]; description = "Automatic timestamping for Eternity"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ether" = callPackage @@ -80965,6 +85107,7 @@ self: { ]; description = "Monad transformers and classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ethereum-analyzer" = callPackage @@ -80988,6 +85131,7 @@ self: { ]; description = "A Ethereum contract analyzer"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "ethereum-analyzer-cli" = callPackage @@ -81015,6 +85159,7 @@ self: { ]; description = "A CLI frontend for ethereum-analyzer"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "ethereum-analyzer-deps" = callPackage @@ -81060,6 +85205,7 @@ self: { ]; description = "A web frontend for ethereum-analyzer"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "ethereum-client-haskell" = callPackage @@ -81088,6 +85234,7 @@ self: { ]; description = "A Haskell version of an Ethereum client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ethereum-merkle-patricia-db" = callPackage @@ -81112,6 +85259,7 @@ self: { ]; description = "A modified Merkle Patricia DB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ethereum-rlp" = callPackage @@ -81130,6 +85278,8 @@ self: { ]; description = "Ethereum Recursive Length Prefix Encoding"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eths-rlp" = callPackage @@ -81226,6 +85376,8 @@ self: { ]; description = "Dynamic network FRP with events and continuous values"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eurofxref" = callPackage @@ -81243,6 +85395,8 @@ self: { ]; description = "Free foreign exchange/currency feed from the European Central Bank"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "evdev" = callPackage @@ -81266,6 +85420,8 @@ self: { ]; description = "Bindings to libevdev"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libevdev;}; "evdev-streamly" = callPackage @@ -81284,6 +85440,7 @@ self: { ]; description = "Bridge for working with evdev and streamly"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "eve" = callPackage @@ -81318,6 +85475,8 @@ self: { ]; testHaskellDepends = [ base bytestring eve lens mtl text vty ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eveff" = callPackage @@ -81342,6 +85501,8 @@ self: { ]; description = "Monoidal, monadic and first-class events"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "event-driven" = callPackage @@ -81353,6 +85514,8 @@ self: { libraryHaskellDepends = [ base monads-tf yjtools ]; description = "library for event driven programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "event-handlers" = callPackage @@ -81399,6 +85562,7 @@ self: { ]; description = "Event-graph simulation monad transformer"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "event-transformer" = callPackage @@ -81459,6 +85623,8 @@ self: { ]; description = "Library for eventful DynamoDB event stores"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eventful-memory" = callPackage @@ -81500,6 +85666,7 @@ self: { ]; description = "Postgres implementations for eventful"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "eventful-sql-common" = callPackage @@ -81518,6 +85685,8 @@ self: { ]; description = "Common library for SQL event stores"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eventful-sqlite" = callPackage @@ -81540,6 +85709,7 @@ self: { ]; description = "SQLite implementations for eventful"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "eventful-test-helpers" = callPackage @@ -81578,6 +85748,8 @@ self: { executableHaskellDepends = [ aeson base filepath text ]; description = "Visualise an eventlog"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eventloop" = callPackage @@ -81596,6 +85768,8 @@ self: { ]; description = "A different take on an IO system. Based on Amanda's IO loop, this eventloop takes a function that maps input events to output events. It can easily be extended by modules that represent IO devices or join multiple modules together."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "eventsource-api" = callPackage @@ -81639,6 +85813,7 @@ self: { ]; description = "GetEventStore store implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "eventsource-store-specs" = callPackage @@ -81769,6 +85944,8 @@ self: { description = "EventStore TCP Client"; license = lib.licenses.bsd3; platforms = [ "x86_64-darwin" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "every" = callPackage @@ -81791,6 +85968,7 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "A functional pearl on encoding and decoding using question-and-answer strategies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ewe" = callPackage @@ -81810,6 +85988,8 @@ self: { executableToolDepends = [ alex happy uuagc ]; description = "An interpreter for EWE programming language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ex-pool" = callPackage @@ -81850,6 +86030,8 @@ self: { testHaskellDepends = [ base containers tasty tasty-hunit ]; description = "Efficient exact cover solver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exact-pi" = callPackage @@ -81899,6 +86081,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Framework for Exact Real Arithmetic in the Positional Number System"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "example-haskell-project" = callPackage @@ -81926,6 +86110,8 @@ self: { libraryHaskellDepends = [ base exceptions transformers ]; description = "Safely deal with exceptions in ExceptT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exception-hierarchy" = callPackage @@ -81963,6 +86149,7 @@ self: { ]; description = "Exception monad transformer instances for monads-fd classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "exception-monads-tf" = callPackage @@ -82030,6 +86217,8 @@ self: { libraryHaskellDepends = [ base exceptions ]; description = "Essentially the Maybe type with error messages"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exceptionfree-readfile" = callPackage @@ -82045,6 +86234,8 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "An exception-free readFile for use with '+RTS -xc -RTS' projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exceptions_0_10_4" = callPackage @@ -82096,6 +86287,8 @@ self: { ]; description = "A Haskell client for https://exchangeratesapi.io/"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "execs" = callPackage @@ -82110,6 +86303,8 @@ self: { executableHaskellDepends = [ base directory process text ]; description = "Tool to run stack exec prj-exe more easy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "executable-hash" = callPackage @@ -82157,6 +86352,8 @@ self: { testHaskellDepends = [ async base doctest hspec process ]; description = "Shell helpers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exference" = callPackage @@ -82187,6 +86384,7 @@ self: { ]; description = "Tool to search/generate (haskell) expressions with a given type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "exh" = callPackage @@ -82212,6 +86410,8 @@ self: { ]; description = "A library for crawling exhentai"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exhaustive" = callPackage @@ -82250,6 +86450,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Exheres generator for cabal packages"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exif" = callPackage @@ -82262,6 +86464,8 @@ self: { librarySystemDepends = [ exif ]; description = "A Haskell binding to a subset of libexif"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) exif;}; "exiftool" = callPackage @@ -82304,6 +86508,8 @@ self: { ]; description = "database schema for exigo marking/assessment tools"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exinst" = callPackage @@ -82393,6 +86599,8 @@ self: { libraryHaskellDepends = [ base constraints deepseq exinst ]; description = "Derive instances for the `deepseq` library for your existential types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exinst-hashable" = callPackage @@ -82406,6 +86614,8 @@ self: { ]; description = "Derive instances for the `hashable` library for your existential types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exinst-serialise" = callPackage @@ -82483,6 +86693,8 @@ self: { libraryHaskellDepends = [ base contravariant ]; description = "Existential datatypes holding evidence of constraints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exit-codes" = callPackage @@ -82514,6 +86726,8 @@ self: { ]; description = "Monad transformer for exit codes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exomizer" = callPackage @@ -82576,6 +86790,8 @@ self: { libraryHaskellDepends = [ base ]; description = "floating point with extended exponent range"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exp-pairs" = callPackage @@ -82613,6 +86829,7 @@ self: { ]; description = "Extensible Pandoc"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "expat-enumerator" = callPackage @@ -82628,6 +86845,7 @@ self: { ]; description = "Enumerator-based API for Expat"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "experimenter" = callPackage @@ -82701,6 +86919,7 @@ self: { ]; description = "Expiring containers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "expiring-mvar" = callPackage @@ -82727,6 +86946,8 @@ self: { ]; description = "Show how expressions are parsed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "explicit-constraint-lens" = callPackage @@ -82741,6 +86962,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Fully-flexible polymorphic lenses, without any bizarre profunctors"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "explicit-determinant" = callPackage @@ -82752,6 +86975,8 @@ self: { libraryHaskellDepends = [ base ]; description = "explicit computation of determinant of small matrices"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "explicit-exception" = callPackage @@ -82776,6 +87001,8 @@ self: { libraryHaskellDepends = [ base base-unicode-symbols tagged ]; description = "File handles with explicit IOModes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "explicit-iomodes-bytestring" = callPackage @@ -82787,6 +87014,7 @@ self: { libraryHaskellDepends = [ base bytestring explicit-iomodes ]; description = "Extends explicit-iomodes with ByteString operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "explicit-iomodes-text" = callPackage @@ -82798,6 +87026,7 @@ self: { libraryHaskellDepends = [ base explicit-iomodes text ]; description = "Extends explicit-iomodes with Text operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "explicit-sharing" = callPackage @@ -82811,6 +87040,7 @@ self: { ]; description = "Explicit Sharing of Monadic Effects"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "explore" = callPackage @@ -82824,6 +87054,7 @@ self: { executableHaskellDepends = [ array base directory pngload ]; description = "Experimental Plot data Reconstructor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "exploring-interpreters" = callPackage @@ -82855,6 +87086,8 @@ self: { ]; description = "A distribution of the 'containers' package, with all modules exposed"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "express" = callPackage @@ -82879,6 +87112,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Generalization of parsec's expression parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "expressions" = callPackage @@ -82896,6 +87131,8 @@ self: { testHaskellDepends = [ base singletons text ]; description = "Expressions and Formulae a la carte"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "expressions-z3" = callPackage @@ -82914,6 +87151,7 @@ self: { ]; description = "Encode and Decode expressions from Z3 ASTs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "expresso" = callPackage @@ -82942,6 +87180,8 @@ self: { ]; description = "A simple expressions language based on row types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extcore" = callPackage @@ -82959,6 +87199,8 @@ self: { ]; description = "Libraries for processing GHC Core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extemp" = callPackage @@ -82981,6 +87223,7 @@ self: { ]; description = "automated printing for extemp speakers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "extend-record-data-th" = callPackage @@ -83004,6 +87247,8 @@ self: { libraryHaskellDepends = [ base constraints ghc-prim tagged ]; description = "Extended Categories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extended-containers" = callPackage @@ -83081,6 +87326,7 @@ self: { ]; description = "Sums/products/lists/trees which can be extended in other modules"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "extensible-effects" = callPackage @@ -83140,6 +87386,8 @@ self: { ]; description = "Message passing concurrency as extensible-effect"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extensible-exceptions" = callPackage @@ -83169,6 +87417,8 @@ self: { testHaskellDepends = [ base extensible ]; description = "Operational-based extensible effect library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extensible-sp" = callPackage @@ -83220,6 +87470,8 @@ self: { ]; description = "Sort large arrays on your hard drive. Kind of like the unix util sort."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extra" = callPackage @@ -83258,6 +87510,7 @@ self: { ]; description = "Given a hackage package outputs the list of its dependencies"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "extractable-singleton" = callPackage @@ -83287,6 +87540,8 @@ self: { ]; description = "Extract an ELF's metadata and sections into files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extralife" = callPackage @@ -83302,6 +87557,8 @@ self: { ]; description = "API Client for ExtraLife team and user data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extrapolate" = callPackage @@ -83341,6 +87598,8 @@ self: { ]; description = "A high level static library for working with CouchDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ez3" = callPackage @@ -83354,6 +87613,8 @@ self: { libraryHaskellDepends = [ base transformers z3 ]; description = "Z3 bonds with pure interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "f-algebra-gen" = callPackage @@ -83365,6 +87626,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Generate a special f-algebra combinator from any data type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "f-ree-hack-cheats-free-v-bucks-generator" = callPackage @@ -83380,6 +87643,8 @@ self: { executableHaskellDepends = [ base ]; description = "Spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "faceted" = callPackage @@ -83391,6 +87656,8 @@ self: { libraryHaskellDepends = [ base free ]; description = "Faceted computation for dynamic information flow security"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "factor" = callPackage @@ -83452,6 +87719,8 @@ self: { libraryHaskellDepends = [ base exceptions mtl template-haskell ]; description = "Refined types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "factual-api" = callPackage @@ -83469,6 +87738,7 @@ self: { ]; description = "A driver for the Factual API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fad" = callPackage @@ -83516,6 +87786,7 @@ self: { ]; description = "Braid representations in Haskell"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "fadno-xml" = callPackage @@ -83563,6 +87834,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A list-like type for lazy streams, which might terminate with an error"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "failure" = callPackage @@ -83590,6 +87863,8 @@ self: { ]; description = "Failure Detectors implimented in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fair" = callPackage @@ -83647,6 +87922,8 @@ self: { librarySystemDepends = [ libXtst ]; description = "A crossplatform library to simulate keyboard input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs.xorg) libXtst;}; "fakedata" = callPackage @@ -83772,6 +88049,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Faktory Worker for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fallible" = callPackage @@ -83802,6 +88081,7 @@ self: { ]; description = "Falling sand game/cellular automata simulation using regular parallel arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fallingblocks" = callPackage @@ -83820,6 +88100,7 @@ self: { ]; description = "A fun falling blocks game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "familiar-reflection" = callPackage @@ -83847,6 +88128,7 @@ self: { ]; description = "A family tree library for the Haskell programming language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "farmhash" = callPackage @@ -83915,6 +88197,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Fast combinatorics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fast-digits" = callPackage @@ -83934,6 +88218,7 @@ self: { doHaddock = false; description = "Integer-to-digits conversion"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "fast-downward" = callPackage @@ -84002,6 +88287,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Natural Numbers with no overhead"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fast-tags" = callPackage @@ -84084,6 +88371,8 @@ self: { libraryHaskellDepends = [ base hmatrix vector ]; description = "Bayesian modeling algorithms accelerated for particular model structures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fastcgi" = callPackage @@ -84117,6 +88406,8 @@ self: { ]; description = "find nearest neighbours by edit-distance"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fastirc" = callPackage @@ -84133,6 +88424,7 @@ self: { ]; description = "Fast Internet Relay Chat (IRC) library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fastly" = callPackage @@ -84152,6 +88444,8 @@ self: { testHaskellDepends = [ base hspec text ]; description = "A highly experimental Fastly API client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fastparser" = callPackage @@ -84190,6 +88484,8 @@ self: { ]; description = "Haskell bindings to the fastpbkdf2 C library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openssl;}; "fastsum" = callPackage @@ -84223,6 +88519,8 @@ self: { ]; description = "Utilities for working with DuckDuckHack's FatHead Instant Answers"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fault-tree" = callPackage @@ -84234,6 +88532,7 @@ self: { libraryHaskellDepends = [ base yices ]; description = "A fault tree analysis library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fay" = callPackage @@ -84293,6 +88592,8 @@ self: { ]; description = "Compile Fay code on cabal install, and ad-hoc recompile during development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fay-dom" = callPackage @@ -84331,6 +88632,8 @@ self: { libraryHaskellDepends = [ fay-base fay-jquery ]; description = "Clientside HTML generation for fay"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fay-jquery" = callPackage @@ -84367,6 +88670,8 @@ self: { libraryHaskellDepends = [ fay-base ]; description = "SimpleJSON library for Fay"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fay-text" = callPackage @@ -84442,6 +88747,8 @@ self: { libraryHaskellDepends = [ base cereal fb persistent text time ]; description = "Provides Persistent instances to Facebook types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fbmessenger-api" = callPackage @@ -84470,6 +88777,8 @@ self: { testHaskellDepends = [ aeson base bytestring filepath hspec text ]; description = "High-level bindings to Facebook Messenger Platform API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fbrnch" = callPackage @@ -84499,6 +88808,7 @@ self: { doHaddock = false; description = "Build and create Fedora package repos and branches"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "fca" = callPackage @@ -84515,6 +88825,8 @@ self: { ]; description = "Algo for Formal Concept Analysis"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fcache" = callPackage @@ -84531,6 +88843,8 @@ self: { testHaskellDepends = [ base hspec mtl ]; description = "Cache a function (a -> b)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fcd" = callPackage @@ -84550,6 +88864,7 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "A faster way to navigate directories using the command line"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "fcf-containers" = callPackage @@ -84577,6 +88892,8 @@ self: { isExecutable = true; description = "TBA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fckeditor" = callPackage @@ -84588,6 +88905,8 @@ self: { libraryHaskellDepends = [ base cgi HaXml xhtml ]; description = "Server-Side Integration for FCKeditor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fclabels" = callPackage @@ -84618,6 +88937,8 @@ self: { libraryHaskellDepends = [ base fclabels monadLib ]; description = "MonadLib monadic interface for the \"fclabels\" package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fcm-client" = callPackage @@ -84649,6 +88970,8 @@ self: { ]; description = "Admin API for Firebase Cloud Messaging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fdo-notify" = callPackage @@ -84680,6 +89003,8 @@ self: { ]; description = "Utilities related to freedesktop Trash standard"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "feather" = callPackage @@ -84720,6 +89045,8 @@ self: { ]; description = "A minimally obtrusive feature flag library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "feature-flipper-postgres" = callPackage @@ -84741,6 +89068,7 @@ self: { ]; description = "A minimally obtrusive feature flag library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "fec" = callPackage @@ -84802,6 +89130,7 @@ self: { ]; description = "Fedora image download tool"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "fedora-packages" = callPackage @@ -84824,6 +89153,8 @@ self: { ]; description = "Haskell interface to the Fedora Packages webapp API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fee-estimate" = callPackage @@ -84881,6 +89212,8 @@ self: { ]; description = "A simple command line interface for creating and updating feeds like RSS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "feed-collect" = callPackage @@ -84898,6 +89231,8 @@ self: { ]; description = "Watch RSS/Atom feeds (and do with them whatever you like)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "feed-crawl" = callPackage @@ -84914,6 +89249,8 @@ self: { ]; description = "Utility for fetching feeds with redirect info and HTML link detection"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "feed-gipeda" = callPackage @@ -84952,6 +89289,7 @@ self: { ]; description = "CI service around gipeda"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "feed-translator" = callPackage @@ -84973,6 +89311,7 @@ self: { ]; description = "Translate syndication feeds"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "feed2lj" = callPackage @@ -84991,6 +89330,7 @@ self: { ]; description = "(unsupported)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "feed2twitter" = callPackage @@ -85007,6 +89347,7 @@ self: { ]; description = "Send posts from a feed to Twitter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fei-base" = callPackage @@ -85034,6 +89375,7 @@ self: { executableToolDepends = [ c2hs ]; description = "FFI to MXNet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) mxnet;}; "fei-cocoapi" = callPackage @@ -85061,6 +89403,7 @@ self: { ]; description = "Cocodataset with cocoapi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fei-dataiter" = callPackage @@ -85087,6 +89430,7 @@ self: { testHaskellDepends = [ base fei-base hspec streaming ]; description = "mxnet dataiters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) mxnet;}; "fei-datasets" = callPackage @@ -85116,6 +89460,7 @@ self: { ]; description = "Some datasets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fei-examples" = callPackage @@ -85136,6 +89481,7 @@ self: { ]; description = "fei examples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fei-modelzoo" = callPackage @@ -85152,6 +89498,7 @@ self: { ]; description = "A collection of standard models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fei-nn" = callPackage @@ -85173,6 +89520,7 @@ self: { ]; description = "Train a neural network with MXNet in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "feldspar-compiler" = callPackage @@ -85201,6 +89549,7 @@ self: { ]; description = "Compiler for the Feldspar language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {gcc_s = null;}; "feldspar-language" = callPackage @@ -85224,6 +89573,7 @@ self: { ]; description = "A functional embedded language for DSP and parallelism"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "feldspar-signal" = callPackage @@ -85296,6 +89646,8 @@ self: { executableSystemDepends = [ raptor ]; description = "Graph-based notetaking system"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {raptor = null;}; "fernet" = callPackage @@ -85321,6 +89673,8 @@ self: { ]; description = "Generate and verify HMAC-based authentication tokens"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "festung" = callPackage @@ -85351,6 +89705,7 @@ self: { ]; description = "Remote multi-db SQLCipher server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "fez-conf" = callPackage @@ -85362,6 +89717,8 @@ self: { libraryHaskellDepends = [ base containers regex-compat ]; description = "Simple functions for loading config files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ffeed" = callPackage @@ -85376,6 +89733,8 @@ self: { executableHaskellDepends = [ base pretty ]; description = "Haskell binding to the FriendFeed API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fficxx" = callPackage @@ -85397,6 +89756,8 @@ self: { ]; description = "automatic C++ binding generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fficxx-runtime" = callPackage @@ -85447,6 +89808,7 @@ self: { ]; description = "Tutorials on ffmpeg usage to play video/audio"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fft" = callPackage @@ -85495,6 +89857,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "FFunctor typeclass"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fgl" = callPackage @@ -85535,6 +89899,8 @@ self: { libraryHaskellDepends = [ base containers fgl ]; description = "Graph decomposition algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fgl-visualize" = callPackage @@ -85578,6 +89944,8 @@ self: { ]; description = "Tools for running and analyzing Haskell benchmarks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fibonacci" = callPackage @@ -85609,6 +89977,7 @@ self: { ]; description = "update statically hosted file in a push stule through socketed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "fields" = callPackage @@ -85624,6 +89993,7 @@ self: { ]; description = "First-class record field combinators with infix record field syntax"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fields-json" = callPackage @@ -85651,6 +90021,8 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Provides Fieldwise typeclass for operations of fields of records treated as independent components"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fig" = callPackage @@ -85662,6 +90034,8 @@ self: { libraryHaskellDepends = [ base containers parsec pretty ]; description = "Manipulation of FIG files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "file-collection" = callPackage @@ -85675,6 +90049,8 @@ self: { ]; description = "Provide a uniform interface over file archives and directories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "file-command-qq" = callPackage @@ -85690,6 +90066,8 @@ self: { ]; description = "Quasiquoter for system commands involving filepaths"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "file-embed" = callPackage @@ -85743,6 +90121,8 @@ self: { ]; description = "Use Template Haskell to embed file contents directly"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "file-location" = callPackage @@ -85760,6 +90140,8 @@ self: { testHaskellDepends = [ base lifted-base process ]; description = "common functions that show file location information"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "file-modules" = callPackage @@ -85857,6 +90239,8 @@ self: { ]; description = "Diffing and patching module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "filelock" = callPackage @@ -85895,6 +90279,8 @@ self: { libraryHaskellDepends = [ base hinotify stm ]; description = "Block thread until a file stops being modified"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "filepath_1_4_2_1" = callPackage @@ -85941,6 +90327,7 @@ self: { ]; description = "Reversable and secure encoding of object ids as filepaths"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "filepath-io-access" = callPackage @@ -85952,6 +90339,7 @@ self: { libraryHaskellDepends = [ base base-io-access filepath ]; description = "IO Access for filepath"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "filepather" = callPackage @@ -85968,6 +90356,7 @@ self: { ]; description = "Functions on System.FilePath"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "filepattern" = callPackage @@ -86033,6 +90422,8 @@ self: { ]; description = "A shared set of abstractions and types for representing filessytem data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "filesystem-conduit" = callPackage @@ -86054,6 +90445,8 @@ self: { ]; description = "Use system-filepath data types with conduits. (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "filesystem-enumerator" = callPackage @@ -86069,6 +90462,7 @@ self: { ]; description = "Enumerator-based API for manipulating the filesystem"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "filesystem-trees" = callPackage @@ -86085,6 +90479,8 @@ self: { ]; description = "Recursively manipulate and traverse filesystems as lazy rose trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fillit" = callPackage @@ -86101,6 +90497,8 @@ self: { testHaskellDepends = [ base doctest hspec unordered-containers ]; description = "Flexible string substitution"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "filter-logger" = callPackage @@ -86201,6 +90599,8 @@ self: { ]; description = "Extensible pretty printing with semantic annotations and proportional fonts"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "find-clumpiness" = callPackage @@ -86226,6 +90626,7 @@ self: { ]; description = "Find the clumpiness of labels in a tree"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "find-conduit" = callPackage @@ -86260,6 +90661,8 @@ self: { ]; description = "A file-finding conduit that allows user control over traversals"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "find-source-files" = callPackage @@ -86271,6 +90674,8 @@ self: { libraryHaskellDepends = [ base Cabal directory filepath mtl ]; description = "Initial project template from stack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "findhttp" = callPackage @@ -86289,6 +90694,7 @@ self: { ]; description = "List http/html files"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "fingertree" = callPackage @@ -86317,6 +90723,8 @@ self: { libraryHaskellDepends = [ base fingertree ]; description = "Implementation of priority search queues as finger trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fingertree-tf" = callPackage @@ -86328,6 +90736,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Generic finger-tree structure using type families"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "finitary" = callPackage @@ -86376,6 +90786,8 @@ self: { ]; description = "Flexible and easy deriving of type classes for finitary types"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "finitary-optics" = callPackage @@ -86540,6 +90952,8 @@ self: { ]; description = "A simple example using Firefly"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "first-and-last" = callPackage @@ -86552,6 +90966,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "First and Last generalized to return up to n values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "first-class-families" = callPackage @@ -86581,6 +90997,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "First class typeclass instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "first-class-patterns" = callPackage @@ -86609,6 +91027,7 @@ self: { ]; description = "Defunctionalisation for Yhc Core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fishfood" = callPackage @@ -86651,6 +91070,8 @@ self: { ]; description = "FIT file decoder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fits-parse" = callPackage @@ -86674,6 +91095,8 @@ self: { ]; description = "Parse FITS files"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fitsio" = callPackage @@ -86686,6 +91109,8 @@ self: { librarySystemDepends = [ cfitsio ]; description = "A library for reading and writing data files in the FITS data format"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) cfitsio;}; "fitspec" = callPackage @@ -86738,6 +91163,7 @@ self: { libraryHaskellDepends = [ base mmtl ]; description = "Simple fix-expression parser"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "fix-symbols-gitit" = callPackage @@ -86749,6 +91175,8 @@ self: { libraryHaskellDepends = [ base containers gitit ]; description = "Gitit plugin: Turn some Haskell symbols into pretty math symbols"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fix-whitespace" = callPackage @@ -86814,6 +91242,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Binary fixed-point arithmetic"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-point-vector" = callPackage @@ -86825,6 +91255,7 @@ self: { libraryHaskellDepends = [ base fixed-point vector ]; description = "Unbox instances for the fixed-point package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "fixed-point-vector-space" = callPackage @@ -86836,6 +91267,7 @@ self: { libraryHaskellDepends = [ base fixed-point vector-space ]; description = "vector-space instances for the fixed-point package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "fixed-precision" = callPackage @@ -86851,6 +91283,8 @@ self: { ]; description = "Fixed Precision Arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-storable-array" = callPackage @@ -86862,6 +91296,8 @@ self: { libraryHaskellDepends = [ array base tagged ]; description = "Fixed-size wrapper for StorableArray, providing a Storable instance. Deprecated - use storable-static-array instead."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-timestep" = callPackage @@ -86873,6 +91309,8 @@ self: { libraryHaskellDepends = [ async base clock time ]; description = "Pure Haskell library to repeat an action at a specific frequency"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-vector" = callPackage @@ -86901,6 +91339,8 @@ self: { ]; description = "Binary instances for fixed-vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-vector-cborg" = callPackage @@ -86917,6 +91357,8 @@ self: { ]; description = "Binary instances for fixed-vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-vector-cereal" = callPackage @@ -86933,6 +91375,8 @@ self: { ]; description = "Cereal instances for fixed-vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-vector-hetero" = callPackage @@ -86956,6 +91400,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Fixed width subsets of an Int64/Word64"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixedprec" = callPackage @@ -87011,6 +91457,8 @@ self: { ]; description = "A Haskell client for http://fixer.io/"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixfile" = callPackage @@ -87032,6 +91480,8 @@ self: { ]; description = "File-backed recursive data structures"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixhs" = callPackage @@ -87056,6 +91506,7 @@ self: { ]; description = "FIX (co)parser"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "fixie" = callPackage @@ -87077,6 +91528,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Opininated testing framework for mtl style (spies, stubs, and mocks)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixplate" = callPackage @@ -87137,6 +91590,8 @@ self: { libraryHaskellDepends = [ base ]; description = "test"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fizzbuzz-as-a-service" = callPackage @@ -87154,6 +91609,8 @@ self: { ]; description = "FizzBuzz as a service"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flac" = callPackage @@ -87180,6 +91637,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Complete high-level binding to libFLAC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {FLAC = null;}; "flac-picture" = callPackage @@ -87200,6 +91659,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Support for writing picture to FLAC metadata blocks with JuicyPixels"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "flaccuraterip" = callPackage @@ -87217,6 +91677,8 @@ self: { ]; description = "Verify FLAC files ripped form CD using AccurateRip™"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flags-applicative" = callPackage @@ -87244,6 +91706,8 @@ self: { libraryHaskellDepends = [ base template-haskell text ]; description = "A template engine for HTML"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flamingra" = callPackage @@ -87260,6 +91724,8 @@ self: { ]; description = "FlameGraphs of profiling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flashblast" = callPackage @@ -87304,6 +91770,7 @@ self: { ]; description = "Generate language learning flashcards from video"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "flat" = callPackage @@ -87342,6 +91809,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Strict Maybe without space and indirection overhead"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flat-mcmc" = callPackage @@ -87408,6 +91877,7 @@ self: { ]; description = "Haskell implementation of the FlatBuffers protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "flatparse" = callPackage @@ -87442,6 +91912,8 @@ self: { testHaskellDepends = [ base tasty tasty-quickcheck transformers ]; description = "Work generically on your datatype without knowing its shape nor its contents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flexible-defaults" = callPackage @@ -87468,6 +91940,8 @@ self: { libraryHaskellDepends = [ base bytestring unix-time ]; description = "simple extension of Data.UnixTime."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flexible-unlit" = callPackage @@ -87493,6 +91967,7 @@ self: { libraryHaskellDepends = [ base data-type mtl QuickCheck ]; description = "Flexible wrappers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "flexiwrap-smallcheck" = callPackage @@ -87506,6 +91981,7 @@ self: { ]; description = "SmallCheck (Serial) instances for flexiwrap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "flick-duration" = callPackage @@ -87536,6 +92012,8 @@ self: { executableHaskellDepends = [ xhtml ]; description = "Haskell binding to the Flickr API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flight-igc" = callPackage @@ -87570,6 +92048,8 @@ self: { ]; description = "Parsing of pilot tracklogs dumped as KML"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flink-statefulfun" = callPackage @@ -87591,6 +92071,8 @@ self: { libraryToolDepends = [ proto-lens-protoc ]; description = "Flink stateful functions SDK"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flip-cmd" = callPackage @@ -87633,6 +92115,7 @@ self: { ]; description = "f-lite compiler, interpreter and libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "flo" = callPackage @@ -87669,6 +92152,8 @@ self: { ]; description = "C99 printf \"%a\" style formatting and parsing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "float128" = callPackage @@ -87693,6 +92178,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Conversions between floating and integral values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "floatshow" = callPackage @@ -87779,6 +92266,8 @@ self: { testHaskellDepends = [ base doctest flow QuickCheck ]; description = "More directional operators"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flow2dot" = callPackage @@ -87816,6 +92305,8 @@ self: { ]; description = "Flowdock client library for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flowdock-api" = callPackage @@ -87852,6 +92343,7 @@ self: { ]; description = "API integration with Flowdock"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "flowdock-rest" = callPackage @@ -87879,6 +92371,8 @@ self: { ]; description = "Flowdock REST API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flower" = callPackage @@ -87896,6 +92390,7 @@ self: { ]; description = "Analyze 454 flowgrams (.SFF files)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "flowlocks-framework" = callPackage @@ -87908,6 +92403,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Generalized Flow Locks Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flowsim" = callPackage @@ -87926,6 +92423,7 @@ self: { ]; description = "Simulate 454 pyrosequencing"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "flp" = callPackage @@ -87958,6 +92456,8 @@ self: { testToolDepends = [ alex happy ]; description = "A layout spec language for memory managers implemented in Rust"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fltkhs" = callPackage @@ -87982,6 +92482,8 @@ self: { ]; description = "FLTK bindings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fltk14; inherit (pkgs) libGL; inherit (pkgs) libGLU; inherit (pkgs) pkg-config;}; @@ -88027,6 +92529,7 @@ self: { executableHaskellDepends = [ base bytestring fltkhs ]; description = "Fltkhs Fluid Examples"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "fltkhs-hello-world" = callPackage @@ -88084,6 +92587,7 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A structured logger for Fluentd (Haskell)"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "fluent-logger-conduit" = callPackage @@ -88135,6 +92639,8 @@ self: { ]; description = "The parser for fluffy to parsec the question bank in .docx type"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fluid-idl" = callPackage @@ -88200,6 +92706,8 @@ self: { librarySystemDepends = [ fluidsynth ]; description = "Haskell bindings to FluidSynth"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fluidsynth;}; "flush-queue" = callPackage @@ -88226,6 +92734,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A monoid for tracking changes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fmark" = callPackage @@ -88243,6 +92753,8 @@ self: { ]; description = "A Friendly Markup language without syntax"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fmlist" = callPackage @@ -88355,6 +92867,8 @@ self: { ]; description = "Extras for Fn, a functional web framework"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "focus" = callPackage @@ -88510,6 +93024,8 @@ self: { benchmarkHaskellDepends = [ base containers criterion foldl ]; description = "incremental folds"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foldl-statistics" = callPackage @@ -88534,6 +93050,8 @@ self: { ]; description = "Statistical functions from the statistics package implemented as Folds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foldl-transduce" = callPackage @@ -88560,6 +93078,8 @@ self: { ]; description = "Transducers for foldl folds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foldl-transduce-attoparsec" = callPackage @@ -88581,6 +93101,7 @@ self: { ]; description = "Attoparsec and foldl-transduce integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "folds" = callPackage @@ -88614,6 +93135,8 @@ self: { testHaskellDepends = [ base containers tasty tasty-quickcheck ]; description = "A playground of common folds for folds"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "folgerhs" = callPackage @@ -88660,6 +93183,8 @@ self: { ]; description = "Haskell library to follow content published on any subject"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "follow-file" = callPackage @@ -88702,6 +93227,7 @@ self: { ]; description = "Follow Tweets anonymously"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "foma" = callPackage @@ -88739,6 +93265,8 @@ self: { executableHaskellDepends = [ base GLFW-b OpenGL ]; description = "Basic4x6 font for OpenGL"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foo" = callPackage @@ -88754,6 +93282,7 @@ self: { ]; description = "Paper soccer, an OpenGL game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "foobar" = callPackage @@ -88785,6 +93314,8 @@ self: { ]; description = "Functor, Monad, MonadPlus, etc for free"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forbidden-fruit" = callPackage @@ -88805,6 +93336,8 @@ self: { ]; description = "A library accelerates imperative style programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "force-layout" = callPackage @@ -88834,6 +93367,8 @@ self: { executableHaskellDepends = [ base process transformers ]; description = "Run a command on files with magic substituion support (sequencing and regexp)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forecast-io" = callPackage @@ -88845,6 +93380,8 @@ self: { libraryHaskellDepends = [ aeson base text ]; description = "A Haskell library for working with forecast.io data."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foreign-storable-asymmetric" = callPackage @@ -88880,6 +93417,8 @@ self: { libraryHaskellDepends = [ base stm transformers ]; description = "Encapsulating mutatable state in external libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forest" = callPackage @@ -88895,6 +93434,8 @@ self: { ]; description = "Tree and Forest types"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forest-fire" = callPackage @@ -88916,6 +93457,8 @@ self: { ]; description = "Recursively delete CloudFormation stacks and their dependants"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forex2ledger" = callPackage @@ -88943,6 +93486,7 @@ self: { ]; description = "Print Forex quotes in Ledger format"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "forger" = callPackage @@ -88957,6 +93501,8 @@ self: { executableHaskellDepends = [ base ]; description = "Library for generating fake placeholder data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forkable-monad" = callPackage @@ -89008,6 +93554,7 @@ self: { ]; description = "A statically typed, functional programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "format" = callPackage @@ -89020,6 +93567,7 @@ self: { testHaskellDepends = [ haskell2010 parsec QuickCheck ]; description = "Rendering from and scanning to format strings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "format-numbers" = callPackage @@ -89049,6 +93597,7 @@ self: { ]; description = "A utility for writing the date to dzen2"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "formatn" = callPackage @@ -89066,6 +93615,8 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Number text formatting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "formattable" = callPackage @@ -89086,6 +93637,8 @@ self: { ]; description = "Business-quality formatting of numbers, dates, and other things"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "formatting" = callPackage @@ -89150,6 +93703,7 @@ self: { ]; description = "A statically typed, functional programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "formlets" = callPackage @@ -89166,6 +93720,7 @@ self: { ]; description = "Formlets implemented in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "formlets-hsp" = callPackage @@ -89182,6 +93737,7 @@ self: { libraryToolDepends = [ trhsx ]; description = "HSP support for Formlets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "formura" = callPackage @@ -89203,6 +93759,8 @@ self: { ]; description = "Formura is a simple language to describe stencil computation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forsyde-deep" = callPackage @@ -89230,6 +93788,8 @@ self: { ]; description = "ForSyDe's Haskell-embedded Domain Specific Language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forsyde-shallow" = callPackage @@ -89257,6 +93817,7 @@ self: { libraryHaskellDepends = [ array-forth base free mtl ]; description = "A simple eDSL for generating arrayForth code"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "fortran-src" = callPackage @@ -89286,6 +93847,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Parsers and analyses for Fortran standards 66, 77, 90 and 95"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fortran-src-extras" = callPackage @@ -89305,6 +93868,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Common functions and utils for fortran-src"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "fortytwo" = callPackage @@ -89319,6 +93883,8 @@ self: { testHaskellDepends = [ base doctest hspec ]; description = "Interactive terminal prompt"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forward-chan" = callPackage @@ -89349,6 +93915,7 @@ self: { ]; description = "Foscam File format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "foscam-filename" = callPackage @@ -89368,6 +93935,8 @@ self: { ]; description = "Foscam File format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foscam-sort" = callPackage @@ -89394,6 +93963,7 @@ self: { ]; description = "Foscam File format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "foundation" = callPackage @@ -89477,6 +94047,7 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "IEEE 754-2019 compliant operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fpco-api" = callPackage @@ -89513,6 +94084,8 @@ self: { ]; description = "Simple interface to the FP Complete IDE API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fpe" = callPackage @@ -89558,6 +94131,7 @@ self: { testHaskellDepends = [ base ]; description = "Haskell bindings to "; license = lib.licenses.lgpl21Plus; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) fplll;}; "fpnla" = callPackage @@ -89593,6 +94167,7 @@ self: { ]; description = "Example implementations for FPNLA library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fptest" = callPackage @@ -89618,6 +94193,8 @@ self: { ]; description = "IEEE754r floating point conformance tests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fquery" = callPackage @@ -89661,6 +94238,8 @@ self: { testHaskellDepends = [ base integer-gmp QuickCheck ]; description = "A collection of useful fractal curve encoders"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fraction" = callPackage @@ -89672,6 +94251,8 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "Fractions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "frag" = callPackage @@ -89686,6 +94267,8 @@ self: { executableHaskellDepends = [ array base GLUT OpenGL random ]; description = "A 3-D First Person Shooter Game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "frame" = callPackage @@ -89734,6 +94317,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A package for configuring and building Haskell software"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "franz" = callPackage @@ -89779,6 +94364,8 @@ self: { benchmarkHaskellDepends = [ base time ]; description = "Cached and parallel data fetching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freddy" = callPackage @@ -89798,6 +94385,8 @@ self: { ]; description = "RabbitMQ Messaging API supporting request-response"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free" = callPackage @@ -89896,6 +94485,8 @@ self: { libraryHaskellDepends = [ base type-aligned ]; description = "Free monads suitable for concurrent computation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free-er" = callPackage @@ -89948,6 +94539,8 @@ self: { ]; description = "Create games for free"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free-http" = callPackage @@ -89964,6 +94557,8 @@ self: { ]; description = "An HTTP Client based on Free Monads"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free-operational" = callPackage @@ -89979,6 +94574,8 @@ self: { ]; description = "Operational Applicative, Alternative, Monad and MonadPlus from free types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free-theorems" = callPackage @@ -89994,6 +94591,8 @@ self: { ]; description = "Automatic generation of free theorems"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free-theorems-counterexamples" = callPackage @@ -90012,6 +94611,7 @@ self: { executableHaskellDepends = [ cgi free-theorems utf8-string xhtml ]; description = "Automatically Generating Counterexamples to Naive Free Theorems"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "free-theorems-seq" = callPackage @@ -90029,6 +94629,7 @@ self: { ]; description = "Taming Selective Strictness"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "free-theorems-seq-webui" = callPackage @@ -90047,6 +94648,7 @@ self: { ]; description = "Taming Selective Strictness"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "free-theorems-webui" = callPackage @@ -90066,6 +94668,7 @@ self: { ]; description = "CGI-based web interface for the free-theorems package"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "free-v-bucks-generator-no-survey" = callPackage @@ -90081,6 +94684,8 @@ self: { executableHaskellDepends = [ base ]; description = "Spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free-v-bucks-generator-ps4-no-survey" = callPackage @@ -90096,6 +94701,8 @@ self: { executableHaskellDepends = [ base ]; description = "Spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "free-vector-spaces" = callPackage @@ -90151,6 +94758,7 @@ self: { ]; description = "A soccer game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "freelude" = callPackage @@ -90170,6 +94778,7 @@ self: { ]; description = "A generalisation of the Category->Functor->Applicative->Monad hierarchy and more"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "freenect" = callPackage @@ -90224,6 +94833,7 @@ self: { ]; description = "Handle effects conversely using monadic conversation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "freer-effects" = callPackage @@ -90244,6 +94854,8 @@ self: { benchmarkHaskellDepends = [ base criterion free mtl ]; description = "Implementation of effect system for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freer-indexed" = callPackage @@ -90294,6 +94906,8 @@ self: { testHaskellDepends = [ base freer-simple hspec ]; description = "Checked runtime exceptions with freer-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freer-simple-http" = callPackage @@ -90314,6 +94928,8 @@ self: { ]; description = "Make HTTP requests with freer-simple!"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freer-simple-profiling" = callPackage @@ -90326,6 +94942,8 @@ self: { testHaskellDepends = [ base containers freer-simple hspec time ]; description = "Automatic profling of freer-simple programs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freer-simple-random" = callPackage @@ -90338,6 +94956,8 @@ self: { testHaskellDepends = [ base containers freer-simple hspec random ]; description = "Random number generators using freer-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freer-simple-time" = callPackage @@ -90350,6 +94970,8 @@ self: { testHaskellDepends = [ base freer-simple hspec time ]; description = "freer-simple interface to IO based time functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freesect" = callPackage @@ -90367,6 +94989,8 @@ self: { ]; description = "A Haskell syntax extension for generalised sections"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freesound" = callPackage @@ -90388,6 +95012,8 @@ self: { ]; description = "Access the Freesound Project database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freetype-simple" = callPackage @@ -90402,6 +95028,8 @@ self: { ]; description = "Single line text rendering for OpenGL ES"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "freetype2" = callPackage @@ -90445,6 +95073,8 @@ self: { benchmarkHaskellDepends = [ base bytestring containers gauge ]; description = "Are you ready to get freaky?"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fresco-binding" = callPackage @@ -90472,6 +95102,8 @@ self: { libraryHaskellDepends = [ base containers haskell-src-exts syb ]; description = "Introduce fresh variables into Haskell source code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "friday" = callPackage @@ -90510,6 +95142,8 @@ self: { librarySystemDepends = [ libdevil ]; description = "Uses the DevIL C library to read and write images from and to files and memory buffers"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libdevil;}; "friday-juicypixels" = callPackage @@ -90541,6 +95175,8 @@ self: { ]; description = "Scale Friday images with DCT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "friendly" = callPackage @@ -90556,6 +95192,8 @@ self: { ]; description = "Attempt to pretty-print any input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "friendly-time" = callPackage @@ -90671,6 +95309,8 @@ self: { executableHaskellDepends = [ base directory ]; description = "LALR(k) parser generator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "frp-arduino" = callPackage @@ -90682,6 +95322,8 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Arduino programming without the hassle of C"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "frpnow" = callPackage @@ -90696,6 +95338,8 @@ self: { libraryHaskellDepends = [ base containers mtl transformers ]; description = "Principled practical FRP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "frpnow-gloss" = callPackage @@ -90711,6 +95355,7 @@ self: { ]; description = "Program awesome stuff with Gloss and frpnow!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "frpnow-gtk" = callPackage @@ -90727,6 +95372,7 @@ self: { ]; description = "Program GUIs with GTK and frpnow!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "frpnow-gtk3" = callPackage @@ -90740,6 +95386,7 @@ self: { ]; description = "Program GUIs with GTK3 and frpnow!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "frpnow-vty" = callPackage @@ -90754,6 +95401,7 @@ self: { executableHaskellDepends = [ base containers frpnow vty ]; description = "Program terminal applications with vty and frpnow!"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "frquotes" = callPackage @@ -90779,6 +95427,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A haskell binding to the FSEvents API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fsh-csv" = callPackage @@ -90790,6 +95440,8 @@ self: { libraryHaskellDepends = [ base hint ]; description = "csv parser for fsh"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fsharp" = callPackage @@ -90816,6 +95468,8 @@ self: { ]; description = "Finite state machines and FSM actions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fsnotify" = callPackage @@ -90877,6 +95531,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Finite state transducers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fsutils" = callPackage @@ -90888,6 +95544,8 @@ self: { libraryHaskellDepends = [ base directory filepath ]; description = "File system utilities for Haskell that are missing from built in libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fswait" = callPackage @@ -90907,6 +95565,8 @@ self: { ]; description = "Wait and observe events on the filesystem for a path, with a timeout"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fswatch" = callPackage @@ -90927,6 +95587,8 @@ self: { ]; description = "File System watching tool with cli and slave functionalities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fswatcher" = callPackage @@ -90958,6 +95620,8 @@ self: { executableHaskellDepends = [ base mtl parsec ]; description = "implementation accompanying a WFLP'19 paper"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ftdi" = callPackage @@ -90979,6 +95643,7 @@ self: { ]; description = "A thin layer over USB to communicate with FTDI chips"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ftp-client" = callPackage @@ -90996,6 +95661,8 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hspec ]; description = "Transfer files with FTP and FTPS"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ftp-client-conduit" = callPackage @@ -91012,6 +95679,7 @@ self: { testHaskellDepends = [ base ]; description = "Transfer file with FTP and FTPS with Conduit"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "ftp-conduit" = callPackage @@ -91028,6 +95696,8 @@ self: { ]; description = "FTP client package with conduit interface based off http-conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ftphs" = callPackage @@ -91045,6 +95715,8 @@ self: { ]; description = "FTP Client and Server Library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ftree" = callPackage @@ -91056,6 +95728,7 @@ self: { libraryHaskellDepends = [ base ShowF type-unary ]; description = "Depth-typed functor-based trees, both top-down and bottom-up"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ftshell" = callPackage @@ -91074,6 +95747,7 @@ self: { ]; description = "Shell interface to the FreeTheorems library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "fugue" = callPackage @@ -91096,6 +95770,8 @@ self: { libraryHaskellDepends = [ base ghc network ]; description = "a monad for protocol-typed network programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "full-text-search" = callPackage @@ -91163,6 +95839,7 @@ self: { ]; description = "IRC bot for fun, learning, creativity and collaboration"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "funbot-client" = callPackage @@ -91181,6 +95858,8 @@ self: { ]; description = "Report events to FunBot over a JSON/HTTP API"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "funbot-ext-events" = callPackage @@ -91211,6 +95890,7 @@ self: { ]; description = "Git hook which sends events to FunBot"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "funcmp" = callPackage @@ -91262,6 +95942,7 @@ self: { ]; description = "call-by-value lambda-calculus with meta-programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "funcons-simple" = callPackage @@ -91277,6 +95958,7 @@ self: { executableHaskellDepends = [ base funcons-tools funcons-values ]; description = "A modular interpreter for executing SIMPLE funcons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "funcons-tools" = callPackage @@ -91303,6 +95985,7 @@ self: { ]; description = "A modular interpreter for executing funcons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "funcons-values" = callPackage @@ -91318,6 +96001,8 @@ self: { ]; description = "Library providing values and operations on values in a fixed universe"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "function-builder" = callPackage @@ -91341,6 +96026,7 @@ self: { libraryHaskellDepends = [ base data-type ]; description = "Combining functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "function-instances-algebra" = callPackage @@ -91352,6 +96038,8 @@ self: { libraryHaskellDepends = [ base numeric-prelude ]; description = "Instances of the Algebra.* classes for functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functional-arrow" = callPackage @@ -91363,6 +96051,7 @@ self: { libraryHaskellDepends = [ base HList ]; description = "Combinators that allow for a more functional/monadic style of Arrow programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "functional-kmp" = callPackage @@ -91387,6 +96076,8 @@ self: { libraryHaskellDepends = [ base category ]; description = "Functors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functor-apply" = callPackage @@ -91440,6 +96131,8 @@ self: { ]; description = "Tools for functor combinator-based program design"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functor-combo" = callPackage @@ -91456,6 +96149,7 @@ self: { ]; description = "Functor combinators with tries & zippers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "functor-friends" = callPackage @@ -91467,6 +96161,8 @@ self: { libraryHaskellDepends = [ base recursion-schemes ]; description = "Friendly helpers for your recursion schemes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functor-infix" = callPackage @@ -91480,6 +96176,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Infix operators for mapping over compositions of functors. Lots of them."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functor-monadic" = callPackage @@ -91502,6 +96200,8 @@ self: { libraryHaskellDepends = [ base microlens singletons text vinyl ]; description = "General functor products for various Foldable instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functor-utils" = callPackage @@ -91513,6 +96213,8 @@ self: { libraryHaskellDepends = [ base ghc-prim lens ]; description = "Collection of functor utilities, providing handy operators, like generalization of (.)."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functorm" = callPackage @@ -91524,6 +96226,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Data.FunctorM (compatibility package)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "functors" = callPackage @@ -91574,6 +96278,8 @@ self: { ]; description = "Workflows with arrows"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "funflow-nix" = callPackage @@ -91595,6 +96301,7 @@ self: { ]; description = "Utility functions for using funflow with nix"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fungll-combinators" = callPackage @@ -91628,6 +96335,7 @@ self: { ]; description = "A unioning file-system using HFuse"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "funnyprint" = callPackage @@ -91643,6 +96351,7 @@ self: { benchmarkHaskellDepends = [ base criterion hscolour ipprint ]; description = "funnyPrint function to colorize GHCi output"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "funpat" = callPackage @@ -91654,6 +96363,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A generalization of pattern matching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "funsat" = callPackage @@ -91675,6 +96386,7 @@ self: { ]; description = "A modern DPLL-style SAT solver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "funspection" = callPackage @@ -91686,6 +96398,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Type-level function utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fused-effects" = callPackage @@ -91722,6 +96436,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Handle exceptions thrown in IO with fused-effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fused-effects-lens" = callPackage @@ -91806,6 +96522,8 @@ self: { ]; description = "Resumable exceptions for the fused-effects ecosystem"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fused-effects-squeal" = callPackage @@ -91822,6 +96540,7 @@ self: { ]; description = "A fused-effects adapter for squeal-postgresql"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fused-effects-th" = callPackage @@ -91852,6 +96571,8 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Effectful streaming library based on shortcut fusion techniques"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fusion-plugin" = callPackage @@ -91947,6 +96668,8 @@ self: { executableHaskellDepends = [ base bytestring network unix ]; description = "Simple IP-over-UDP tunnel using TUNTAP"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "future" = callPackage @@ -91958,6 +96681,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Supposed to mimics and enhance proposed C++ \"future\" features"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "future-resource" = callPackage @@ -92099,6 +96824,8 @@ self: { ]; description = "Translates high-level definitions of \"fuzzily\" scheduled objects (e.g. play this commercial 10 times per hour between 9:00-13:00) to a list of accurately scheduled objects using glpk-hs."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fuzzyfind" = callPackage @@ -92182,6 +96909,8 @@ self: { ]; description = "Game engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fwgl-glfw" = callPackage @@ -92198,6 +96927,7 @@ self: { ]; description = "FWGL GLFW backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fwgl-javascript" = callPackage @@ -92213,6 +96943,7 @@ self: { ]; description = "FWGL GHCJS backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fx" = callPackage @@ -92235,6 +96966,7 @@ self: { libraryHaskellDepends = [ base bytestring serialport ]; description = "Interface to the FXPak/FXPak Pro USB interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "g-npm" = callPackage @@ -92248,6 +96980,8 @@ self: { executableHaskellDepends = [ base HTTP json ]; description = "Generate Gentoo ebuilds from NodeJS/npm packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "g2" = callPackage @@ -92280,6 +97014,7 @@ self: { ]; description = "Haskell symbolic execution engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "g2q" = callPackage @@ -92291,6 +97026,7 @@ self: { libraryHaskellDepends = [ base g2 ]; description = "G2Q allows constraint programming, via writing Haskell predicates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "g4ip" = callPackage @@ -92303,6 +97039,8 @@ self: { testHaskellDepends = [ base ]; description = "A theorem prover for propositional logic that uses G4ip"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "g4ip-prover" = callPackage @@ -92337,6 +97075,7 @@ self: { ]; description = "General Alignment Clustering Tool"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "galois-fft" = callPackage @@ -92363,6 +97102,7 @@ self: { ]; description = "FFTs over finite fields"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "galois-field" = callPackage @@ -92388,6 +97128,8 @@ self: { ]; description = "Galois field library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "game-of-life" = callPackage @@ -92413,6 +97155,8 @@ self: { libraryHaskellDepends = [ base containers probability random ]; description = "Simple probability library for dice rolls, card games and similar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "game-tree" = callPackage @@ -92437,6 +97181,8 @@ self: { executableHaskellDepends = [ base cairo containers glib gtk time ]; description = "Game clock that shows two analog clock faces"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gamgee" = callPackage @@ -92467,6 +97213,8 @@ self: { ]; description = "Tool for generating TOTP MFA tokens"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gamma" = callPackage @@ -92487,6 +97235,8 @@ self: { ]; description = "Gamma function and related functions"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gang-of-threads" = callPackage @@ -92512,6 +97262,8 @@ self: { executableHaskellDepends = [ base haskeline transformers ]; description = "reverse prefix notation calculator and calculation library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "garfield" = callPackage @@ -92578,6 +97330,7 @@ self: { ]; description = "Connect to gargoyle-managed postgresql instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gargoyle-postgresql-nix" = callPackage @@ -92598,6 +97351,8 @@ self: { ]; description = "Manage PostgreSQL servers with gargoyle and nix"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "garlic-bread" = callPackage @@ -92632,6 +97387,8 @@ self: { libraryHaskellDepends = [ base free transformers ]; description = "Limit how many steps a program may take"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gasp" = callPackage @@ -92654,6 +97411,8 @@ self: { libraryHaskellDepends = [ base ]; description = "An applicative for parsing unordered things, heterogenous sorting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gauge" = callPackage @@ -92688,6 +97447,7 @@ self: { ]; description = "planar graph embedding into a plane"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gc" = callPackage @@ -92717,6 +97477,8 @@ self: { ]; description = "a wai application to show GHC.GCStats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gcodehs" = callPackage @@ -92763,6 +97525,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GNOME configuration database system"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs.gnome2) GConf;}; "gd" = callPackage @@ -92816,6 +97580,7 @@ self: { ]; description = "API Wrapping for Coinbase's GDAX exchange"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gdelt" = callPackage @@ -92856,6 +97621,7 @@ self: { ]; description = "Generic diff for the instant-generics library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gdiff-th" = callPackage @@ -92874,6 +97640,8 @@ self: { ]; description = "Generate gdiff GADTs and Instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gdo" = callPackage @@ -92936,6 +97704,7 @@ self: { testHaskellDepends = [ base hspec megaparsec text-all ]; description = "Parser for the GEDCOM genealogy file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "geek" = callPackage @@ -92956,6 +97725,7 @@ self: { ]; description = "Geek blog engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "geek-server" = callPackage @@ -92979,6 +97749,7 @@ self: { ]; description = "Geek blog engine server"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "gegl" = callPackage @@ -92999,6 +97770,8 @@ self: { libraryPkgconfigDepends = [ gegl ]; description = "Haskell bindings to GEGL library"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gegl;}; "gelatin" = callPackage @@ -93017,6 +97790,8 @@ self: { executableHaskellDepends = [ base linear mtl vector ]; description = "A graphics description language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gelatin-freetype2" = callPackage @@ -93034,6 +97809,7 @@ self: { testHaskellDepends = [ base ]; description = "FreeType2 based text rendering for the gelatin realtime rendering system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gelatin-fruity" = callPackage @@ -93045,6 +97821,7 @@ self: { libraryHaskellDepends = [ base FontyFruity gelatin linear vector ]; description = "Gelatin's support for rendering TTF outlines, using FontyFruity"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gelatin-gl" = callPackage @@ -93066,6 +97843,7 @@ self: { executableHaskellDepends = [ base gelatin lens linear mtl vector ]; description = "OpenGL rendering routines for the gelatin-picture graphics EDSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gelatin-sdl2" = callPackage @@ -93083,6 +97861,7 @@ self: { executableHaskellDepends = [ base either filepath sdl2 ]; description = "An SDL2 backend for the gelatin renderer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gelatin-shaders" = callPackage @@ -93095,6 +97874,7 @@ self: { libraryHaskellDepends = [ base bytestring filepath gelatin ]; description = "Gelatin's OpenGL shaders"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gemini-router" = callPackage @@ -93165,6 +97945,8 @@ self: { ]; description = "A simple library of helpers for SDL+GL games"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gen-imports" = callPackage @@ -93180,6 +97962,8 @@ self: { ]; description = "Code to generate instances for the package \"ghc-instances\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gen-passwd" = callPackage @@ -93197,6 +97981,8 @@ self: { ]; description = "Create wordlist-based passwords easily"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gencheck" = callPackage @@ -93213,6 +97999,8 @@ self: { ]; description = "A testing framework inspired by QuickCheck and SmallCheck"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gender" = callPackage @@ -93228,6 +98016,8 @@ self: { executableHaskellDepends = [ attoparsec base text ]; description = "Identify a persons gender by their first name"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "genders" = callPackage @@ -93243,6 +98033,8 @@ self: { testHaskellDepends = [ base bytestring hspec network vector ]; description = "Bindings to libgenders"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {genders = null;}; "gendocs" = callPackage @@ -93288,6 +98080,8 @@ self: { ]; description = "Prelude replacement using generalized type classes where possible"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generator" = callPackage @@ -93299,6 +98093,8 @@ self: { libraryHaskellDepends = [ base List transformers ]; description = "Python-generators notation for creation of monadic lists"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generators" = callPackage @@ -93310,6 +98106,8 @@ self: { libraryHaskellDepends = [ base mtl random ]; description = "Actually useful monadic random value generators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-accessors" = callPackage @@ -93329,6 +98127,8 @@ self: { ]; description = "stringly-named getters for generic data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-aeson" = callPackage @@ -93367,6 +98167,8 @@ self: { libraryHaskellDepends = [ base binary bytestring ghc-prim ]; description = "Generic Data.Binary derivation using GHC generics."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-church" = callPackage @@ -93382,6 +98184,8 @@ self: { ]; description = "Automatically convert Generic instances to and from church representations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-constraints" = callPackage @@ -93500,6 +98304,8 @@ self: { testHaskellDepends = [ array base bytestring hspec ]; description = "An Enum class that fixes some deficiences with Prelude's Enum"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-enumeration" = callPackage @@ -93511,6 +98317,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Generically derived enumerations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-env" = callPackage @@ -93551,6 +98359,8 @@ self: { testHaskellDepends = [ base Cabal inspection-testing ]; description = "Generically extract and replace collections of record fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-lens" = callPackage @@ -93591,6 +98401,8 @@ self: { libraryHaskellDepends = [ base generic-lens ]; description = "GHC.OverloadedLabels.IsLabel instance for lenses from ghc-generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-lens-lite" = callPackage @@ -93616,6 +98428,8 @@ self: { libraryHaskellDepends = [ base lucid text ]; description = "General-purpose web page scaffold for Lucid"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-match" = callPackage @@ -93648,6 +98462,8 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "A generic version of Data.Maybe"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-monoid" = callPackage @@ -93677,6 +98493,8 @@ self: { ]; description = "Generically derive traversals, lenses and prisms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-optics-lite" = callPackage @@ -93714,6 +98532,8 @@ self: { testHaskellDepends = [ aeson base generic-override hspec text ]; description = "Provides orphan instances necessary for integrating generic-override and aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-pretty" = callPackage @@ -93732,6 +98552,8 @@ self: { ]; description = "Pretty printing for Generic value"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-random" = callPackage @@ -93768,6 +98590,8 @@ self: { libraryHaskellDepends = [ base bytestring network ]; description = "Simple generic TCP/IP server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-storable" = callPackage @@ -93780,6 +98604,8 @@ self: { testHaskellDepends = [ base ghc-prim hspec QuickCheck ]; description = "Generic implementation of Storable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-tree" = callPackage @@ -93791,6 +98617,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Generic Tree data type"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-trie" = callPackage @@ -93804,6 +98632,8 @@ self: { libraryHaskellDepends = [ base containers transformers ]; description = "A map, where the keys may be complex structured data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-xml" = callPackage @@ -93818,6 +98648,8 @@ self: { ]; description = "Marshalling Haskell values to/from XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-xmlpickler" = callPackage @@ -93832,6 +98664,8 @@ self: { testHaskellDepends = [ base hxt tasty tasty-hunit tasty-th ]; description = "Generic generation of HXT XmlPickler instances using GHC Generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generics-eot" = callPackage @@ -93864,6 +98698,8 @@ self: { ]; description = "Generic Programming with Mutually Recursive Sums of Products"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generics-mrsop-gdiff" = callPackage @@ -93875,6 +98711,7 @@ self: { libraryHaskellDepends = [ base generics-mrsop ]; description = "Reimplementation of the gdiff algorithm for generics-mrsop"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "generics-sop" = callPackage @@ -93919,6 +98756,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Serialization library using Data.Generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "genesis" = callPackage @@ -93946,6 +98785,7 @@ self: { ]; description = "Opinionated bootstrapping for Haskell web services"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "genesis-test" = callPackage @@ -93969,6 +98809,7 @@ self: { ]; description = "Opinionated bootstrapping for Haskell web services"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "genetics" = callPackage @@ -93982,6 +98823,8 @@ self: { executableHaskellDepends = [ base random-fu ]; description = "A Genetic Algorithm library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "geni-gui" = callPackage @@ -94005,6 +98848,7 @@ self: { executableHaskellDepends = [ base GenI ]; description = "GenI graphical user interface"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "geni-util" = callPackage @@ -94047,6 +98891,7 @@ self: { ]; description = "Conversion utility for the GenI generator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "genifunctors" = callPackage @@ -94070,6 +98915,8 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Use Template Haskell to generate Uniplate-like functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "geniplate-mirror" = callPackage @@ -94113,6 +98960,8 @@ self: { libraryHaskellDepends = [ base MonadRandom syb syz ]; description = "Genetic programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gentlemark" = callPackage @@ -94125,6 +98974,8 @@ self: { testHaskellDepends = [ base HUnit parsec transformers ]; description = "Gentle markup language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "genvalidity" = callPackage @@ -94464,6 +99315,8 @@ self: { ]; description = "GenValidity support for Persistent"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "genvalidity-property" = callPackage @@ -94749,6 +99602,8 @@ self: { ]; description = "Performs geo location lookups and parses the results"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "geo-uk" = callPackage @@ -94807,6 +99662,7 @@ self: { ]; description = "Geodetic calculations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "geodetic-types" = callPackage @@ -94818,6 +99674,8 @@ self: { libraryHaskellDepends = [ base dimensional lens semigroups ]; description = "Types for geodetic operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "geodetics" = callPackage @@ -94896,6 +99754,7 @@ self: { libraryHaskellDepends = [ aeson base bson bytestring lens text ]; description = "GeoJSON data types including JSON/BSON conversion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "geolite-csv" = callPackage @@ -94914,6 +99773,7 @@ self: { ]; description = "Geolite CSV Parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "geom2d" = callPackage @@ -94926,6 +99786,8 @@ self: { testHaskellDepends = [ base ieee754 linear QuickCheck ]; description = "package for geometry in euklidean 2d space"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "geos" = callPackage @@ -94946,6 +99808,8 @@ self: { testSystemDepends = [ geos ]; description = "Bindings for GEOS"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) geos;}; "getemx" = callPackage @@ -94964,6 +99828,7 @@ self: { ]; description = "Fetch from emusic using .emx files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "getflag" = callPackage @@ -94975,6 +99840,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Command-line parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "getopt-generics" = callPackage @@ -95054,6 +99921,8 @@ self: { executableHaskellDepends = [ base containers parsec ]; description = "A type checker and runtime system of rCOS/g (impl. of ggts-FCS)."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gh-labeler" = callPackage @@ -95071,6 +99940,8 @@ self: { ]; description = "Github Standard Labeler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gh-pocket-knife" = callPackage @@ -95220,6 +100091,8 @@ self: { ]; description = "Override GHC error messages to the user's liking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-compact_0_1_0_0" = callPackage @@ -95281,6 +100154,8 @@ self: { testHaskellDepends = [ base ghc ghc-paths ]; description = "A small-step semantics for Core"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-datasize" = callPackage @@ -95294,6 +100169,8 @@ self: { ]; description = "Determine the size of data structures in GHC's memory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-dump-core" = callPackage @@ -95333,6 +100210,8 @@ self: { ]; description = "Dump GHC's parsed, renamed, and type checked ASTs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-dump-util" = callPackage @@ -95366,6 +100245,8 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Explicitly prevent sharing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-events" = callPackage @@ -95408,6 +100289,8 @@ self: { ]; description = "Analyze and visualize event logs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-events-parallel" = callPackage @@ -95431,6 +100314,8 @@ self: { ]; description = "Library and tool for parsing .eventlog files from parallel GHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-exactprint" = callPackage @@ -95478,6 +100363,8 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Derived instances of GHC.Generic of the GHC AST"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-heap_9_0_1" = callPackage @@ -95557,6 +100444,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Find the Haddock documentation for a symbol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ghc-instances" = callPackage @@ -95578,6 +100466,7 @@ self: { ]; description = "Easily import all instances contained in GHC distributed libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ghc-justdoit" = callPackage @@ -95590,6 +100479,8 @@ self: { testHaskellDepends = [ base inspection-testing ]; description = "A magic typeclass that just does it"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-lib" = callPackage @@ -95738,6 +100629,8 @@ self: { executableHaskellDepends = [ base parsec process ]; description = "Generate a bash completion from the GHC manpage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-mod" = callPackage @@ -95784,6 +100677,7 @@ self: { ]; description = "Happy Haskell Hacking"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "ghc-mtl" = callPackage @@ -95847,6 +100741,8 @@ self: { ]; description = "A parallel wrapper for 'ghc --make'"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-parser" = callPackage @@ -95890,6 +100786,8 @@ self: { ]; description = "Simple utility to fix BROKEN package dependencies for cabal-install"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-pkg-lib" = callPackage @@ -95904,6 +100802,8 @@ self: { ]; description = "Provide library support for ghc-pkg information"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-plugs-out" = callPackage @@ -95919,6 +100819,8 @@ self: { doHaddock = false; description = "Type checker plugins without the type checking"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-prim_0_7_0" = callPackage @@ -96012,6 +100914,8 @@ self: { testHaskellDepends = [ base transformers ]; description = "GHC plugin to prove program equations by simplification"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-server" = callPackage @@ -96042,6 +100946,8 @@ self: { executableHaskellDepends = [ base transformers ]; description = "Simplified GHC API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-simple" = callPackage @@ -96057,6 +100963,8 @@ self: { ]; description = "Simplified interface to the GHC API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-source-gen" = callPackage @@ -96084,6 +100992,8 @@ self: { libraryHaskellDepends = [ array base containers ghc hpc ]; description = "Generic GHC Plugin for annotating Haskell code with source location data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-syb" = callPackage @@ -96095,6 +101005,8 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Data and Typeable instances for the GHC API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-syb-utils" = callPackage @@ -96106,6 +101018,8 @@ self: { libraryHaskellDepends = [ base bytestring ghc syb ]; description = "Scrap Your Boilerplate utilities for the GHC API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-syntax-highlighter" = callPackage @@ -96166,6 +101080,8 @@ self: { ]; description = "a library to work with tags created from Haskell parsed tree"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-tags-plugin" = callPackage @@ -96187,6 +101103,7 @@ self: { ]; description = "A compiler plugin which generates tags file from GHC parsed syntax tree"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "ghc-tcplugins-extra_0_3_2" = callPackage @@ -96229,6 +101146,8 @@ self: { ]; description = "Library for parsing GHC time and allocation profiling reports"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-timers" = callPackage @@ -96350,6 +101269,8 @@ self: { executableHaskellDepends = [ base ghc-paths unix ]; description = "Print minimal export lists"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-vis" = callPackage @@ -96369,6 +101290,7 @@ self: { ]; description = "Live visualization of data structures in GHCi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ghcflags" = callPackage @@ -96435,6 +101357,8 @@ self: { libraryHaskellDepends = [ base cairo colour diagrams gtk ]; description = "Display simple diagrams from ghci"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghci-haskeline" = callPackage @@ -96453,6 +101377,8 @@ self: { ]; description = "An implementation of ghci using the Haskeline line-input library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghci-hexcalc" = callPackage @@ -96477,6 +101403,8 @@ self: { testHaskellDepends = [ base doctest hspec parsec ]; description = "parse output of ghci \":history\" command"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghci-lib" = callPackage @@ -96488,6 +101416,8 @@ self: { libraryHaskellDepends = [ base ghc MissingH ]; description = "A library for interactively evaluating Haskell code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghci-ng" = callPackage @@ -96509,6 +101439,8 @@ self: { ]; description = "Next generation GHCi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghci-pretty" = callPackage @@ -96520,6 +101452,7 @@ self: { libraryHaskellDepends = [ base hscolour ipprint ]; description = "colored pretty-printing within ghci"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ghci-websockets" = callPackage @@ -96755,6 +101688,8 @@ self: { sha256 = "02m0qszdl3kxyhjrzj1ph9gwbr9jkzak2v1b47v6ywsm7hmjgn7w"; description = "DOM library using JSFFI and GHCJS"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghcjs-dom-webkit" = callPackage @@ -96787,6 +101722,8 @@ self: { ]; description = "GHCJS bindings for the JavaScript Fetch API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghcjs-hplay" = callPackage @@ -96803,6 +101740,7 @@ self: { ]; description = "Client-side web EDSL for transient nodes running in the web browser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ghcjs-perch" = callPackage @@ -96825,6 +101763,8 @@ self: { libraryHaskellDepends = [ base ghcjs-base protolude ]; description = "Bidirectional bidings to javascript's promise"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghcjs-vdom" = callPackage @@ -96873,6 +101813,8 @@ self: { libraryHaskellDepends = [ base ghcjs-base text ]; description = "XmlHttpRequest (\"AJAX\") bindings for GHCJS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghclive" = callPackage @@ -96899,6 +101841,8 @@ self: { ]; description = "Interactive Haskell interpreter in a browser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghcprofview" = callPackage @@ -96917,6 +101861,8 @@ self: { ]; description = "GHC .prof files viewer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghcup" = callPackage @@ -96970,6 +101916,7 @@ self: { ]; description = "ghc toolchain installer"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "ghczdecode" = callPackage @@ -97018,6 +101965,7 @@ self: { ]; description = "Trivial routines for inspecting git repositories"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "gi-atk" = callPackage @@ -97119,6 +102067,7 @@ self: { ]; description = "Bridge between packages gi-* and cairo-core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gi-cairo-connector" = callPackage @@ -97634,6 +102583,8 @@ self: { libraryPkgconfigDepends = [ graphene-gobject ]; description = "Graphene bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {graphene-gobject = null;}; "gi-graphene_1_0_3" = callPackage @@ -97654,6 +102605,7 @@ self: { description = "Graphene bindings"; license = lib.licenses.lgpl21Only; hydraPlatforms = lib.platforms.none; + broken = true; }) {graphene-gobject = null;}; "gi-gsk" = callPackage @@ -97678,6 +102630,7 @@ self: { libraryPkgconfigDepends = [ gtk4 ]; description = "Gsk bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gtk4;}; "gi-gst" = callPackage @@ -97763,6 +102716,7 @@ self: { libraryPkgconfigDepends = [ gstreamer-pbutils ]; description = "GStreamer Plugins Base Utils bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {gstreamer-pbutils = null;}; "gi-gsttag" = callPackage @@ -97784,6 +102738,8 @@ self: { libraryPkgconfigDepends = [ gstreamer-tag ]; description = "GStreamer Tag bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gstreamer-tag = null;}; "gi-gstvideo" = callPackage @@ -97980,6 +102936,8 @@ self: { libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ]; description = "GtkosxApplication bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gtk-mac-integration-gtk3 = null;}; "gi-gtksheet" = callPackage @@ -98004,6 +102962,8 @@ self: { libraryPkgconfigDepends = [ gtksheet ]; description = "GtkSheet bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gtksheet = null;}; "gi-gtksource" = callPackage @@ -98052,6 +103012,8 @@ self: { libraryPkgconfigDepends = [ libhandy ]; description = "libhandy bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libhandy;}; "gi-harfbuzz" = callPackage @@ -98381,6 +103343,8 @@ self: { libraryPkgconfigDepends = [ vips ]; description = "libvips GObject bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) vips;}; "gi-vte" = callPackage @@ -98529,6 +103493,8 @@ self: { libraryPkgconfigDepends = [ libwnck ]; description = "Wnck bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libwnck;}; "gi-xlib" = callPackage @@ -98587,6 +103553,8 @@ self: { ]; description = "Fuzzy finder for cabal executables"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gimlh" = callPackage @@ -98674,6 +103642,8 @@ self: { executableSystemDepends = [ openssl ]; description = "Ginsu Gale Client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openssl;}; "gio" = callPackage @@ -98714,6 +103684,8 @@ self: { ]; description = "Git Performance Dashboard"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "giphy-api" = callPackage @@ -98739,6 +103711,8 @@ self: { ]; description = "Giphy HTTP API wrapper and CLI search tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gist" = callPackage @@ -98756,6 +103730,8 @@ self: { ]; description = "A reliable command-line client for gist.github.com"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git" = callPackage @@ -98780,6 +103756,8 @@ self: { doCheck = false; description = "Git operations in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-all" = callPackage @@ -98798,6 +103776,8 @@ self: { ]; description = "Determine which Git repositories need actions to be taken"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-annex" = callPackage @@ -98911,6 +103891,8 @@ self: { ]; description = "Maintain per-branch checklists in Git"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-config" = callPackage @@ -98932,6 +103914,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "A simple parser for Git configuration files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-cuk" = callPackage @@ -98951,6 +103935,8 @@ self: { executableHaskellDepends = [ base relude ]; description = "Haskell Git Helper Tool"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-date" = callPackage @@ -98971,6 +103957,8 @@ self: { ]; description = "Bindings to the date parsing from Git"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-embed" = callPackage @@ -99008,6 +103996,7 @@ self: { ]; description = "Custom git command for formatting code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "git-freq" = callPackage @@ -99050,6 +104039,7 @@ self: { ]; description = "More intelligent push-to-GitHub utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "git-jump" = callPackage @@ -99063,6 +104053,8 @@ self: { executableHaskellDepends = [ base base-compat process ]; description = "Move a git branch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-lfs" = callPackage @@ -99136,6 +104128,7 @@ self: { ]; description = "Git object and its parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "git-remote-ipfs" = callPackage @@ -99196,6 +104189,8 @@ self: { ]; description = "repairs a damaged git repository"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-sanity" = callPackage @@ -99215,6 +104210,8 @@ self: { executableHaskellDepends = [ base Cabal ]; description = "A sanity checker for your git history"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "git-vogue" = callPackage @@ -99244,6 +104241,8 @@ self: { testToolDepends = [ git ]; description = "A framework for pre-commit checks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gitHUD" = callPackage @@ -99299,6 +104298,8 @@ self: { ]; description = "Create Github issues out of TODO comments in code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "githash" = callPackage @@ -99375,6 +104376,8 @@ self: { executableToolDepends = [ git ]; description = "backs up everything github knows about a repository, to the repository"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) git;}; "github-data" = callPackage @@ -99400,6 +104403,8 @@ self: { ]; description = "Access to the GitHub API, v3"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "github-post-receive" = callPackage @@ -99478,6 +104483,8 @@ self: { ]; description = "Various Github helper utilities"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "github-types" = callPackage @@ -99508,6 +104515,8 @@ self: { libraryHaskellDepends = [ base basic-prelude github text ]; description = "Useful functions that use the GitHub API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "github-webhook-handler" = callPackage @@ -99526,6 +104535,8 @@ self: { ]; description = "GitHub WebHook Handler"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "github-webhook-handler-snap" = callPackage @@ -99544,6 +104555,7 @@ self: { ]; description = "GitHub WebHook Handler implementation for Snap"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "github-webhooks" = callPackage @@ -99587,6 +104599,8 @@ self: { ]; description = "Heads up, and you see your GIT context"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gitignore" = callPackage @@ -99605,6 +104619,8 @@ self: { ]; description = "Apply GitHub .gitignore templates to already existing repositories."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gitit" = callPackage @@ -99658,6 +104674,8 @@ self: { testHaskellDepends = [ base hspec rio ]; description = "Gitlab Web API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gitlab-haskell" = callPackage @@ -99724,6 +104742,8 @@ self: { ]; description = "Gitlib repository backend that uses the git command-line tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gitlib-cross" = callPackage @@ -99741,6 +104761,7 @@ self: { ]; description = "Run tests between repositories"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gitlib-libgit2" = callPackage @@ -99796,6 +104817,7 @@ self: { ]; description = "Gitlib repository backend for storing Git objects in Amazon S3"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gitlib-sample" = callPackage @@ -99845,6 +104867,8 @@ self: { ]; description = "Generic utility functions for working with Git repositories"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gitrev" = callPackage @@ -99885,6 +104909,8 @@ self: { ]; description = "A document store library for Git + JSON"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gitter" = callPackage @@ -99900,6 +104926,8 @@ self: { ]; description = "Gitter.im API client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "givegif" = callPackage @@ -99927,6 +104955,7 @@ self: { ]; description = "CLI Giphy search tool with previews in iTerm 2"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gjk" = callPackage @@ -100025,6 +105054,8 @@ self: { libraryPkgconfigDepends = [ libglade ]; description = "Binding to the glade library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs.gnome2) libglade;}; "gladexml-accessor" = callPackage @@ -100036,6 +105067,7 @@ self: { libraryHaskellDepends = [ base glade HaXml template-haskell ]; description = "Automagically declares getters for widget handles in specified interface file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "glambda" = callPackage @@ -100076,6 +105108,8 @@ self: { ]; description = "An OpenGL micro framework"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "glasso" = callPackage @@ -100121,6 +105155,7 @@ self: { ]; description = "Extensible effects using ContT, State and variants"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "glazier-pipes" = callPackage @@ -100136,6 +105171,7 @@ self: { ]; description = "A threaded rendering framework using glaizer and pipes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "glazier-react" = callPackage @@ -100155,6 +105191,7 @@ self: { ]; description = "ReactJS binding using Glazier.Command."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "glazier-react-examples" = callPackage @@ -100179,6 +105216,7 @@ self: { ]; description = "Examples of using glazier-react"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "glazier-react-widget" = callPackage @@ -100198,6 +105236,7 @@ self: { ]; description = "Generic widget library using glazier-react"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gli" = callPackage @@ -100222,6 +105261,8 @@ self: { testHaskellDepends = [ base ]; description = "Tiny cli to fetch PR info from gitlab"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "glib" = callPackage @@ -100267,6 +105308,8 @@ self: { testHaskellDepends = [ base Cabal containers hspec text ]; description = "Natural Language Processing library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "glintcollider" = callPackage @@ -100346,6 +105389,8 @@ self: { benchmarkHaskellDepends = [ base criterion Glob MissingH ]; description = "Haskell bindings for POSIX glob library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "global" = callPackage @@ -100363,6 +105408,7 @@ self: { ]; description = "Library enabling unique top-level declarations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "global-config" = callPackage @@ -100383,6 +105429,7 @@ self: { ]; description = "Global mutable configuration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "global-lock" = callPackage @@ -100405,6 +105452,8 @@ self: { libraryHaskellDepends = [ base containers stm ]; description = "Namespaced, global, and top-level mutable variables without unsafePerformIO"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "glome-hs" = callPackage @@ -100428,6 +105477,7 @@ self: { doHaddock = false; description = "ray tracer"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "gloss" = callPackage @@ -100482,6 +105532,7 @@ self: { libraryHaskellDepends = [ base gloss reactive-banana ]; description = "An Interface for gloss in terms of a reactive-banana Behavior"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "gloss-devil" = callPackage @@ -100493,6 +105544,7 @@ self: { libraryHaskellDepends = [ base bytestring gloss repa repa-devil ]; description = "Display images in Gloss using libdevil for decoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gloss-examples" = callPackage @@ -100512,6 +105564,7 @@ self: { ]; description = "Examples using the gloss library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gloss-export" = callPackage @@ -100531,6 +105584,8 @@ self: { testHaskellDepends = [ base directory filepath gloss JuicyPixels ]; description = "Export Gloss pictures to png, bmp, tga, tiff, gif and juicy-pixels-image"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gloss-game" = callPackage @@ -100542,6 +105597,8 @@ self: { libraryHaskellDepends = [ base gloss gloss-juicy ]; description = "Gloss wrapper that simplifies writing games"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gloss-juicy" = callPackage @@ -100620,6 +105677,7 @@ self: { libraryHaskellDepends = [ base gloss sodium ]; description = "A Sodium interface to the Gloss drawing package"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "glpk-headers" = callPackage @@ -100638,6 +105696,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Low-level Haskell bindings to GLPK"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) glpk;}; "glpk-hs" = callPackage @@ -100700,6 +105760,8 @@ self: { testHaskellDepends = [ base bytestring directory filepath shower ]; description = "glTF scene loader"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "glue" = callPackage @@ -100729,6 +105791,8 @@ self: { ]; description = "Make better services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "glue-common" = callPackage @@ -100849,6 +105913,7 @@ self: { ]; description = "Composable maps and generic tries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gmndl" = callPackage @@ -100867,6 +105932,7 @@ self: { ]; description = "Mandelbrot Set explorer using GTK"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "gmpint" = callPackage @@ -100894,6 +105960,7 @@ self: { ]; description = "Randomly set a picture as the GNOME desktop background"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "gnome-keyring" = callPackage @@ -100931,6 +105998,7 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GNOME Virtual File System library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {gnome-vfs = null; gnome-vfs_module = null;}; "gnss-converters" = callPackage @@ -100958,6 +106026,7 @@ self: { ]; description = "GNSS Converters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gnuidn" = callPackage @@ -100980,6 +106049,7 @@ self: { testToolDepends = [ c2hs ]; description = "Bindings for GNU IDN"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libidn;}; "gnuplot" = callPackage @@ -101029,6 +106099,8 @@ self: { libraryHaskellDepends = [ base directory filepath process ]; description = "GHCi bindings to lambdabot"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "goal-core" = callPackage @@ -101048,6 +106120,8 @@ self: { executableHaskellDepends = [ base ]; description = "Core imports for Geometric Optimization Libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "goal-geometry" = callPackage @@ -101062,6 +106136,7 @@ self: { executableHaskellDepends = [ base goal-core ]; description = "Scientific computing on geometric objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "goal-probability" = callPackage @@ -101081,6 +106156,7 @@ self: { executableHaskellDepends = [ base goal-core goal-geometry vector ]; description = "Manifolds of probability distributions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "goal-simulation" = callPackage @@ -101104,6 +106180,7 @@ self: { ]; description = "Mealy based simulation tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "goat" = callPackage @@ -101179,6 +106256,8 @@ self: { testHaskellDepends = [ base hspec hspec-core ]; description = "Go-style channels"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "godot-haskell" = callPackage @@ -101201,6 +106280,8 @@ self: { doHaddock = false; description = "Haskell bindings for the Godot game engine API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gofer-prelude" = callPackage @@ -101212,6 +106293,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "The Gofer 2.30 standard prelude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "goggles" = callPackage @@ -103502,6 +108585,8 @@ self: { libraryHaskellDepends = [ base renderable transformers varying ]; description = "Graphical user interfaces that are renderable, change over time and eventually produce a value"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "google-cloud" = callPackage @@ -103521,6 +108606,8 @@ self: { ]; description = "Client for the Google Cloud APIs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "google-dictionary" = callPackage @@ -103555,6 +108642,7 @@ self: { ]; description = "Google Drive API access"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "google-html5-slide" = callPackage @@ -103573,6 +108661,8 @@ self: { ]; description = "Google HTML5 Slide generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "google-isbn" = callPackage @@ -103603,6 +108693,7 @@ self: { testHaskellDepends = [ base google-search text time xml-conduit ]; description = "Write GMail filters and output to importable XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "google-maps-geocoding" = callPackage @@ -103619,6 +108710,7 @@ self: { ]; description = "Bindings to the Google Geocoding API (formerly Maps Geocoding API)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "google-oauth2" = callPackage @@ -103639,6 +108731,8 @@ self: { ]; description = "Google OAuth2 token negotiation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "google-oauth2-easy" = callPackage @@ -103658,6 +108752,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Opininated use of Google Authentication for ease"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "google-oauth2-for-cli" = callPackage @@ -103701,6 +108797,8 @@ self: { libraryHaskellDepends = [ base free nats text time ]; description = "EDSL for Google and GMail search expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "google-server-api" = callPackage @@ -103743,6 +108841,7 @@ self: { ]; description = "Bindings to the Google Maps Static API (formerly Static Maps API)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "google-translate" = callPackage @@ -103759,6 +108858,8 @@ self: { ]; description = "Google Translate API bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "googleplus" = callPackage @@ -103776,6 +108877,7 @@ self: { ]; description = "Haskell implementation of the Google+ API v1"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "googlepolyline" = callPackage @@ -103794,6 +108896,8 @@ self: { ]; description = "Google Polyline Encoder/Decoder"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gopher-proxy" = callPackage @@ -103832,6 +108936,8 @@ self: { ]; description = "Spidering robot to download files from Gopherspace"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gopro-plus" = callPackage @@ -103860,6 +108966,8 @@ self: { ]; description = "GoPro Plus Client API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gore-and-ash" = callPackage @@ -103878,6 +108986,8 @@ self: { ]; description = "Core of FRP game engine called Gore&Ash"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gore-and-ash-actor" = callPackage @@ -103895,6 +109005,7 @@ self: { ]; description = "Gore&Ash engine extension that implements actor style of programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-async" = callPackage @@ -103917,6 +109028,7 @@ self: { ]; description = "Core module for Gore&Ash engine that embeds async IO actions into game loop"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-demo" = callPackage @@ -103942,6 +109054,7 @@ self: { ]; description = "Demonstration game for Gore&Ash game engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-glfw" = callPackage @@ -103958,6 +109071,7 @@ self: { ]; description = "Core module for Gore&Ash engine for GLFW input events"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-lambdacube" = callPackage @@ -103977,6 +109091,7 @@ self: { ]; description = "Core module for Gore&Ash engine that do something"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-logging" = callPackage @@ -103995,6 +109110,7 @@ self: { ]; description = "Core module for gore-and-ash with logging utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-network" = callPackage @@ -104016,6 +109132,7 @@ self: { ]; description = "Core module for Gore&Ash engine with low level network API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-sdl" = callPackage @@ -104034,6 +109151,7 @@ self: { ]; description = "Gore&Ash core module for integration with SDL library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gore-and-ash-sync" = callPackage @@ -104053,6 +109171,7 @@ self: { ]; description = "Gore&Ash module for high level network synchronization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gothic" = callPackage @@ -104110,6 +109229,8 @@ self: { ]; description = "Generic Programming Use in Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gpcsets" = callPackage @@ -104174,6 +109295,7 @@ self: { ]; description = "For manipulating GPS coordinates and trails"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gps2htmlReport" = callPackage @@ -104194,6 +109316,7 @@ self: { ]; description = "GPS to HTML Summary Report"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gpx-conduit" = callPackage @@ -104210,6 +109333,8 @@ self: { ]; description = "Read GPX files using conduits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grab" = callPackage @@ -104223,6 +109348,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Applicative non-linear consumption"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grab-form" = callPackage @@ -104235,6 +109362,7 @@ self: { testHaskellDepends = [ base containers hedgehog text ]; description = "Applicative parsers for form parameter lists"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "graceful" = callPackage @@ -104251,6 +109379,8 @@ self: { ]; description = "Library to write graceful shutdown / upgrade service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grafana" = callPackage @@ -104269,6 +109399,8 @@ self: { ]; description = "API for creating grafana dashboards represented as json"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graflog" = callPackage @@ -104287,6 +109419,7 @@ self: { ]; description = "Monadic correlated log events"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "grakn" = callPackage @@ -104310,6 +109443,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "A Haskell client for Grakn"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grammar-combinators" = callPackage @@ -104327,6 +109462,7 @@ self: { ]; description = "A parsing library of context-free grammar combinators"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "grammatical-parsers" = callPackage @@ -104378,6 +109514,7 @@ self: { ]; description = "Examples using the Grapefruit library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "grapefruit-frp" = callPackage @@ -104395,6 +109532,8 @@ self: { ]; description = "Functional Reactive Programming core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grapefruit-records" = callPackage @@ -104406,6 +109545,7 @@ self: { libraryHaskellDepends = [ arrows base grapefruit-frp ]; description = "A record system for Functional Reactive Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "grapefruit-ui" = callPackage @@ -104424,6 +109564,7 @@ self: { ]; description = "Declarative user interface programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "grapefruit-ui-gtk" = callPackage @@ -104443,6 +109584,7 @@ self: { ]; description = "GTK+-based backend for declarative user interface programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph" = callPackage @@ -104512,6 +109654,8 @@ self: { libraryHaskellDepends = [ base containers fgl ]; description = "An implementation of algorithms for matchings in graphs"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graph-rewriting" = callPackage @@ -104525,6 +109669,8 @@ self: { ]; description = "Monadic graph rewriting of hypergraphs with ports and multiedges"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graph-rewriting-cl" = callPackage @@ -104544,6 +109690,7 @@ self: { ]; description = "Interactive graph rewriting system implementing various well-known combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-rewriting-gl" = callPackage @@ -104560,6 +109707,7 @@ self: { ]; description = "OpenGL interface for interactive port graph rewriting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-rewriting-lambdascope" = callPackage @@ -104581,6 +109729,7 @@ self: { ]; description = "Lambdascope, an optimal evaluator of the lambda calculus, as an interactive graph-rewriting system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-rewriting-layout" = callPackage @@ -104596,6 +109745,7 @@ self: { ]; description = "Force-directed node placement intended for incremental graph drawing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-rewriting-ski" = callPackage @@ -104615,6 +109765,7 @@ self: { ]; description = "Two evalutors of the SKI combinator calculus as interactive graph rewrite systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-rewriting-strategies" = callPackage @@ -104630,6 +109781,7 @@ self: { ]; description = "Evaluation strategies for port-graph rewriting systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-rewriting-trs" = callPackage @@ -104651,6 +109803,7 @@ self: { ]; description = "Evaluate first-order applicative term rewrite systems interactively using graph reduction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-rewriting-ww" = callPackage @@ -104671,6 +109824,7 @@ self: { ]; description = "Evaluator of the lambda-calculus in an interactive graph rewriting system with explicit sharing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-serialize" = callPackage @@ -104682,6 +109836,8 @@ self: { libraryHaskellDepends = [ array base bytestring containers ]; description = "Serialization of data structures with references"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graph-utils" = callPackage @@ -104697,6 +109853,8 @@ self: { ]; description = "A simple wrapper & quasi quoter for fgl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graph-visit" = callPackage @@ -104712,6 +109870,7 @@ self: { ]; description = "Graph walk abstraction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graph-wrapper" = callPackage @@ -104745,6 +109904,8 @@ self: { ]; description = "A declarative, monadic graph construction language for small graphs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphene" = callPackage @@ -104761,6 +109922,8 @@ self: { ]; description = "A minimal Graph Theory library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphics-drawingcombinators" = callPackage @@ -104778,6 +109941,8 @@ self: { ]; description = "A functional interface to 2D drawing in OpenGL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphics-formats-collada" = callPackage @@ -104793,6 +109958,8 @@ self: { ]; description = "Load 3D geometry in the COLLADA format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphicsFormats" = callPackage @@ -104804,6 +109971,7 @@ self: { libraryHaskellDepends = [ base haskell98 OpenGL QuickCheck ]; description = "Classes for renderable objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graphicstools" = callPackage @@ -104822,6 +109990,7 @@ self: { executableHaskellDepends = [ base CV wx wxcore ]; description = "Tools for creating graphical UIs, based on wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graphite" = callPackage @@ -104878,6 +110047,8 @@ self: { executableHaskellDepends = [ base ]; description = "A reimplementation of graphmod as a source plugin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphql" = callPackage @@ -104931,6 +110102,8 @@ self: { ]; description = "GraphQL API"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphql-client" = callPackage @@ -104961,6 +110134,7 @@ self: { ]; description = "A client for Haskell programs to query a GraphQL API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graphql-utils" = callPackage @@ -104976,6 +110150,8 @@ self: { ]; description = "GraphQL Utils"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphql-w-persistent" = callPackage @@ -104987,6 +110163,8 @@ self: { libraryHaskellDepends = [ base containers json text ]; description = "GraphQL interface middleware for SQL databases"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphs" = callPackage @@ -105015,6 +110193,8 @@ self: { libraryHaskellDepends = [ base indexed ]; description = "Graph indexed monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphtype" = callPackage @@ -105032,6 +110212,7 @@ self: { ]; description = "A simple tool to illustrate dependencies between Haskell types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "graphula" = callPackage @@ -105088,6 +110269,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "A declarative library for describing dependencies between data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "graphviz" = callPackage @@ -105131,6 +110314,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Execute Graql queries on a Grakn graph"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grasp" = callPackage @@ -105155,6 +110340,8 @@ self: { testHaskellDepends = [ base ]; description = "GRASP implementation for the AMMM project"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gravatar" = callPackage @@ -105183,6 +110370,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Gray code encoder/decoder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gray-extended" = callPackage @@ -105235,6 +110424,8 @@ self: { executableHaskellDepends = [ array base containers pretty ]; description = "GreenCard, a foreign function pre-processor for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "greencard-lib" = callPackage @@ -105247,6 +110438,7 @@ self: { libraryHaskellDepends = [ array base containers greencard pretty ]; description = "A foreign function interface pre-processor library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "greenclip" = callPackage @@ -105283,6 +110475,8 @@ self: { ]; description = "A scalable distributed logger with a high-precision global time axis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gremlin-haskell" = callPackage @@ -105306,6 +110500,8 @@ self: { testHaskellDepends = [ aeson-qq base hspec lens lens-aeson mtl ]; description = "Graph database client for TinkerPop3 Gremlin Server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grenade" = callPackage @@ -105329,6 +110525,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion hmatrix ]; description = "Practical Deep Learning in Haskell"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "greplicate" = callPackage @@ -105449,6 +110647,7 @@ self: { ]; description = "Grid-based prototyping framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gridbounds" = callPackage @@ -105461,6 +110660,7 @@ self: { testHaskellDepends = [ base earclipper gjk gridbox hspec ]; description = "Collision detection for GridBox"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gridbox" = callPackage @@ -105509,6 +110709,7 @@ self: { ]; description = "Grid-based multimedia engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "grids" = callPackage @@ -105552,6 +110753,8 @@ self: { executableToolDepends = [ happy ]; description = "grm grammar converter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "groom" = callPackage @@ -105615,6 +110818,8 @@ self: { ]; description = "Command line utility to manage AWS ECS resources"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gross" = callPackage @@ -105629,6 +110834,8 @@ self: { executableHaskellDepends = [ base lens mtl ncurses ]; description = "A spoof on gloss for terminal animation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "groundhog" = callPackage @@ -105666,6 +110873,8 @@ self: { ]; description = "Extended Converter Library for groundhog embedded types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "groundhog-inspector" = callPackage @@ -105706,6 +110915,8 @@ self: { ]; description = "MySQL backend for the groundhog library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "groundhog-postgresql" = callPackage @@ -105786,6 +110997,8 @@ self: { libraryHaskellDepends = [ base containers groups ]; description = "The theory of groups"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "group-with" = callPackage @@ -105802,6 +111015,8 @@ self: { ]; description = "Classify objects by key-generating function, like SQL GROUP BY"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "groupBy" = callPackage @@ -105834,6 +111049,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Grouped lists. Equal consecutive elements are grouped."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "groupoid" = callPackage @@ -105919,6 +111136,8 @@ self: { ]; description = "A revised version of the scotty library that attempts to be simpler and more performant"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grpc-api-etcd" = callPackage @@ -105930,6 +111149,8 @@ self: { libraryHaskellDepends = [ base proto-lens proto-lens-runtime ]; description = "Generated messages and instances for etcd gRPC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "grpc-etcd-client" = callPackage @@ -105946,6 +111167,7 @@ self: { ]; description = "gRPC client for etcd"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "grpc-haskell" = callPackage @@ -105976,6 +111198,7 @@ self: { ]; description = "Haskell implementation of gRPC layered on shared C library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "grpc-haskell-core" = callPackage @@ -106001,6 +111224,7 @@ self: { ]; description = "Haskell implementation of gRPC layered on shared C library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {gpr = null; inherit (pkgs) grpc;}; "gruff" = callPackage @@ -106022,6 +111246,7 @@ self: { ]; description = "fractal explorer GUI using the ruff library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "gruff-examples" = callPackage @@ -106040,6 +111265,7 @@ self: { ]; description = "Mandelbrot Set examples using ruff and gruff"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "gsasl" = callPackage @@ -106085,6 +111311,7 @@ self: { ]; description = "scrapes google scholar, provides RSS feed"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "gsl-random" = callPackage @@ -106097,6 +111324,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Bindings the the GSL random number generation facilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gsl-random-fu" = callPackage @@ -106108,6 +111337,7 @@ self: { libraryHaskellDepends = [ base gsl-random random-fu ]; description = "Instances for using gsl-random with random-fu"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "gsmenu" = callPackage @@ -106172,6 +111402,7 @@ self: { ]; description = "Generic implementation of Storable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gstreamer" = callPackage @@ -106191,6 +111422,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GStreamer open source multimedia framework"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gst-plugins-base = null; gstreamer = null;}; "gt-tools" = callPackage @@ -106224,6 +111457,7 @@ self: { ]; description = "The General Transit Feed Specification format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gtfs-realtime" = callPackage @@ -106239,6 +111473,8 @@ self: { ]; description = "GTFS RealTime protobafs library (autogenerated from .proto file)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gtk" = callPackage @@ -106333,6 +111569,7 @@ self: { libraryPkgconfigDepends = [ gtk2 ]; description = "GTK+ Serialized event"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gtk2;}; "gtk-simple-list-view" = callPackage @@ -106377,6 +111614,8 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtk3;}; "gtk-strut" = callPackage @@ -106410,6 +111649,8 @@ self: { libraryHaskellDepends = [ base containers gtk ]; description = "Convenient Gtk canvas with mouse and keyboard input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gtk-traymanager" = callPackage @@ -106561,6 +111802,8 @@ self: { executableHaskellDepends = [ base glib gtk3 transformers ]; description = "Gtk2Hs Hello World, an example package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gtk2hs-rpn" = callPackage @@ -106572,6 +111815,8 @@ self: { libraryHaskellDepends = [ base cairo glib gtk mtl ]; description = "Adds a module to gtk2hs allowing layouts to be defined using reverse polish notation"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gtk3" = callPackage @@ -106623,6 +111868,8 @@ self: { libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ]; description = "Bindings for the Gtk/OS X integration library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gtk-mac-integration-gtk3 = null;}; "gtkglext" = callPackage @@ -106641,6 +111888,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GTK+ OpenGL Extension"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtk2; inherit (pkgs.gnome2) gtkglext; inherit (pkgs) libGLU; inherit (pkgs.xorg) libICE; inherit (pkgs.xorg) libSM; inherit (pkgs.xorg) libXmu; @@ -106662,6 +111911,7 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GtkImageView library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gtkimageview;}; "gtkrsync" = callPackage @@ -106680,6 +111930,7 @@ self: { ]; description = "Gnome rsync progress display"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "gtksourceview2" = callPackage @@ -106699,6 +111950,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GtkSourceView library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtksourceview;}; "gtksourceview3" = callPackage @@ -106718,6 +111971,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the GtkSourceView library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtksourceview3;}; "guarded-allocation" = callPackage @@ -106740,6 +111995,7 @@ self: { libraryHaskellDepends = [ base instant-generics ]; description = "Datatype-generic rewriting with preconditions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "guess-combinator" = callPackage @@ -106751,6 +112007,7 @@ self: { libraryHaskellDepends = [ base HList ]; description = "Generate simple combinators given their type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "guid" = callPackage @@ -106777,6 +112034,8 @@ self: { executableHaskellDepends = [ base cairo containers filepath gtk ]; description = "graphical untyped lambda calculus interactive interpreter"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gutenberg-fibonaccis" = callPackage @@ -106801,6 +112060,8 @@ self: { executableHaskellDepends = [ base unix ]; description = "ghcWithPackages cmdline util"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gyah-bin" = callPackage @@ -106814,6 +112075,8 @@ self: { executableHaskellDepends = [ base extra GiveYouAHead ]; description = "A binary version of GiveYouAHead"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gym-http-api" = callPackage @@ -106835,6 +112098,8 @@ self: { ]; description = "REST client to the gym-http-api project"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "h-booru" = callPackage @@ -106858,6 +112123,8 @@ self: { ]; description = "Haskell library for retrieving data from various booru image sites"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "h-gpgme" = callPackage @@ -106881,6 +112148,8 @@ self: { ]; description = "High Level Binding for GnuPG Made Easy (gpgme)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "h-reversi" = callPackage @@ -106904,6 +112173,8 @@ self: { ]; description = "Reversi game in haskell/blank-canvas"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "h2048" = callPackage @@ -106930,6 +112201,8 @@ self: { ]; description = "An Implementation of Game 2048"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "h2c" = callPackage @@ -106941,6 +112214,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl resourcet ]; description = "Bindings to Linux I2C with support for repeated-start transactions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hArduino" = callPackage @@ -106956,6 +112231,7 @@ self: { ]; description = "Control your Arduino board from Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hBDD" = callPackage @@ -106982,6 +112258,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "An FFI binding to CMU/Long's BDD library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {bdd = null; mem = null;}; "hBDD-CUDD" = callPackage @@ -106997,6 +112275,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "An FFI binding to the CUDD library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) cudd; epd = null; inherit (pkgs) mtr; inherit (pkgs) st; util = null;}; @@ -107028,6 +112308,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "interface to CSound API"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {csound64 = null; inherit (pkgs) libsndfile;}; "hDFA" = callPackage @@ -107039,6 +112321,8 @@ self: { libraryHaskellDepends = [ base containers directory process ]; description = "A simple library for representing and minimising DFAs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hF2" = callPackage @@ -107051,6 +112335,8 @@ self: { libraryHaskellDepends = [ base cereal vector ]; description = "F(2^e) math for cryptography"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hGelf" = callPackage @@ -107067,6 +112353,8 @@ self: { ]; description = "Haskell GELF library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hLLVM" = callPackage @@ -107109,6 +112397,8 @@ self: { ]; description = "Library to interact with the @Mollom anti-spam service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hOff-display" = callPackage @@ -107123,6 +112413,7 @@ self: { executableHaskellDepends = [ base GLFW hOff-parser OpenGL parsec ]; description = "The tool to transform the OFF to other image format"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hOff-parser" = callPackage @@ -107200,6 +112491,7 @@ self: { ]; description = "Protein Databank file format library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hPDB-examples" = callPackage @@ -107226,6 +112518,7 @@ self: { ]; description = "Examples for hPDB library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hPushover" = callPackage @@ -107241,6 +112534,8 @@ self: { ]; description = "Pushover.net API functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hR" = callPackage @@ -107252,6 +112547,8 @@ self: { libraryHaskellDepends = [ array base containers unix ]; description = "R bindings and interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hRESP" = callPackage @@ -107298,6 +112595,8 @@ self: { ]; description = "A Haskell library to scrape and crawl web-pages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hSimpleDB" = callPackage @@ -107314,6 +112613,8 @@ self: { ]; description = "Interface to Amazon's SimpleDB service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hTalos" = callPackage @@ -107327,6 +112628,8 @@ self: { testHaskellDepends = [ base ]; description = "Parser, print and manipulate structures in PDB file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hTensor" = callPackage @@ -107338,6 +112641,8 @@ self: { libraryHaskellDepends = [ base containers hmatrix random ]; description = "Multidimensional arrays and simple tensor computations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hVOIDP" = callPackage @@ -107353,6 +112658,8 @@ self: { executableSystemDepends = [ blas liblapack ]; description = "Optimal variable selection in chain graphical model"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) blas; liblapack = null;}; "hXmixer" = callPackage @@ -107386,6 +112693,8 @@ self: { ]; description = "Haar wavelet transforms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "habit" = callPackage @@ -107410,6 +112719,7 @@ self: { executableHaskellDepends = [ base text ]; description = "Haskell message bot framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hable" = callPackage @@ -107445,6 +112755,7 @@ self: { ]; description = "A minimalist static blog generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hablog" = callPackage @@ -107467,6 +112778,7 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "A blog system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hacanon-light" = callPackage @@ -107509,6 +112821,7 @@ self: { ]; description = "Hack contrib"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack-contrib-press" = callPackage @@ -107525,6 +112838,7 @@ self: { ]; description = "Hack helper that renders Press templates"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hack-frontend-happstack" = callPackage @@ -107542,6 +112856,8 @@ self: { ]; description = "hack-frontend-happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hack-frontend-monadcgi" = callPackage @@ -107564,6 +112880,8 @@ self: { libraryHaskellDepends = [ base bytestring hack ]; description = "Hack handler using CGI protocol. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hack-handler-epoll" = callPackage @@ -107582,6 +112900,7 @@ self: { ]; description = "hack handler implementation using epoll"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hack-handler-evhttp" = callPackage @@ -107600,6 +112919,7 @@ self: { librarySystemDepends = [ event ]; description = "Hack EvHTTP (libevent) Handler"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {event = null;}; "hack-handler-fastcgi" = callPackage @@ -107612,6 +112932,7 @@ self: { librarySystemDepends = [ fcgi ]; description = "Hack handler direct to fastcgi (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) fcgi;}; "hack-handler-happstack" = callPackage @@ -107629,6 +112950,8 @@ self: { ]; description = "Hack Happstack server handler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hack-handler-hyena" = callPackage @@ -107645,6 +112968,7 @@ self: { ]; description = "Hyena hack handler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack-handler-kibro" = callPackage @@ -107659,6 +112983,8 @@ self: { ]; description = "Hack Kibro handler"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hack-handler-simpleserver" = callPackage @@ -107674,6 +113000,7 @@ self: { ]; description = "A simplistic HTTP server handler for Hack. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack-middleware-cleanpath" = callPackage @@ -107687,6 +113014,7 @@ self: { ]; description = "Applies some basic redirect rules to get cleaner paths. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack-middleware-clientsession" = callPackage @@ -107702,6 +113030,7 @@ self: { ]; description = "Middleware for easily keeping session data in client cookies. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack-middleware-gzip" = callPackage @@ -107728,6 +113057,7 @@ self: { ]; description = "Automatic wrapping of JSON responses to convert into JSONP. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack2" = callPackage @@ -107790,6 +113120,7 @@ self: { ]; description = "Hack2 Happstack server handler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack2-handler-mongrel2-http" = callPackage @@ -107810,6 +113141,7 @@ self: { ]; description = "Hack2 Mongrel2 HTTP handler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack2-handler-snap-server" = callPackage @@ -107828,6 +113160,7 @@ self: { ]; description = "Hack2 Snap server handler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hack2-handler-warp" = callPackage @@ -107844,6 +113177,8 @@ self: { ]; description = "Hack2 warp handler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hack2-interface-wai" = callPackage @@ -107878,6 +113213,8 @@ self: { testHaskellDepends = [ base http-client-tls servant-client ]; description = "An API binding to Hackage API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage-db" = callPackage @@ -107918,6 +113255,8 @@ self: { ]; description = "Compare the public API of different versions of a Hackage library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage-mirror" = callPackage @@ -107947,6 +113286,8 @@ self: { ]; description = "Simple mirroring utility for Hackage"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage-plot" = callPackage @@ -107978,6 +113319,8 @@ self: { executableHaskellDepends = [ base Cabal containers hackage-db ]; description = "Process 00-index.tar.gz from Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage-proxy" = callPackage @@ -108001,6 +113344,8 @@ self: { ]; description = "Provide a proxy for Hackage which modifies responses in some way. (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage-repo-tool" = callPackage @@ -108023,6 +113368,8 @@ self: { ]; description = "Manage secure file-based package repositories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage-security" = callPackage @@ -108107,6 +113454,7 @@ self: { ]; description = "The Hackage web server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hackage-sparks" = callPackage @@ -108143,6 +113491,8 @@ self: { ]; description = "Check for differences between working directory and hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage2hwn" = callPackage @@ -108156,6 +113506,8 @@ self: { executableHaskellDepends = [ base download feed tagsoup ]; description = "Convert Hackage RSS feeds to wiki format for publishing on Haskell.org"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackage2twitter" = callPackage @@ -108169,6 +113521,7 @@ self: { executableHaskellDepends = [ base feed feed2twitter ]; description = "Send new Hackage releases to Twitter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hackager" = callPackage @@ -108186,6 +113539,8 @@ self: { ]; description = "Hackage testing tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackernews" = callPackage @@ -108210,6 +113565,8 @@ self: { ]; description = "API for Hacker News"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hackertyper" = callPackage @@ -108246,6 +113603,7 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "Generate useful files for Haskell projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hackport" = callPackage @@ -108281,6 +113639,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Hackage and Portage integration tool"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hactor" = callPackage @@ -108297,6 +113657,8 @@ self: { ]; description = "Lightweight Erlang-style actors for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hactors" = callPackage @@ -108308,6 +113670,8 @@ self: { libraryHaskellDepends = [ base stm ]; description = "Practical actors for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haddock_2_23_1" = callPackage @@ -108341,6 +113705,7 @@ self: { preCheck = "unset GHC_PACKAGE_PATH"; description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haddock-api_2_23_1" = callPackage @@ -108366,6 +113731,7 @@ self: { description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haddock-api" = callPackage @@ -108392,6 +113758,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haddock-cheatsheet" = callPackage @@ -108403,6 +113771,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A documentation-only package exemplifying haddock markup features"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haddock-leksah" = callPackage @@ -108421,6 +113791,8 @@ self: { ]; description = "A documentation-generation tool for Haskell libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haddock-library_1_7_0" = callPackage @@ -108502,6 +113874,8 @@ self: { ]; description = "Test utilities for Haddock"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haddocset" = callPackage @@ -108523,6 +113897,7 @@ self: { ]; description = "Generate docset of Dash by Haddock haskell documentation tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hadolint" = callPackage @@ -108572,6 +113947,8 @@ self: { testHaskellDepends = [ base bytestring filepath text vector ]; description = "Read/write file formats commonly used by Hadoop"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) snappy;}; "hadoop-rpc" = callPackage @@ -108592,6 +113969,8 @@ self: { testHaskellDepends = [ base protobuf tasty tasty-hunit vector ]; description = "Use the Hadoop RPC interface from Haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hadoop-streaming" = callPackage @@ -108633,6 +114012,7 @@ self: { ]; description = "Fast command line tools for working with Hadoop"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "haeredes" = callPackage @@ -108663,6 +114043,8 @@ self: { testHaskellDepends = [ base intervals mtl QuickCheck ]; description = "Affine arithmetic library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haggis" = callPackage @@ -108689,6 +114071,7 @@ self: { ]; description = "A static site generator with blogging/comments support"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haggle" = callPackage @@ -108741,6 +114124,8 @@ self: { executableHaskellDepends = [ base time ]; description = "Analytic Hierarchy Process"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haiji" = callPackage @@ -108763,6 +114148,8 @@ self: { ]; description = "A typed template engine, subset of jinja2"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hail" = callPackage @@ -108816,6 +114203,8 @@ self: { ]; description = "A program to send emails throught the Mailgun api"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hailgun-simple" = callPackage @@ -108921,6 +114310,8 @@ self: { ]; description = "A JSON REST API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hakaru" = callPackage @@ -108950,6 +114341,8 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ghc-prim ]; description = "A probabilistic programming embedded DSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hake" = callPackage @@ -108977,6 +114370,8 @@ self: { libraryHaskellDepends = [ base HTTP network ]; description = "Akismet spam protection library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hakka" = callPackage @@ -108991,6 +114386,8 @@ self: { executableHaskellDepends = [ base ]; description = "Minimal akka-inspired actor library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hako" = callPackage @@ -109007,6 +114404,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "A mako-like quasi-quoter template library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hakyll" = callPackage @@ -109044,6 +114443,8 @@ self: { testToolDepends = [ utillinux ]; description = "A static website compiler library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) utillinux;}; "hakyll-R" = callPackage @@ -109058,6 +114459,7 @@ self: { ]; description = "A package allowing to write Hakyll blog posts in Rmd"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-agda" = callPackage @@ -109074,6 +114476,7 @@ self: { ]; description = "Wrapper to integrate literate Agda files with Hakyll"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-alectryon" = callPackage @@ -109090,6 +114493,7 @@ self: { ]; description = "Hakyll extension for rendering Coq code using Alectryon"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-blaze-templates" = callPackage @@ -109101,6 +114505,7 @@ self: { libraryHaskellDepends = [ base blaze-html blaze-markup hakyll ]; description = "Blaze templates for Hakyll"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-contrib" = callPackage @@ -109116,6 +114521,7 @@ self: { executableHaskellDepends = [ base directory filepath hakyll ]; description = "Extra modules for the hakyll website compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-contrib-csv" = callPackage @@ -109132,6 +114538,7 @@ self: { testHaskellDepends = [ base blaze-html bytestring cassava hspec ]; description = "Generate Html tables from Csv files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-contrib-elm" = callPackage @@ -109150,6 +114557,7 @@ self: { executableHaskellDepends = [ base hakyll ]; description = "Compile Elm code for inclusion in Hakyll static site"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-contrib-hyphenation" = callPackage @@ -109161,6 +114569,7 @@ self: { libraryHaskellDepends = [ base hakyll hyphenation split tagsoup ]; description = "automatic hyphenation for Hakyll"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-contrib-i18n" = callPackage @@ -109205,6 +114614,7 @@ self: { ]; description = "A hakyll library that helps maintain a separate links database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-convert" = callPackage @@ -109253,6 +114663,7 @@ self: { executableHaskellDepends = [ base dhall hakyll ]; description = "Dhall compiler for Hakyll"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-dir-list" = callPackage @@ -109267,6 +114678,7 @@ self: { ]; description = "Allow Hakyll to create hierarchical menues from directories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-elm" = callPackage @@ -109296,6 +114708,7 @@ self: { executableHaskellDepends = [ base hakyll ]; testHaskellDepends = [ base ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-filestore" = callPackage @@ -109310,6 +114723,7 @@ self: { ]; description = "FileStore utilities for Hakyll"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-images" = callPackage @@ -109331,6 +114745,7 @@ self: { ]; description = "Hakyll utilities to work with images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-ogmarkup" = callPackage @@ -109342,6 +114757,7 @@ self: { libraryHaskellDepends = [ base hakyll ogmarkup ]; description = "Integrate ogmarkup document with Hakyll"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-process" = callPackage @@ -109353,6 +114769,7 @@ self: { libraryHaskellDepends = [ base bytestring hakyll typed-process ]; description = "Hakyll compiler for arbitrary external processes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-sass" = callPackage @@ -109368,6 +114785,7 @@ self: { ]; description = "Hakyll SASS compiler over hsass"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-series" = callPackage @@ -109379,6 +114797,7 @@ self: { libraryHaskellDepends = [ base containers hakyll ]; description = "Adds series functionality to hakyll"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-shakespeare" = callPackage @@ -109396,6 +114815,7 @@ self: { ]; description = "Hakyll Hamlet compiler"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-shortcode" = callPackage @@ -109417,6 +114837,8 @@ self: { ]; description = "A shortcode extension module for Hakyll"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hakyll-shortcut-links" = callPackage @@ -109433,6 +114855,7 @@ self: { testHaskellDepends = [ base hspec mtl pandoc text ]; description = "Use shortcut-links in markdown file for Hakyll"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "hakyll-typescript" = callPackage @@ -109449,6 +114872,7 @@ self: { testHaskellDepends = [ base directory hakyll tasty tasty-hunit ]; description = "Typescript and javascript hakyll compilers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hal" = callPackage @@ -109501,6 +114925,7 @@ self: { ]; description = "A tool to generate missing import statements for Haskell modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "half" = callPackage @@ -109541,6 +114966,8 @@ self: { ]; description = "The HAskelL File System (\"halfs\" -- intended for use on the HaLVM)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "halipeto" = callPackage @@ -109554,6 +114981,8 @@ self: { libraryHaskellDepends = [ base directory HaXml pandoc ]; description = "Haskell Static Web Page Generator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "halive" = callPackage @@ -109583,6 +115012,8 @@ self: { ]; description = "A live recompiler"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hall-symbols" = callPackage @@ -109599,6 +115030,7 @@ self: { ]; description = "Symmetry operations generater of Hall Symbols"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "halma" = callPackage @@ -109619,6 +115051,8 @@ self: { ]; description = "Library implementing Halma rules"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "halma-gui" = callPackage @@ -109637,6 +115071,7 @@ self: { ]; description = "GTK application for playing Halma"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "halma-telegram-bot" = callPackage @@ -109661,6 +115096,7 @@ self: { ]; description = "Telegram bot for playing Halma"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haltavista" = callPackage @@ -109686,6 +115122,8 @@ self: { testHaskellDepends = [ base hedgehog lens ]; description = "Split or combine data structures to and from halves, quarters, eighths"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "halvm-web" = callPackage @@ -109732,6 +115170,7 @@ self: { ]; testHaskellDepends = [ base bytestring ]; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hamid" = callPackage @@ -109798,6 +115237,8 @@ self: { ]; description = "Haskell macro preprocessor"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hamsql" = callPackage @@ -109821,6 +115262,8 @@ self: { testHaskellDepends = [ base ]; description = "Interpreter for SQL-structure definitions in YAML (YamSql)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hamtmap" = callPackage @@ -109834,6 +115277,8 @@ self: { libraryHaskellDepends = [ array base deepseq hashable ]; description = "A purely functional and persistent hash map"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hamtsolo" = callPackage @@ -109874,6 +115319,7 @@ self: { executableHaskellDepends = [ filepath ]; description = "Library to handle abstract music"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "han2zen" = callPackage @@ -109899,6 +115345,8 @@ self: { libraryHaskellDepends = [ base containers random ]; description = "Hanabi card game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "handa-data" = callPackage @@ -109939,6 +115387,8 @@ self: { ]; description = "Library and command-line utility for accessing Google services and APIs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "handa-geodata" = callPackage @@ -109985,6 +115435,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "HandleLike class"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "handsy" = callPackage @@ -110005,6 +115457,8 @@ self: { ]; description = "A DSL to describe common shell operations and interpeters for running them locally and remotely"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "handwriting" = callPackage @@ -110063,6 +115517,8 @@ self: { ]; description = "Simple Continuous Integration/Deployment System"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hans" = callPackage @@ -110086,6 +115542,8 @@ self: { ]; description = "Network Stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hans-pcap" = callPackage @@ -110097,6 +115555,7 @@ self: { libraryHaskellDepends = [ base bytestring hans pcap ]; description = "Driver for real ethernet devices for HaNS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hans-pfq" = callPackage @@ -110141,6 +115600,8 @@ self: { ]; description = "Korean spell checker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haphviz" = callPackage @@ -110159,6 +115620,8 @@ self: { ]; description = "Graphviz code generation with Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hapistrano" = callPackage @@ -110207,6 +115670,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the appindicator library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libappindicator-gtk2;}; "happindicator3" = callPackage @@ -110221,6 +115686,8 @@ self: { libraryPkgconfigDepends = [ libappindicator-gtk3 ]; description = "Binding to the appindicator library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libappindicator-gtk3;}; "happlets" = callPackage @@ -110238,6 +115705,8 @@ self: { ]; description = "\"Haskell Applets\" provides an event handler and a canvas for building simple GUI apps"; license = "AGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happlets-lib-gtk" = callPackage @@ -110259,6 +115728,7 @@ self: { ]; description = "The \"Haskell Applets\" Gtk+ ver. 2 back-end for \"happlets\"."; license = "AGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "happraise" = callPackage @@ -110272,6 +115742,8 @@ self: { executableHaskellDepends = [ base directory filepath ]; description = "A small program for counting the comments in haskell source"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happs-hsp" = callPackage @@ -110285,6 +115757,7 @@ self: { base bytestring HAppS-Server hsp mtl plugins ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happs-hsp-template" = callPackage @@ -110301,6 +115774,7 @@ self: { ]; description = "Utilities for using HSP templates in HAppS applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happs-tutorial" = callPackage @@ -110325,6 +115799,7 @@ self: { ]; description = "A Happstack Tutorial that is its own web 2.0-type demo."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack" = callPackage @@ -110339,6 +115814,8 @@ self: { doHaddock = false; description = "The haskell application server stack + code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-auth" = callPackage @@ -110357,6 +115834,7 @@ self: { ]; description = "A Happstack Authentication Suite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-authenticate" = callPackage @@ -110386,6 +115864,7 @@ self: { ]; description = "Happstack Authentication Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-clientsession" = callPackage @@ -110422,6 +115901,7 @@ self: { ]; description = "Web related tools and services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-data" = callPackage @@ -110443,6 +115923,7 @@ self: { ]; description = "Happstack data manipulation libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-dlg" = callPackage @@ -110460,6 +115941,7 @@ self: { ]; description = "Cross-request user interactions for Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-facebook" = callPackage @@ -110485,6 +115967,7 @@ self: { ]; description = "A package for building Facebook applications using Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-fastcgi" = callPackage @@ -110516,6 +115999,7 @@ self: { ]; description = "Support for using Fay with Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-fay-ajax" = callPackage @@ -110528,6 +116012,8 @@ self: { libraryHaskellDepends = [ fay-base fay-jquery ]; description = "Support for using Fay with Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-foundation" = callPackage @@ -110548,6 +116034,8 @@ self: { ]; description = "Glue code for using Happstack with acid-state, web-routes, reform, and HSP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-hamlet" = callPackage @@ -110559,6 +116047,8 @@ self: { libraryHaskellDepends = [ base happstack-server shakespeare text ]; description = "Support for Hamlet HTML templates in Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-heist" = callPackage @@ -110575,6 +116065,8 @@ self: { ]; description = "Support for using Heist templates in Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-helpers" = callPackage @@ -110598,6 +116090,7 @@ self: { ]; description = "Convenience functions for Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-hsp" = callPackage @@ -110629,6 +116122,8 @@ self: { ]; description = "Support for using HStringTemplate in Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-ixset" = callPackage @@ -110647,6 +116142,7 @@ self: { ]; description = "Efficient relational queries on Haskell sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-jmacro" = callPackage @@ -110664,6 +116160,7 @@ self: { ]; description = "Support for using JMacro with Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-lite" = callPackage @@ -110677,6 +116174,8 @@ self: { ]; description = "Happstack minus the useless stuff"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-monad-peel" = callPackage @@ -110692,6 +116191,8 @@ self: { ]; description = "monad-peel instances for Happstack types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-plugins" = callPackage @@ -110707,6 +116208,7 @@ self: { ]; description = "The haskell application server stack + reload"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-server" = callPackage @@ -110770,6 +116272,8 @@ self: { ]; description = "Extend happstack-server with native HTTPS support (TLS/SSL)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-state" = callPackage @@ -110790,6 +116294,7 @@ self: { ]; description = "Event-based distributed state"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-static-routing" = callPackage @@ -110828,6 +116333,8 @@ self: { ]; description = "Web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-yui" = callPackage @@ -110849,6 +116356,7 @@ self: { ]; description = "Utilities for using YUI3 with Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happy_1_19_9" = callPackage @@ -110913,6 +116421,8 @@ self: { libraryHaskellDepends = [ base Chart Chart-diagrams ]; description = "Generate simple okay-looking bar plots without much effort"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happy-meta" = callPackage @@ -110947,6 +116457,8 @@ self: { ]; description = "Acceptance test framework for web applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happybara-webkit" = callPackage @@ -110966,6 +116478,7 @@ self: { ]; description = "WebKit Happybara driver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "happybara-webkit-server" = callPackage @@ -110977,6 +116490,8 @@ self: { libraryHaskellDepends = [ base directory filepath process ]; description = "WebKit Server binary for Happybara (taken from capybara-webkit)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hapstone" = callPackage @@ -110995,6 +116510,8 @@ self: { ]; description = "Capstone bindings for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) capstone;}; "haquery" = callPackage @@ -111010,6 +116527,8 @@ self: { ]; description = "jQuery for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haquil" = callPackage @@ -111031,6 +116550,7 @@ self: { ]; description = "A Haskell implementation of the Quil instruction set for quantum computing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "har" = callPackage @@ -111063,6 +116583,8 @@ self: { executableSystemDepends = [ openssl sqlite ]; description = "Networked content addressed backup and restore software"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openssl; inherit (pkgs) sqlite;}; "hardware-edsl" = callPackage @@ -111080,6 +116602,7 @@ self: { ]; description = "Deep embedding of hardware descriptions with code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "harg" = callPackage @@ -111097,6 +116620,7 @@ self: { testHaskellDepends = [ base ]; description = "Haskell program configuration using higher kinded data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hark" = callPackage @@ -111115,6 +116639,7 @@ self: { ]; description = "A Gentoo package query tool"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "harmony" = callPackage @@ -111140,6 +116665,7 @@ self: { ]; description = "A web service specification compiler that generates implementation and tests"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "haroonga" = callPackage @@ -111156,6 +116682,8 @@ self: { libraryPkgconfigDepends = [ groonga ]; description = "Low level bindings for Groonga"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) groonga;}; "haroonga-httpd" = callPackage @@ -111174,6 +116702,7 @@ self: { ]; description = "Yet another Groonga http server"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "harp" = callPackage @@ -111201,6 +116730,8 @@ self: { ]; description = "Runtime code generation for x86 machine code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "harvest-api" = callPackage @@ -111221,6 +116752,8 @@ self: { ]; description = "Bindings for Harvest API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "has" = callPackage @@ -111234,6 +116767,8 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Entity based records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "has-th" = callPackage @@ -111245,6 +116780,7 @@ self: { libraryHaskellDepends = [ base has template-haskell ]; description = "Template Haskell function for Has records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hasbolt" = callPackage @@ -111290,6 +116826,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Extras for hasbolt library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hascal" = callPackage @@ -111366,6 +116904,8 @@ self: { ]; description = "A TUI for reviewing notes using 'flashcards' written with markdown-like syntax"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hascas" = callPackage @@ -111387,6 +116927,8 @@ self: { ]; description = "Cassandra driver for haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hascat" = callPackage @@ -111481,6 +117023,8 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Hashing tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hash-store" = callPackage @@ -111594,6 +117138,8 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Higher-rank Hashable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hashable-generics" = callPackage @@ -111612,6 +117158,8 @@ self: { benchmarkHaskellDepends = [ base criterion ghc-prim hashable ]; description = "Automatically generates Hashable instances with GHC.Generics."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hashable-orphans" = callPackage @@ -111625,6 +117173,8 @@ self: { libraryHaskellDepends = [ base hashable sorted-list time ]; description = "Provides instances missing from Hashable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hashable-time" = callPackage @@ -111654,6 +117204,8 @@ self: { ]; description = "Principled, portable & extensible hashing of data and types, including an implementation of the FNV-1a and SipHash algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hashed-storage" = callPackage @@ -111672,6 +117224,8 @@ self: { ]; description = "Hashed file storage support code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hashflare" = callPackage @@ -111685,6 +117239,7 @@ self: { libraryHaskellDepends = [ base containers simple-money ]; description = "A library for working with HashFlare.io contracts and hashrates"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "hashids" = callPackage @@ -111785,6 +117340,8 @@ self: { ]; description = "Efficient consistent hashing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hashtable-benchmark" = callPackage @@ -111845,6 +117402,8 @@ self: { ]; description = "Extensions for a \"hashtables\" library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasim" = callPackage @@ -111856,6 +117415,8 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Process-Based Discrete Event Simulation library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hask" = callPackage @@ -111873,6 +117434,8 @@ self: { ]; description = "Categories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hask-home" = callPackage @@ -111891,6 +117454,7 @@ self: { ]; description = "Generate homepages for cabal packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskades" = callPackage @@ -111970,6 +117534,7 @@ self: { ]; description = "A dialect of haskell with order of execution based on dependency resolution"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "haskbot-core" = callPackage @@ -111990,6 +117555,8 @@ self: { ]; description = "Easily-extensible chatbot for Slack messaging service"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskdeep" = callPackage @@ -112014,6 +117581,7 @@ self: { ]; description = "Computes and audits file hashes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskdogs" = callPackage @@ -112050,6 +117618,7 @@ self: { ]; description = "A small scheme interpreter"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "haskeline_0_8_1_2" = callPackage @@ -112086,6 +117655,8 @@ self: { libraryHaskellDepends = [ base haskeline mtl ]; description = "Class interface for working with Haskeline"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskeline-repl" = callPackage @@ -112109,6 +117680,8 @@ self: { libraryHaskellDepends = [ base containers mtl protolude text ]; description = "Write Emacs module in Haskell, using Emacs 25's Dynamic Module feature"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-abci" = callPackage @@ -112134,6 +117707,7 @@ self: { ]; description = "Haskell Application BlockChain Interface (ABCI) Server Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-aliyun" = callPackage @@ -112156,6 +117730,7 @@ self: { ]; description = "haskell client of aliyun service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-awk" = callPackage @@ -112191,6 +117766,8 @@ self: { ]; description = "Transform text from the command-line using Haskell expressions"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-bcrypt" = callPackage @@ -112229,6 +117806,7 @@ self: { ]; description = "Complete BitMEX Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-bitmex-rest" = callPackage @@ -112256,6 +117834,8 @@ self: { ]; description = "Auto-generated bitmex API Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-brainfuck" = callPackage @@ -112275,6 +117855,8 @@ self: { ]; description = "BrainFuck interpreter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-ci" = callPackage @@ -112309,6 +117891,8 @@ self: { doHaddock = false; description = "Cabal package script generator for Travis-CI"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-cnc" = callPackage @@ -112329,6 +117913,8 @@ self: { executableHaskellDepends = [ base directory process ]; description = "Library for parallel programming in the Intel Concurrent Collections paradigm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-coffee" = callPackage @@ -112340,6 +117926,8 @@ self: { libraryHaskellDepends = [ base process ]; description = "Simple CoffeeScript API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-compression" = callPackage @@ -112359,6 +117947,8 @@ self: { ]; description = "compress files"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-conll" = callPackage @@ -112374,6 +117964,8 @@ self: { ]; description = "Core Types for NLP"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-course-preludes" = callPackage @@ -112385,6 +117977,8 @@ self: { libraryHaskellDepends = [ base deepseq ]; description = "Small modules for a Haskell course in which Haskell is taught by implementing Prelude functionality"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-dap" = callPackage @@ -112447,6 +118041,8 @@ self: { testHaskellDepends = [ base ]; description = "Client library for the Disque datastore"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-docs" = callPackage @@ -112469,6 +118065,7 @@ self: { testHaskellDepends = [ base ]; description = "A program to find and display the docs and type of a name"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-eigen-util" = callPackage @@ -112481,6 +118078,7 @@ self: { testHaskellDepends = [ base eigen vector ]; description = "Some utility functions for haskell-eigen library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-exp-parser" = callPackage @@ -112533,6 +118131,8 @@ self: { ]; description = "Haskell source code formatter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-ftp" = callPackage @@ -112559,6 +118159,7 @@ self: { ]; description = "A Haskell ftp server with configurable backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-generate" = callPackage @@ -112575,6 +118176,8 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Typesafe generation of haskell source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-gettext" = callPackage @@ -112690,6 +118293,8 @@ self: { executableHaskellDepends = [ base containers gloss ]; description = "Go and Checkers game in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-google-trends" = callPackage @@ -112720,6 +118325,8 @@ self: { testHaskellDepends = [ base template-haskell transformers ]; description = "Infer haskell code by given type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-igraph" = callPackage @@ -112742,6 +118349,8 @@ self: { ]; description = "Bindings to the igraph C library (v0.8.0)."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-import-graph" = callPackage @@ -112773,6 +118382,8 @@ self: { executableHaskellDepends = [ base HGL random ]; description = "'Asteroids' arcade games"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-kubernetes" = callPackage @@ -112792,6 +118403,8 @@ self: { ]; description = "Haskell bindings to the Kubernetes API (via swagger-codegen)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-language-server" = callPackage @@ -112933,6 +118546,8 @@ self: { ]; description = "A haskell package to build your own Language Server client"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-lsp-types" = callPackage @@ -112998,6 +118613,8 @@ self: { testHaskellDepends = [ base MonadRandom ]; description = "Machine learning in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-modbus" = callPackage @@ -113021,6 +118638,8 @@ self: { libraryHaskellDepends = [ base ghc-prim integer-gmp ]; description = "Correctly-rounded arbitrary-precision floating-point arithmetic"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-mpi" = callPackage @@ -113040,6 +118659,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Distributed parallel programming in Haskell using MPI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {open-pal = null; open-rte = null; openmpi = null;}; "haskell-names" = callPackage @@ -113063,6 +118684,8 @@ self: { ]; description = "Name resolution library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-neo4j-client" = callPackage @@ -113094,6 +118717,8 @@ self: { ]; description = "A Haskell neo4j client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-openflow" = callPackage @@ -113108,6 +118733,8 @@ self: { testHaskellDepends = [ base ]; description = "OpenFlow protocol in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-overridez" = callPackage @@ -113129,6 +118756,8 @@ self: { ]; description = "Manage nix overrides for haskell packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-packages" = callPackage @@ -113147,6 +118776,8 @@ self: { ]; description = "Haskell suite library for package management and integration with Cabal"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-pdf-presenter" = callPackage @@ -113166,6 +118797,7 @@ self: { ]; description = "Tool for presenting PDF-based presentations"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-platform-test" = callPackage @@ -113194,6 +118826,7 @@ self: { executableToolDepends = [ alex happy ]; description = "A test system for the Haskell Platform environment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-player" = callPackage @@ -113215,6 +118848,8 @@ self: { testHaskellDepends = [ base ]; description = "A terminal music player based on afplay"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-plot" = callPackage @@ -113231,6 +118866,8 @@ self: { ]; description = "A library for generating 2D plots painlessly"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-postal" = callPackage @@ -113246,6 +118883,8 @@ self: { testPkgconfigDepends = [ libpostal ]; description = "Haskell binding for the libpostal library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libpostal;}; "haskell-postgis" = callPackage @@ -113311,6 +118950,8 @@ self: { testHaskellDepends = [ base directory hspec process ]; description = "Opens a temporary file on the system's EDITOR and returns the resulting edits"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-reflect" = callPackage @@ -113327,6 +118968,7 @@ self: { ]; description = "Reflect Haskell types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-rules" = callPackage @@ -113338,6 +118980,8 @@ self: { libraryHaskellDepends = [ base syb ]; description = "A DSL for expressing natural deduction rules in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-say" = callPackage @@ -113391,6 +119035,8 @@ self: { ]; description = "Client API for Rocket Scissor Spacegoo"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-src" = callPackage @@ -113438,6 +119084,7 @@ self: { libraryHaskellDepends = [ base haskell-src-exts Hoed ]; description = "Observable orphan instances for haskell-src-exts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-src-exts-prisms" = callPackage @@ -113451,6 +119098,8 @@ self: { ]; description = "Prisms with newtype wrappers for haskell-src-exts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-src-exts-qq" = callPackage @@ -113467,6 +119116,8 @@ self: { testHaskellDepends = [ base haskell-src-exts hspec ]; description = "A quasiquoter for haskell-src-exts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-src-exts-sc" = callPackage @@ -113480,6 +119131,8 @@ self: { libraryHaskellDepends = [ base haskell-src-exts ]; description = "Pretty print haskell code with comments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-src-exts-simple" = callPackage @@ -113527,6 +119180,8 @@ self: { ]; description = "Testing code generators piece by piece"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-src-meta" = callPackage @@ -113562,6 +119217,8 @@ self: { ]; description = "Parse source to template-haskell abstract syntax"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-stack-trace-plugin" = callPackage @@ -113580,6 +119237,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "haskell-stack-trace-plugin"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-time-range" = callPackage @@ -113637,6 +119296,7 @@ self: { ]; description = "Utilities to tie up tokens to an AST"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-ast" = callPackage @@ -113653,6 +119313,7 @@ self: { ]; description = "Haskell AST for efficient tooling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-ast-fromghc" = callPackage @@ -113670,6 +119331,7 @@ self: { ]; description = "Creating the Haskell-Tools AST from GHC's representations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-ast-gen" = callPackage @@ -113686,6 +119348,7 @@ self: { ]; description = "Facilities for generating new parts of the Haskell-Tools AST"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-ast-trf" = callPackage @@ -113701,6 +119364,7 @@ self: { ]; description = "Conversions on Haskell-Tools AST to prepare for refactorings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-backend-ghc" = callPackage @@ -113718,6 +119382,7 @@ self: { ]; description = "Creating the Haskell-Tools AST from GHC's representations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-builtin-refactorings" = callPackage @@ -113749,6 +119414,7 @@ self: { ]; description = "Refactoring Tool for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-cli" = callPackage @@ -113784,6 +119450,7 @@ self: { ]; description = "Command-line frontend for Haskell-tools Refact"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-daemon" = callPackage @@ -113817,6 +119484,7 @@ self: { ]; description = "Background process for Haskell-tools that editors can connect to"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-debug" = callPackage @@ -113841,6 +119509,7 @@ self: { executableHaskellDepends = [ base ]; description = "Debugging Tools for Haskell-tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-demo" = callPackage @@ -113871,6 +119540,7 @@ self: { ]; description = "A web-based demo for Haskell-tools Refactor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-experimental-refactorings" = callPackage @@ -113901,6 +119571,7 @@ self: { ]; description = "Refactoring Tool for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-prettyprint" = callPackage @@ -113917,6 +119588,7 @@ self: { ]; description = "Pretty printing of Haskell-Tools AST"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-refactor" = callPackage @@ -113946,6 +119618,7 @@ self: { ]; description = "Refactoring Tool for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tools-rewrite" = callPackage @@ -113967,6 +119640,7 @@ self: { ]; description = "Facilities for generating new parts of the Haskell-Tools AST"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-tor" = callPackage @@ -114000,6 +119674,7 @@ self: { ]; description = "A Haskell Tor Node"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskell-type-exts" = callPackage @@ -114013,6 +119688,8 @@ self: { ]; description = "A type checker for Haskell/haskell-src-exts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-typescript" = callPackage @@ -114024,6 +119701,8 @@ self: { libraryHaskellDepends = [ base process ]; description = "Simple TypeScript API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-tyrant" = callPackage @@ -114035,6 +119714,8 @@ self: { libraryHaskellDepends = [ base binary bytestring network ]; description = "Haskell implementation of the Tokyo Tyrant binary protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell-updater" = callPackage @@ -114088,6 +119769,8 @@ self: { libraryHaskellDepends = [ array base ghc-prim ]; description = "Compatibility with Haskell 2010"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell2020" = callPackage @@ -114099,6 +119782,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Haskell 2020[draft] Standard Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell98" = callPackage @@ -114114,6 +119799,8 @@ self: { ]; description = "Compatibility with Haskell 98"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskell98libraries" = callPackage @@ -114129,6 +119816,8 @@ self: { ]; description = "Compatibility with Haskell 98"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskelldb" = callPackage @@ -114144,6 +119833,8 @@ self: { ]; description = "A library of combinators for generating and executing SQL statements"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskelldb-connect-hdbc" = callPackage @@ -114155,6 +119846,7 @@ self: { libraryHaskellDepends = [ base containers haskelldb HDBC ]; description = "Bracketed HDBC session for HaskellDB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-connect-hdbc-catchio-mtl" = callPackage @@ -114170,6 +119862,7 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using MonadCatchIO-mtl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-connect-hdbc-catchio-tf" = callPackage @@ -114186,6 +119879,7 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using MonadCatchIO-transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-connect-hdbc-catchio-transformers" = callPackage @@ -114202,6 +119896,7 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using MonadCatchIO-transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-connect-hdbc-lifted" = callPackage @@ -114218,6 +119913,7 @@ self: { ]; description = "Bracketed HaskellDB HDBC session using lifted-base"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-dynamic" = callPackage @@ -114232,6 +119928,7 @@ self: { executableHaskellDepends = [ haskelldb ]; description = "HaskellDB support for the dynamically loaded drivers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-flat" = callPackage @@ -114249,6 +119946,7 @@ self: { ]; description = "An experimental HaskellDB back-end in pure Haskell (no SQL)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hdbc" = callPackage @@ -114264,6 +119962,7 @@ self: { ]; description = "HaskellDB support for HDBC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hdbc-mysql" = callPackage @@ -114281,6 +119980,7 @@ self: { ]; description = "HaskellDB support for the HDBC MySQL driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hdbc-odbc" = callPackage @@ -114298,6 +119998,7 @@ self: { ]; description = "HaskellDB support for the HDBC ODBC driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hdbc-postgresql" = callPackage @@ -114316,6 +120017,7 @@ self: { executableSystemDepends = [ postgresql ]; description = "HaskellDB support for the HDBC PostgreSQL driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) postgresql;}; "haskelldb-hdbc-sqlite3" = callPackage @@ -114333,6 +120035,7 @@ self: { ]; description = "HaskellDB support for the HDBC SQLite driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hsql" = callPackage @@ -114344,6 +120047,7 @@ self: { libraryHaskellDepends = [ base haskelldb hsql mtl old-time ]; description = "HaskellDB support for HSQL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hsql-mysql" = callPackage @@ -114361,6 +120065,7 @@ self: { ]; description = "HaskellDB support for the HSQL MySQL driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hsql-odbc" = callPackage @@ -114378,6 +120083,7 @@ self: { ]; description = "HaskellDB support for the HSQL ODBC driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hsql-oracle" = callPackage @@ -114414,6 +120120,7 @@ self: { ]; description = "HaskellDB support for the HSQL PostgreSQL driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-hsql-sqlite" = callPackage @@ -114450,6 +120157,7 @@ self: { ]; description = "HaskellDB support for the HSQL SQLite3 driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-th" = callPackage @@ -114461,6 +120169,7 @@ self: { libraryHaskellDepends = [ base haskelldb mtl template-haskell ]; description = "Template Haskell utilities for HaskellDB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskelldb-wx" = callPackage @@ -114471,6 +120180,8 @@ self: { sha256 = "01652m0bym80400navqlpdv5n0gfgnfzd1d0857f3kd13ksqk2hy"; description = "HaskellDB support for WXHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskellish" = callPackage @@ -114509,6 +120220,8 @@ self: { ]; description = "A scrabble library capturing the core game logic of scrabble"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskellscript" = callPackage @@ -114526,6 +120239,8 @@ self: { ]; description = "Command line tool for running Haskell scripts with a hashbang"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskelm" = callPackage @@ -114575,6 +120290,8 @@ self: { ]; description = "CP in Haskell through MiniZinc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskeme" = callPackage @@ -114589,6 +120306,8 @@ self: { executableHaskellDepends = [ base ]; description = "Compiler from I- to S-Expressions for the Scheme Programming Language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskey" = callPackage @@ -114616,6 +120335,8 @@ self: { ]; description = "A transactional, ACID compliant, embeddable key-value store"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskey-btree" = callPackage @@ -114659,6 +120380,7 @@ self: { ]; description = "A monad transformer supporting Haskey transactions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskgame" = callPackage @@ -114670,6 +120392,7 @@ self: { libraryHaskellDepends = [ base containers haskell98 SDL SDL-ttf ]; description = "Haskell game library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskheap" = callPackage @@ -114686,6 +120409,8 @@ self: { ]; description = "Haskell bindings to refheap"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskhol-core" = callPackage @@ -114705,6 +120430,8 @@ self: { ]; description = "The core logical system of HaskHOL, an EDSL for HOL theorem proving"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskintex" = callPackage @@ -114741,6 +120468,8 @@ self: { ]; description = "A haskell wrapper for PokeAPI.co (www.pokeapi.co)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskoin" = callPackage @@ -114766,6 +120495,8 @@ self: { ]; description = "Implementation of the Bitcoin protocol"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskoin-bitcoind" = callPackage @@ -114783,6 +120514,7 @@ self: { ]; description = "An adapter for haskoin to network-bitcoin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-core" = callPackage @@ -114814,6 +120546,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bitcoin & Bitcoin Cash library for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-crypto" = callPackage @@ -114836,6 +120569,7 @@ self: { ]; description = "Implementation of Bitcoin cryptographic primitives"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-node" = callPackage @@ -114867,6 +120601,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "P2P library for Bitcoin and Bitcoin Cash"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-protocol" = callPackage @@ -114889,6 +120624,7 @@ self: { ]; description = "Implementation of the Bitcoin network protocol messages"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-script" = callPackage @@ -114913,6 +120649,7 @@ self: { ]; description = "Implementation of Bitcoin script parsing and evaluation"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-store" = callPackage @@ -114962,6 +120699,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Storage and index for Bitcoin and Bitcoin Cash"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-store-data" = callPackage @@ -114990,6 +120728,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Data for Haskoin Store"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haskoin-util" = callPackage @@ -115012,6 +120751,8 @@ self: { ]; description = "Utility functions for the Network.Haskoin project"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskoin-wallet" = callPackage @@ -115054,6 +120795,7 @@ self: { ]; description = "Implementation of a Bitcoin SPV Wallet with BIP32 and multisig support"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "haskoon" = callPackage @@ -115071,6 +120813,7 @@ self: { ]; description = "Web Application Abstraction"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "haskoon-httpspec" = callPackage @@ -115086,6 +120829,7 @@ self: { ]; description = "Integrating HttpSpec with Haskoon"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "haskoon-salvia" = callPackage @@ -115103,6 +120847,7 @@ self: { ]; description = "Integrating HttpSpec with Haskoon"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "haskore" = callPackage @@ -115127,6 +120872,8 @@ self: { ]; description = "The Haskore Computer Music System"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskore-realtime" = callPackage @@ -115144,6 +120891,7 @@ self: { ]; description = "Routines for realtime playback of Haskore songs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "haskore-supercollider" = callPackage @@ -115165,6 +120913,7 @@ self: { ]; description = "Haskore back-end for SuperCollider"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "haskore-synthesizer" = callPackage @@ -115184,6 +120933,7 @@ self: { ]; description = "Music rendering coded in Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "haskore-vintage" = callPackage @@ -115277,6 +121027,7 @@ self: { doHaddock = false; description = "Torch for tensors and neural networks in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hasktorch-codegen" = callPackage @@ -115306,6 +121057,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Code generation tools for Hasktorch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasktorch-ffi-tests" = callPackage @@ -115340,6 +121093,8 @@ self: { ]; description = "Bindings to Torch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {ATen = null;}; "hasktorch-ffi-thc" = callPackage @@ -115362,6 +121117,7 @@ self: { ]; description = "Bindings to Cutorch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {ATen = null;}; "hasktorch-indef" = callPackage @@ -115390,6 +121146,7 @@ self: { doHaddock = false; description = "Core Hasktorch abstractions wrapping FFI bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hasktorch-signatures" = callPackage @@ -115415,6 +121172,7 @@ self: { doHaddock = false; description = "Backpack signatures for Tensor operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hasktorch-signatures-partial" = callPackage @@ -115430,6 +121188,8 @@ self: { ]; description = "Functions to partially satisfy tensor signatures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasktorch-signatures-support" = callPackage @@ -115446,6 +121206,8 @@ self: { doHaddock = false; description = "Signatures for support tensors in hasktorch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasktorch-signatures-types" = callPackage @@ -115506,6 +121268,7 @@ self: { ]; description = "Neural architectures in hasktorch"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskus-binary" = callPackage @@ -115530,6 +121293,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Haskus binary format manipulation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskus-system-build" = callPackage @@ -115587,6 +121352,7 @@ self: { ]; description = "Compatibility modules with other external packages (ByteString, etc.)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskus-utils-data" = callPackage @@ -115654,6 +121420,7 @@ self: { ]; description = "Haskus web"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haskyapi" = callPackage @@ -115685,6 +121452,8 @@ self: { ]; description = "HTTP server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haslo" = callPackage @@ -115699,6 +121468,7 @@ self: { executableHaskellDepends = [ mtl old-time QuickCheck time wtk ]; description = "Loan calculator engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hasloGUI" = callPackage @@ -115717,6 +121487,7 @@ self: { ]; description = "Loan calculator Gtk GUI. Based on haslo (Haskell Loan) library."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hasmin" = callPackage @@ -115747,6 +121518,8 @@ self: { benchmarkHaskellDepends = [ base criterion directory text ]; description = "CSS Minifier"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasparql-client" = callPackage @@ -115758,6 +121531,7 @@ self: { libraryHaskellDepends = [ base HTTP monads-fd network xml ]; description = "This package enables to write SPARQL queries to remote endpoints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haspell" = callPackage @@ -115812,6 +121586,8 @@ self: { ]; description = "API for backends of \"hasql\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasql-class" = callPackage @@ -115834,6 +121610,8 @@ self: { ]; description = "Encodable and Decodable classes for hasql"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasql-cursor-query" = callPackage @@ -115856,6 +121634,7 @@ self: { ]; description = "A declarative abstraction over PostgreSQL Cursor"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hasql-cursor-transaction" = callPackage @@ -115873,6 +121652,8 @@ self: { ]; description = "An abstraction for simultaneous fetching from multiple PostgreSQL cursors"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasql-dynamic-statements" = callPackage @@ -115893,6 +121674,8 @@ self: { ]; description = "Toolkit for constructing Hasql statements dynamically"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasql-generic" = callPackage @@ -115911,6 +121694,8 @@ self: { ]; description = "Generic encoder and decoder deriving for Hasql"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasql-implicits" = callPackage @@ -116044,6 +121829,7 @@ self: { ]; description = "A \"PostgreSQL\" backend for the \"hasql\" library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hasql-postgres-options" = callPackage @@ -116058,6 +121844,7 @@ self: { ]; description = "An \"optparse-applicative\" parser for \"hasql-postgres\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hasql-queue" = callPackage @@ -116092,6 +121879,7 @@ self: { ]; description = "A PostgreSQL backed queue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hasql-simple" = callPackage @@ -116108,6 +121896,8 @@ self: { ]; description = "A somewhat opinionated \"simpler\" API to hasql"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasql-th" = callPackage @@ -116203,6 +121993,8 @@ self: { ]; description = "Haskell implementation of Mustache templates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hastache-aeson" = callPackage @@ -116219,6 +122011,7 @@ self: { ]; description = "render hastache templates using aeson values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haste" = callPackage @@ -116232,6 +122025,8 @@ self: { executableHaskellDepends = [ base curl filepath mtl ]; description = "A universal pastebin tool, written in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haste-app" = callPackage @@ -116251,6 +122046,7 @@ self: { ]; description = "Framework for type-safe, distributed web applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haste-compiler" = callPackage @@ -116313,6 +122109,7 @@ self: { ]; description = "Base libraries for haste-compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "haste-markup" = callPackage @@ -116327,6 +122124,7 @@ self: { ]; description = "A port of blaze-markup and blaze-html to Haste"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "haste-perch" = callPackage @@ -116350,6 +122148,8 @@ self: { libraryHaskellDepends = [ base ghc-prim integer-gmp ]; description = "Low level primitives for the Haste compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hastily" = callPackage @@ -116432,6 +122232,8 @@ self: { ]; description = "HaTeX User's Guide"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hatexmpp3" = callPackage @@ -116505,6 +122307,8 @@ self: { ]; description = "Haskell client for the NATS messaging system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hatt" = callPackage @@ -116527,6 +122331,8 @@ self: { ]; description = "A truth table generator for classical propositional logic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haveibeenpwned" = callPackage @@ -116568,6 +122374,8 @@ self: { ]; description = "Recursively retrieve maven dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haverer" = callPackage @@ -116592,6 +122400,8 @@ self: { ]; description = "Implementation of the rules of Love Letter"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hawitter" = callPackage @@ -116613,6 +122423,7 @@ self: { ]; description = "A twitter client for GTK+. Beta version."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hax" = callPackage @@ -116638,6 +122449,8 @@ self: { ]; description = "Haskell cash-flow and tax simulation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haxl" = callPackage @@ -116680,6 +122493,8 @@ self: { ]; description = "Haxl data source for accessing AWS services through amazonka"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haxl-facebook" = callPackage @@ -116702,6 +122517,8 @@ self: { ]; description = "An example Haxl data source for accessing the Facebook Graph API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haxparse" = callPackage @@ -116726,6 +122543,8 @@ self: { ]; description = "Readable HaxBall replays"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haxr" = callPackage @@ -116757,6 +122576,8 @@ self: { libraryHaskellDepends = [ base haxr template-haskell ]; description = "Automatic deriving of XML-RPC structs for Haskell records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haxy" = callPackage @@ -116773,6 +122594,7 @@ self: { ]; description = "A simple HTTP proxy server library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hayland" = callPackage @@ -116793,6 +122615,8 @@ self: { testHaskellDepends = [ base process xml ]; description = "Haskell bindings for the C Wayland library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libGL; inherit (pkgs) wayland;}; "hayoo-cli" = callPackage @@ -116811,6 +122635,8 @@ self: { ]; description = "Hayoo CLI"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hback" = callPackage @@ -116829,6 +122655,7 @@ self: { ]; description = "N-back memory game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hbayes" = callPackage @@ -116858,6 +122685,7 @@ self: { ]; description = "Bayesian Networks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hbb" = callPackage @@ -116874,6 +122702,7 @@ self: { ]; description = "Haskell Busy Bee, a backend for text editors"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "hbcd" = callPackage @@ -116885,6 +122714,7 @@ self: { libraryHaskellDepends = [ base bytestring Decimal digits split ]; description = "Packed binary-coded decimal (BCD) serialization"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hbeanstalk" = callPackage @@ -116900,6 +122730,8 @@ self: { ]; description = "Client for the beanstalkd workqueue service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hbeat" = callPackage @@ -116918,6 +122750,8 @@ self: { executableSystemDepends = [ SDL_mixer ]; description = "A simple step sequencer GUI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) SDL_mixer;}; "hbf" = callPackage @@ -116954,6 +122788,7 @@ self: { ]; description = "An optimizing Brainfuck compiler and evaluator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hblas" = callPackage @@ -116971,6 +122806,8 @@ self: { testHaskellDepends = [ base hspec primitive vector ]; description = "Human friendly BLAS and Lapack bindings for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) blas; liblapack = null;}; "hblock" = callPackage @@ -116990,6 +122827,8 @@ self: { ]; description = "A mutable vector that provides indexation on the datatype fields it stores"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hbro" = callPackage @@ -117077,6 +122916,8 @@ self: { executableToolDepends = [ alex happy ]; description = "Haskell Bottom Up Rewrite Generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcad" = callPackage @@ -117088,6 +122929,8 @@ self: { libraryHaskellDepends = [ base containers gasp mtl ]; description = "Haskell CAD library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcc" = callPackage @@ -117101,6 +122944,8 @@ self: { executableHaskellDepends = [ base bytestring language-c ]; description = "A toy C compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcg-minus" = callPackage @@ -117113,6 +122958,8 @@ self: { libraryHaskellDepends = [ base colour random ]; description = "haskell cg (minus)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcg-minus-cairo" = callPackage @@ -117128,6 +122975,7 @@ self: { ]; description = "haskell cg (minus) (cairo rendering)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hcheat" = callPackage @@ -117140,6 +122988,7 @@ self: { libraryHaskellDepends = [ base mps ]; description = "A collection of code cheatsheet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hcheckers" = callPackage @@ -117173,6 +123022,7 @@ self: { ]; description = "Implementation of checkers (\"draughts\") board game - server application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hchesslib" = callPackage @@ -117189,6 +123039,8 @@ self: { ]; description = "Chess library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcltest" = callPackage @@ -117209,6 +123061,8 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "A testing library for command line applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcoap" = callPackage @@ -117231,6 +123085,8 @@ self: { ]; description = "CoAP implementation for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcobs" = callPackage @@ -117265,6 +123121,8 @@ self: { doHaddock = false; description = "Haskell COM support library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcoord" = callPackage @@ -117302,6 +123160,8 @@ self: { ]; description = "Haskell name counts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcron" = callPackage @@ -117318,6 +123178,8 @@ self: { ]; description = "A simple job scheduler, which just runs some IO action at a given time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcube" = callPackage @@ -117338,6 +123200,8 @@ self: { ]; description = "Virtual Rubik's cube of arbitrary size"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hcwiid" = callPackage @@ -117383,6 +123247,8 @@ self: { ]; description = "Library to handle the details of writing daemons for UNIX"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdbc-aeson" = callPackage @@ -117399,6 +123265,8 @@ self: { ]; description = "Deserialize from HDBC rows to FromJSON instances"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdbc-postgresql-hstore" = callPackage @@ -117410,6 +123278,8 @@ self: { libraryHaskellDepends = [ attoparsec base containers HDBC text ]; description = "Manipulate data in PostgreSQL \"hstore\" columns"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdbc-tuple" = callPackage @@ -117448,6 +123318,7 @@ self: { ]; description = "Haskell Database Independent interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdbi-conduit" = callPackage @@ -117468,6 +123339,7 @@ self: { ]; description = "Conduit glue for HDBI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdbi-postgresql" = callPackage @@ -117495,6 +123367,7 @@ self: { ]; description = "PostgreSQL driver for hdbi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdbi-sqlite" = callPackage @@ -117514,6 +123387,7 @@ self: { ]; description = "SQlite driver for HDBI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdbi-tests" = callPackage @@ -117533,6 +123407,7 @@ self: { ]; description = "test suite for testing HDBI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdevtools" = callPackage @@ -117552,6 +123427,8 @@ self: { ]; description = "Persistent GHC powered background server for FAST haskell development tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdf" = callPackage @@ -117569,6 +123446,7 @@ self: { ]; description = "HDF: Uniform Rate Audio Signal Processing in Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hdf5-lite" = callPackage @@ -117621,6 +123499,7 @@ self: { ]; description = "Pattern-Expression-based differencing of arbitrary types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hdigest" = callPackage @@ -117635,6 +123514,8 @@ self: { ]; description = "Server-side HTTP Digest (RFC2617) in the CGI monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdirect" = callPackage @@ -117653,6 +123534,7 @@ self: { executableToolDepends = [ happy ]; description = "An IDL compiler for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdis86" = callPackage @@ -117664,6 +123546,8 @@ self: { libraryHaskellDepends = [ base bytestring containers QuickCheck ]; description = "Interface to the udis86 disassembler for x86 and x86-64 / AMD64"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdiscount" = callPackage @@ -117676,6 +123560,8 @@ self: { librarySystemDepends = [ markdown ]; description = "Haskell bindings to the Discount markdown library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {markdown = null;}; "hdm" = callPackage @@ -117689,6 +123575,8 @@ self: { executableHaskellDepends = [ base directory process unix vty ]; description = "a small display manager"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdo" = callPackage @@ -117716,6 +123604,8 @@ self: { ]; description = "A Digital Ocean client in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdocs" = callPackage @@ -117740,6 +123630,7 @@ self: { testHaskellDepends = [ base containers mtl ]; description = "Haskell docs tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdph" = callPackage @@ -117766,6 +123657,7 @@ self: { ]; description = "Haskell distributed parallel Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hdph-closure" = callPackage @@ -117781,6 +123673,8 @@ self: { ]; description = "Explicit closures in Haskell distributed parallel Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hdr-histogram" = callPackage @@ -117800,6 +123694,8 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq primitive ]; description = "Haskell implementation of High Dynamic Range (HDR) Histograms"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "headed-megaparsec" = callPackage @@ -117834,6 +123730,8 @@ self: { ]; description = "Creates a header for a haskell source file"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "headroom" = callPackage @@ -117891,6 +123789,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "interactively inspect Haskell values at runtime"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heaps" = callPackage @@ -117933,6 +123833,8 @@ self: { executableHaskellDepends = [ array base ]; description = "Heapsort of MArrays as a demo of imperative programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heart-app" = callPackage @@ -117948,6 +123850,7 @@ self: { ]; description = "An opinionated app prelude and framework in the UnliftIO style"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "heart-core" = callPackage @@ -117967,6 +123870,8 @@ self: { ]; description = "An opinionated library prelude in the UnliftIO style"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heartbeat-streams" = callPackage @@ -118007,6 +123912,7 @@ self: { ]; description = "Find and annotate ITDs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "heatitup-complete" = callPackage @@ -118063,6 +123969,7 @@ self: { ]; description = "Simle api for heavy logger"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "heavy-logger" = callPackage @@ -118084,6 +123991,7 @@ self: { ]; description = "Full-weight logging based on fast-logger"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "heavy-logger-amazon" = callPackage @@ -118099,6 +124007,7 @@ self: { ]; description = "heavy-logger compatibility with amazonka-core logging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "heavy-logger-instances" = callPackage @@ -118119,6 +124028,7 @@ self: { ]; description = "Orphan instances for data types in heavy-logger package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hebrew-time" = callPackage @@ -118131,6 +124041,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck time ]; description = "Hebrew dates and prayer times"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hecc" = callPackage @@ -118143,6 +124055,7 @@ self: { libraryHaskellDepends = [ base cereal crypto-api hF2 ]; description = "Elliptic Curve Cryptography for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "heckin" = callPackage @@ -118174,6 +124087,8 @@ self: { executableHaskellDepends = [ base directory process split ]; description = "Jekyll in Haskell (feat. LaTeX)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedgehog" = callPackage @@ -118213,6 +124128,8 @@ self: { ]; testHaskellDepends = [ base either hedgehog ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedgehog-checkers-lens" = callPackage @@ -118224,6 +124141,7 @@ self: { libraryHaskellDepends = [ base hedgehog hedgehog-checkers lens ]; testHaskellDepends = [ base hedgehog hedgehog-checkers lens ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hedgehog-classes" = callPackage @@ -118319,6 +124237,7 @@ self: { ]; description = "JSON generators for Hedgehog"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hedgehog-generic" = callPackage @@ -118330,6 +124249,8 @@ self: { libraryHaskellDepends = [ base hedgehog ]; description = "GHC Generics automatically derived hedgehog generators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedgehog-golden" = callPackage @@ -118347,6 +124268,8 @@ self: { testHaskellDepends = [ base hedgehog ]; description = "Golden testing capabilities for hedgehog using Aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedgehog-quickcheck" = callPackage @@ -118383,6 +124306,8 @@ self: { ]; description = "Hedgehog property testing for Servant APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedis" = callPackage @@ -118423,6 +124348,8 @@ self: { ]; description = "Easy trivial configuration for Redis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedis-envy" = callPackage @@ -118464,6 +124391,8 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedis-pile" = callPackage @@ -118485,6 +124414,7 @@ self: { ]; description = "Caching mandatory data with Redis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hedis-simple" = callPackage @@ -118496,6 +124426,8 @@ self: { libraryHaskellDepends = [ base bytestring either hedis mtl ]; description = "A simplified API for hedis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedis-tags" = callPackage @@ -118513,6 +124445,8 @@ self: { ]; description = "Tags for hedis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedn" = callPackage @@ -118566,6 +124500,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "A small library and executable for generating dice rolls"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heidi" = callPackage @@ -118593,6 +124529,7 @@ self: { benchmarkHaskellDepends = [ base criterion weigh ]; description = "Tidy data in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hein" = callPackage @@ -118611,6 +124548,8 @@ self: { ]; description = "An extensible build helper for haskell, in the vein of leiningen"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heist" = callPackage @@ -118669,6 +124608,7 @@ self: { ]; description = "Use JSON directly from Heist templates"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "heist-async" = callPackage @@ -118682,6 +124622,8 @@ self: { ]; description = "Adding support for asynchronous updates (\"AJAX\") with heist"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "helf" = callPackage @@ -118727,6 +124669,7 @@ self: { ]; description = "New Relic® agent SDK wrapper for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {newrelic-collector-client = null; newrelic-common = null; newrelic-transaction = null;}; @@ -118745,6 +124688,7 @@ self: { ]; description = "New Relic® agent SDK wrapper for wai"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "helisp" = callPackage @@ -118758,6 +124702,8 @@ self: { executableHaskellDepends = [ base containers mtl parsec process ]; description = "An incomplete Elisp compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "helium" = callPackage @@ -118781,6 +124727,7 @@ self: { ]; description = "The Helium Compiler"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "helium-overture" = callPackage @@ -118820,6 +124767,8 @@ self: { ]; description = "Web development micro framework for haskell with typesafe URLs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hell" = callPackage @@ -118844,6 +124793,8 @@ self: { executableHaskellDepends = [ base transformers utf8-string ]; description = "A Haskell shell based on shell-conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hellage" = callPackage @@ -118863,6 +124814,7 @@ self: { ]; description = "Distributed hackage mirror"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hellnet" = callPackage @@ -118887,6 +124839,7 @@ self: { ]; description = "Simple, distributed, anonymous data sharing network"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hello" = callPackage @@ -118938,6 +124891,8 @@ self: { ]; description = "A Haskell client for the Help.com team's ESB."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hemkay" = callPackage @@ -118955,6 +124910,8 @@ self: { ]; description = "A module music mixer and player"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hemkay-core" = callPackage @@ -118995,6 +124952,7 @@ self: { benchmarkHaskellDepends = [ base conduit criterion mtl ]; description = "Haskell port of the Emokit EEG project"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hen" = callPackage @@ -119015,6 +124973,7 @@ self: { ]; description = "Haskell bindings to Xen hypervisor interface"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {xenctrl = null;}; "henet" = callPackage @@ -119029,6 +124988,7 @@ self: { ]; description = "Bindings and high level interface for to ENet v1.3.9"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hepevt" = callPackage @@ -119040,6 +125000,7 @@ self: { libraryHaskellDepends = [ bytestring haskell2010 lha ]; description = "HEPEVT parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "her-lexer" = callPackage @@ -119051,6 +125012,8 @@ self: { libraryHaskellDepends = [ base mtl split ]; description = "A lexer for Haskell source code"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "her-lexer-parsec" = callPackage @@ -119062,6 +125025,7 @@ self: { libraryHaskellDepends = [ base her-lexer parsec transformers ]; description = "Parsec frontend to \"her-lexer\" for Haskell source code"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "herbalizer" = callPackage @@ -119079,6 +125043,8 @@ self: { ]; description = "HAML to ERB translator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hercules-ci-agent" = callPackage @@ -119343,6 +125309,8 @@ self: { testHaskellDepends = [ base bytestring doctest text ]; description = "Heredocument on Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "herf-time" = callPackage @@ -119384,6 +125352,7 @@ self: { ]; description = "Haskell Equational Reasoning Model-to-Implementation Tunnel"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hermit-syb" = callPackage @@ -119399,6 +125368,7 @@ self: { ]; description = "HERMIT plugin for optimizing Scrap-Your-Boilerplate traversals"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "herms" = callPackage @@ -119419,6 +125389,8 @@ self: { ]; description = "A command-line manager for delicious kitchen recipes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hero-club-five-tenets" = callPackage @@ -119480,6 +125452,7 @@ self: { ]; description = "A library for compiling and serving static web assets"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "herringbone-embed" = callPackage @@ -119496,6 +125469,7 @@ self: { ]; description = "Embed preprocessed web assets in your executable with Template Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "herringbone-wai" = callPackage @@ -119512,6 +125486,7 @@ self: { ]; description = "Wai adapter for the Herringbone web asset preprocessor"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hesh" = callPackage @@ -119538,6 +125513,7 @@ self: { ]; description = "the Haskell Extensible Shell: Haskell for Bash-style scripts"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hesql" = callPackage @@ -119555,6 +125531,7 @@ self: { ]; description = "Haskell's embedded SQL"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hetero-dict" = callPackage @@ -119575,6 +125552,8 @@ self: { ]; description = "Fast heterogeneous data structures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hetero-map" = callPackage @@ -119616,6 +125595,8 @@ self: { testHaskellDepends = [ base ]; description = "Allows the use of tuples as literals for Heterogeneous collections"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heterolist" = callPackage @@ -119633,6 +125614,7 @@ self: { ]; description = "A heterogeneous list type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hetris" = callPackage @@ -119649,6 +125631,8 @@ self: { executableSystemDepends = [ ncurses ]; description = "Text Tetris"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ncurses;}; "heukarya" = callPackage @@ -119663,6 +125647,8 @@ self: { ]; description = "A genetic programming based on tree structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hevm" = callPackage @@ -119710,6 +125696,8 @@ self: { testSystemDepends = [ secp256k1 ]; description = "Ethereum virtual machine evaluator"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;}; "hevolisa" = callPackage @@ -119726,6 +125714,7 @@ self: { ]; description = "Genetic Mona Lisa problem in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hevolisa-dph" = callPackage @@ -119744,6 +125733,7 @@ self: { ]; description = "Genetic Mona Lisa problem in Haskell - using Data Parallel Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hex" = callPackage @@ -119778,6 +125768,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Haskell scripting interface for HexChat"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexdump" = callPackage @@ -119801,6 +125793,8 @@ self: { libraryHaskellDepends = [ base binary bytestring filepath ]; description = "Reading Exif data form a JPEG file with Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexmino" = callPackage @@ -119819,6 +125813,8 @@ self: { ]; description = "A small game based on domino-like hexagonal tiles"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexml" = callPackage @@ -119851,6 +125847,8 @@ self: { ]; description = "Lenses for the hexml package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexpat" = callPackage @@ -119900,6 +125898,7 @@ self: { ]; description = "Chunked XML parsing using iteratees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hexpat-lens" = callPackage @@ -119948,6 +125947,8 @@ self: { ]; description = "Picklers for de/serialising Generic data types to and from XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexpat-streamparser" = callPackage @@ -119989,6 +125990,8 @@ self: { ]; description = "A framework for symbolic, homoiconic languages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexpress" = callPackage @@ -120006,6 +126009,8 @@ self: { ]; description = "An express-like http framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexquote" = callPackage @@ -120021,6 +126026,8 @@ self: { ]; description = "Hexadecimal ByteString literals, with placeholders that bind variables"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hexstring" = callPackage @@ -120038,6 +126045,8 @@ self: { testHaskellDepends = [ base binary bytestring hspec text ]; description = "Fast and safe representation of a hex string"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hext" = callPackage @@ -120054,6 +126063,8 @@ self: { executableHaskellDepends = [ base text ]; description = "a text classification library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hextra" = callPackage @@ -120119,6 +126130,8 @@ self: { ]; description = "A server for Eye-Fi SD cards"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heyting-algebras" = callPackage @@ -120155,6 +126168,8 @@ self: { libraryPkgconfigDepends = [ fann ]; description = "Haskell binding to the FANN library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {doublefann = null; fann = null;}; "hfd" = callPackage @@ -120173,6 +126188,7 @@ self: { ]; description = "Flash debugger"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hfiar" = callPackage @@ -120188,6 +126204,7 @@ self: { executableHaskellDepends = [ wx wxcore ]; description = "Four in a Row in Haskell!!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hflags" = callPackage @@ -120228,6 +126245,8 @@ self: { ]; description = "Haskell source code formatter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hfoil" = callPackage @@ -120247,6 +126266,8 @@ self: { executableHaskellDepends = [ base ]; description = "Hess-Smith panel code for inviscid 2-d airfoil analysis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hformat" = callPackage @@ -120274,6 +126295,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Field-of-view calculation for low-resolution 2D raster grids"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hfractal" = callPackage @@ -120292,6 +126315,8 @@ self: { ]; description = "OpenGL fractal renderer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hfsevents" = callPackage @@ -120322,6 +126347,8 @@ self: { ]; description = "A library for fusing a subset of Haskell programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hg-buildpackage" = callPackage @@ -120340,6 +126367,8 @@ self: { ]; description = "Tools to help manage Debian packages with Mercurial"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgal" = callPackage @@ -120362,6 +126391,7 @@ self: { libraryHaskellDepends = [ array base haskell98 mtl ]; description = "Haskell Genetic Algorithm Library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "hgdbmi" = callPackage @@ -120380,6 +126410,8 @@ self: { ]; description = "GDB Machine Interface: program-driven control of GDB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgearman" = callPackage @@ -120397,6 +126429,8 @@ self: { ]; description = "A Gearman client for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgen" = callPackage @@ -120412,6 +126446,7 @@ self: { ]; description = "Random generation of modal and hybrid logic formulas"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hgeometric" = callPackage @@ -120423,6 +126458,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A geometric library with bindings to GPC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgeometry" = callPackage @@ -120523,6 +126560,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Reading and Writing ipe7 files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgeometry-svg" = callPackage @@ -120543,6 +126582,7 @@ self: { testHaskellDepends = [ base doctest ]; description = "Writing geometric primitives from HGeometry as SVG Files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hgeos" = callPackage @@ -120579,6 +126619,8 @@ self: { ]; description = "Bindings to libintl.h (gettext, bindtextdomain)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgis" = callPackage @@ -120602,6 +126644,8 @@ self: { doHaddock = false; description = "Library and for GIS with Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgithub" = callPackage @@ -120622,6 +126666,7 @@ self: { executableHaskellDepends = [ base cmdargs directory ]; description = "Haskell bindings to the GitHub API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hgl-example" = callPackage @@ -120669,6 +126714,8 @@ self: { ]; description = "An haskell port of the java version of gom"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgopher" = callPackage @@ -120680,6 +126727,8 @@ self: { libraryHaskellDepends = [ base bytestring network ]; description = "Gopher server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgrep" = callPackage @@ -120702,6 +126751,8 @@ self: { ]; description = "Search Haskell source code from the command line"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgrev" = callPackage @@ -120735,6 +126786,8 @@ self: { testHaskellDepends = [ base directory hspec ]; description = "Unofficial bindings for GRIB API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {grib_api = null;}; "hharp" = callPackage @@ -120747,6 +126800,8 @@ self: { librarySystemDepends = [ harp ]; description = "Binding to libharp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {harp = null;}; "hhp" = callPackage @@ -120786,6 +126841,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Bindings to https://www.open-mpi.org/projects/hwloc"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hi" = callPackage @@ -120816,6 +126873,8 @@ self: { ]; description = "Generate scaffold for cabal project"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hi-file-parser" = callPackage @@ -120851,6 +126910,8 @@ self: { executableHaskellDepends = [ base dbus process ]; description = "Status line for i3bar"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hiccup" = callPackage @@ -120870,6 +126931,7 @@ self: { ]; description = "Relatively efficient Tcl interpreter with support for basic operations"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hichi" = callPackage @@ -120883,6 +126945,8 @@ self: { executableHaskellDepends = [ array base bytestring mtl network ]; description = "haskell robot for IChat protocol"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hid" = callPackage @@ -120930,6 +126994,8 @@ self: { doHaddock = false; description = "Examples to accompany the book \"Haskell in Depth\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hidapi" = callPackage @@ -120963,6 +127029,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Provides cross-platform getHiddenChar function"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hie-bios" = callPackage @@ -121047,6 +127115,8 @@ self: { ]; description = "The core of an IDE"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hiedb" = callPackage @@ -121083,6 +127153,8 @@ self: { libraryHaskellDepends = [ base containers HUnit mtl multiset ]; description = "Automated clustering of arbitrary elements in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hierarchical-clustering" = callPackage @@ -121137,6 +127209,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "hierarchical environments for dependency injection"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hierarchical-exceptions" = callPackage @@ -121148,6 +127222,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Template Haskell functions to easily create exception hierarchies"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hierarchical-spectral-clustering" = callPackage @@ -121178,6 +127254,7 @@ self: { ]; description = "Hierarchical spectral clustering of a graph"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hierarchy" = callPackage @@ -121200,6 +127277,8 @@ self: { ]; description = "Predicated traversal of generated trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hiernotify" = callPackage @@ -121215,6 +127294,8 @@ self: { ]; description = "Notification library for a filesystem hierarchy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hifi" = callPackage @@ -121257,6 +127338,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Partial types as a type constructor"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "highWaterMark" = callPackage @@ -121271,6 +127354,8 @@ self: { executableHaskellDepends = [ base ghc ]; description = "Memory usage statistics"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "higher-leveldb" = callPackage @@ -121307,6 +127392,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Some higher order functions for Bool and []"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "highjson" = callPackage @@ -121324,6 +127411,8 @@ self: { ]; description = "Spec based JSON parsing/serialisation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "highjson-swagger" = callPackage @@ -121342,6 +127431,7 @@ self: { ]; description = "Derive swagger instances from highjson specs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "highjson-th" = callPackage @@ -121362,6 +127452,7 @@ self: { ]; description = "Template Haskell helpers for highjson specs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "highlight" = callPackage @@ -121409,6 +127500,8 @@ self: { ]; description = "Highlight package versions which differ from the latest version on Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "highlighter" = callPackage @@ -121526,6 +127619,8 @@ self: { ]; description = "Simple gtk2hs image viewer. Point it at an image and fire away."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "himpy" = callPackage @@ -121547,6 +127642,7 @@ self: { ]; description = "multithreaded snmp poller for riemann"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hindent" = callPackage @@ -121597,6 +127693,8 @@ self: { testHaskellDepends = [ base containers hspec ]; description = "Template for Hindley-Milner based languages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hinduce-associations-apriori" = callPackage @@ -121623,6 +127721,7 @@ self: { libraryHaskellDepends = [ base hinduce-missingh layout ]; description = "Interface and utilities for classifiers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hinduce-classifier-decisiontree" = callPackage @@ -121640,6 +127739,7 @@ self: { ]; description = "Decision Tree Classifiers for hInduce"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hinduce-examples" = callPackage @@ -121659,6 +127759,7 @@ self: { ]; description = "Example data for hInduce"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hinduce-missingh" = callPackage @@ -121787,6 +127888,8 @@ self: { ]; description = "Generate armet style query strings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hinstaller" = callPackage @@ -121802,6 +127905,8 @@ self: { ]; description = "Installer wrapper for Haskell applications"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hint" = callPackage @@ -121837,6 +127942,7 @@ self: { ]; description = "A server process that runs hint"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hinter" = callPackage @@ -121858,6 +127964,8 @@ self: { ]; description = "Runtime Haskell interpreter (GHC API wrapper)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hinterface" = callPackage @@ -121884,6 +127992,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell / Erlang interoperability library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hinvaders" = callPackage @@ -121898,6 +128008,7 @@ self: { executableHaskellDepends = [ base haskell98 random ]; description = "Space Invaders"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hinze-streams" = callPackage @@ -121909,6 +128020,7 @@ self: { libraryHaskellDepends = [ base haskell98 Stream ]; description = "Streams and Unique Fixed Points"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hip" = callPackage @@ -121957,6 +128069,7 @@ self: { ]; description = "A library for building HipChat Bots"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hipchat-hs" = callPackage @@ -121975,6 +128088,8 @@ self: { ]; description = "Hipchat API bindings in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hipe" = callPackage @@ -121990,6 +128105,8 @@ self: { ]; description = "Support for reading and writing ipe7 files (http://ipe7.sourceforge.net)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hips" = callPackage @@ -122015,6 +128132,8 @@ self: { sha256 = "18hwc5x902k2dsk8895sr8nil4445b9lazzdzbjzpllx4smf0lvz"; libraryHaskellDepends = [ aeson base bytestring servant ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hipsql-client" = callPackage @@ -122037,6 +128156,7 @@ self: { http-types mtl servant-client servant-client-core ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hipsql-monad" = callPackage @@ -122068,6 +128188,7 @@ self: { servant-server warp ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hircules" = callPackage @@ -122086,6 +128207,8 @@ self: { ]; description = "IRC client"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hirt" = callPackage @@ -122106,6 +128229,7 @@ self: { ]; description = "Calculates IRT 2PL and 3PL models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hissmetrics" = callPackage @@ -122121,6 +128245,8 @@ self: { ]; description = "Unofficial API bindings to KISSmetrics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hist-pl" = callPackage @@ -122144,6 +128270,7 @@ self: { ]; description = "Umbrella package for the historical dictionary of Polish"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hist-pl-dawg" = callPackage @@ -122158,6 +128285,7 @@ self: { ]; description = "A generic, DAWG-based dictionary"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hist-pl-fusion" = callPackage @@ -122174,6 +128302,7 @@ self: { ]; description = "Merging historical dictionary with PoliMorf"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hist-pl-lexicon" = callPackage @@ -122190,6 +128319,7 @@ self: { ]; description = "A binary representation of the historical dictionary of Polish"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hist-pl-lmf" = callPackage @@ -122201,6 +128331,7 @@ self: { libraryHaskellDepends = [ base hist-pl-types polysoup text ]; description = "LMF parsing for the historical dictionary of Polish"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hist-pl-transliter" = callPackage @@ -122223,6 +128354,8 @@ self: { libraryHaskellDepends = [ base binary text text-binary ]; description = "Types in the historical dictionary of Polish"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "histogram-fill" = callPackage @@ -122287,6 +128420,8 @@ self: { ]; description = "Extract the interesting bits from shell history"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hit" = callPackage @@ -122305,6 +128440,7 @@ self: { ]; description = "Git like program in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hit-graph" = callPackage @@ -122320,6 +128456,7 @@ self: { ]; description = "Use graph algorithms to access and manipulate Git repos"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "hit-on" = callPackage @@ -122341,6 +128478,8 @@ self: { testHaskellDepends = [ base github hspec text ]; description = "Haskell Git Helper Tool"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hjcase" = callPackage @@ -122357,6 +128496,8 @@ self: { ]; description = "Jcase library for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hjpath" = callPackage @@ -122386,6 +128527,8 @@ self: { ]; description = "JavaScript Parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hjsmin" = callPackage @@ -122431,6 +128574,8 @@ self: { libraryHaskellDepends = [ base containers hjson ]; description = "library for querying from JSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hjsonpointer" = callPackage @@ -122452,6 +128597,8 @@ self: { ]; description = "JSON Pointer library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hjsonschema" = callPackage @@ -122482,6 +128629,7 @@ self: { ]; description = "JSON Schema library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hjugement" = callPackage @@ -122531,6 +128679,7 @@ self: { ]; description = "Majority Judgment and Helios-C command line tool"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hjugement-protocol" = callPackage @@ -122595,6 +128744,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Definition of \"Delta structures\" for higher kinded data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hkd-lens" = callPackage @@ -122606,6 +128757,8 @@ self: { libraryHaskellDepends = [ base profunctors ]; description = "Generic lens/prism/traversal-kinded data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hkdf" = callPackage @@ -122672,6 +128825,8 @@ self: { ]; description = "A library for higher kinded types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hlatex" = callPackage @@ -122709,6 +128864,8 @@ self: { ]; description = "Haskell binding to L-BFGS-B version 3.0"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gfortran;}; "hlcm" = callPackage @@ -122730,6 +128887,7 @@ self: { ]; description = "Fast algorithm for mining closed frequent itemsets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hleap" = callPackage @@ -122820,6 +128978,7 @@ self: { ]; description = "Web API server for the hledger accounting tool"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hledger-chart" = callPackage @@ -122838,6 +128997,8 @@ self: { ]; description = "A pie chart image generator for the hledger accounting tool"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hledger-diff" = callPackage @@ -122944,6 +129105,8 @@ self: { ]; description = "computes the internal rate of return of an investment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hledger-lib" = callPackage @@ -123065,6 +129228,8 @@ self: { ]; description = "A curses-style console interface for the hledger accounting tool"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hledger-web" = callPackage @@ -123115,6 +129280,8 @@ self: { testHaskellDepends = [ base hlint ]; description = "Haskell binding to libBladeRF SDR library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libbladeRF;}; "hlibcpuid" = callPackage @@ -123142,6 +129309,8 @@ self: { librarySystemDepends = [ ev ]; description = "FFI interface to libev"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {ev = null;}; "hlibfam" = callPackage @@ -123154,6 +129323,8 @@ self: { librarySystemDepends = [ fam ]; description = "FFI interface to libFAM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fam;}; "hlibgit2" = callPackage @@ -123278,6 +129449,8 @@ self: { ]; description = "Client library for the Apache Livy REST API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hlogger" = callPackage @@ -123289,6 +129462,8 @@ self: { libraryHaskellDepends = [ base old-locale time ]; description = "Simple, concurrent, extendable and easy-to-use logging library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hlongurl" = callPackage @@ -123307,6 +129482,8 @@ self: { ]; description = "Library and utility interfacing to longurl.org"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hlrdb" = callPackage @@ -123356,6 +129533,7 @@ self: { libraryHaskellDepends = [ base containers hcg-minus hps ]; description = "Haskell Lindenmayer Systems"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hls-brittany-plugin" = callPackage @@ -123440,6 +129618,8 @@ self: { ]; description = "Common utilities to interaction between ghc-exactprint and HLS plugins"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hls-explicit-imports-plugin" = callPackage @@ -123640,6 +129820,8 @@ self: { libraryHaskellDepends = [ base stm transformers unix X11 ]; description = "Bindings to the herbstluftwm window manager"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hly" = callPackage @@ -123654,6 +129836,7 @@ self: { ]; description = "Haskell LilyPond"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hmark" = callPackage @@ -123672,6 +129855,7 @@ self: { executableHaskellDepends = [ base ]; description = "A tool and library for Markov chains based text generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hmarkup" = callPackage @@ -123685,6 +129869,8 @@ self: { ]; description = "Simple wikitext-like markup format implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmatrix" = callPackage @@ -123740,6 +129926,8 @@ self: { librarySystemDepends = [ liblapack ]; description = "HMatrix interface to LAPACK functions for banded matrices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {liblapack = null;}; "hmatrix-csv" = callPackage @@ -123805,6 +129993,8 @@ self: { libraryHaskellDepends = [ base hmatrix mmap ]; description = "Memory map Vector from disk into memory efficiently"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmatrix-morpheus" = callPackage @@ -123838,6 +130028,8 @@ self: { libraryHaskellDepends = [ base hmatrix ]; description = "NIPALS method for Principal Components Analysis on large data-sets"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmatrix-nlopt" = callPackage @@ -123886,6 +130078,8 @@ self: { librarySystemDepends = [ mkl_core mkl_intel mkl_sequential ]; description = "Sparse linear solver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {mkl_core = null; mkl_intel = null; mkl_sequential = null;}; "hmatrix-special" = callPackage @@ -123912,6 +130106,8 @@ self: { ]; description = "hmatrix with vector and matrix sizes encoded in types"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmatrix-sundials" = callPackage @@ -123939,6 +130135,7 @@ self: { ]; description = "hmatrix interface to sundials"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {sundials_arkode = null; sundials_cvode = null;}; "hmatrix-svdlibc" = callPackage @@ -123954,6 +130151,8 @@ self: { benchmarkHaskellDepends = [ base criterion hmatrix vector ]; description = "SVDLIBC bindings for HMatrix"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmatrix-syntax" = callPackage @@ -123969,6 +130168,8 @@ self: { ]; description = "MATLAB-like syntax for hmatrix vectors and matrices"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmatrix-tests" = callPackage @@ -123986,6 +130187,8 @@ self: { benchmarkHaskellDepends = [ base HUnit QuickCheck random ]; description = "Tests for hmatrix"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmatrix-vector-sized" = callPackage @@ -124017,6 +130220,7 @@ self: { ]; description = "Haskell Meapsoft Parser"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hmeap-utils" = callPackage @@ -124036,6 +130240,7 @@ self: { ]; description = "Haskell Meapsoft Parser Utilities"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hmemdb" = callPackage @@ -124064,6 +130269,8 @@ self: { executableHaskellDepends = [ base MissingH process ]; description = "CLI fuzzy finder and launcher"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmep" = callPackage @@ -124083,6 +130290,7 @@ self: { testHaskellDepends = [ base HUnit vector ]; description = "HMEP Multi Expression Programming – a genetic programming variant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hmidi" = callPackage @@ -124113,6 +130321,8 @@ self: { ]; description = "A make alternative based on Plan9's mk"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmm" = callPackage @@ -124128,6 +130338,8 @@ self: { ]; description = "A hidden markov model library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmm-hmatrix" = callPackage @@ -124146,6 +130358,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Hidden Markov Models using HMatrix primitives"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hmm-lapack" = callPackage @@ -124168,6 +130382,7 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Hidden Markov Models using LAPACK primitives"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hmp3" = callPackage @@ -124188,6 +130403,8 @@ self: { executableSystemDepends = [ ncurses ]; description = "An ncurses mp3 player written in Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ncurses;}; "hmp3-ng" = callPackage @@ -124241,6 +130458,7 @@ self: { ]; description = "Haskell Music Theory"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hmt-diagrams" = callPackage @@ -124258,6 +130476,7 @@ self: { ]; description = "Haskell Music Theory Diagrams"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hmumps" = callPackage @@ -124276,6 +130495,8 @@ self: { ]; description = "Interpreter for the MUMPS langugae"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hnetcdf" = callPackage @@ -124305,6 +130526,8 @@ self: { testSystemDepends = [ netcdf ]; description = "Haskell NetCDF library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) netcdf;}; "hnix" = callPackage @@ -124498,6 +130721,7 @@ self: { ]; description = "Log message normalisation tool producing structured JSON messages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ho-rewriting" = callPackage @@ -124513,6 +130737,8 @@ self: { testHaskellDepends = [ base compdata patch-combinators ]; description = "Generic rewrite rules with safe treatment of variables and binders"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoauth" = callPackage @@ -124530,6 +130756,8 @@ self: { ]; description = "A Haskell implementation of OAuth 1.0a protocol."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoauth2" = callPackage @@ -124577,6 +130805,7 @@ self: { ]; description = "A source code editor aiming for the convenience of use"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hobbes" = callPackage @@ -124594,6 +130823,8 @@ self: { ]; description = "A small file watcher for OSX"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hobbits" = callPackage @@ -124630,6 +130861,8 @@ self: { testSystemDepends = [ ocilib ]; description = "FFI binding to OCILIB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {ocilib = null;}; "hocker" = callPackage @@ -124672,6 +130905,8 @@ self: { ]; description = "Interact with the docker registry and generate nix build instructions"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hocon" = callPackage @@ -124707,6 +130942,8 @@ self: { benchmarkHaskellDepends = [ base criterion random ]; description = "A fully featured date/time library based on Nodatime"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoe" = callPackage @@ -124725,6 +130962,8 @@ self: { ]; description = "hoe: Haskell One-liner Evaluator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hofix-mtl" = callPackage @@ -124754,6 +130993,8 @@ self: { ]; description = "Simple IRC logger bot"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hogg" = callPackage @@ -124771,6 +131012,8 @@ self: { ]; description = "Library and tools to manipulate the Ogg container format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoggl" = callPackage @@ -124811,6 +131054,7 @@ self: { doHaddock = false; description = "Haskell binding to a subset of OGRE"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {OGRE = null; OgreMain = null; cgen-hs = null; grgen = null;}; "hogre-examples" = callPackage @@ -124826,6 +131070,7 @@ self: { executableSystemDepends = [ OgreMain ]; description = "Examples for using Hogre"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {OgreMain = null;}; "hois" = callPackage @@ -124841,6 +131086,8 @@ self: { executableHaskellDepends = [ base X11 ]; description = "OIS bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {OIS = null;}; "hoist-error" = callPackage @@ -124884,6 +131131,8 @@ self: { ]; description = "Higher order logic"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hold-em" = callPackage @@ -124895,6 +131144,8 @@ self: { libraryHaskellDepends = [ base random safe ]; description = "An engine for Texas hold'em Poker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hole" = callPackage @@ -124906,6 +131157,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Higher kinded type removal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "holey-format" = callPackage @@ -124941,6 +131194,8 @@ self: { testToolDepends = [ markdown-unlit tasty-discover ]; description = "Tools and combinators for solving constraint problems"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "holy-project" = callPackage @@ -124975,6 +131230,7 @@ self: { doCheck = false; description = "Start your Haskell project with cabal, git and tests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "homeomorphic" = callPackage @@ -124986,6 +131242,8 @@ self: { libraryHaskellDepends = [ base containers mtl QuickCheck ]; description = "Homeomorphic Embedding Test"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hommage" = callPackage @@ -124999,6 +131257,7 @@ self: { ]; description = "Haskell Offline Music Manipulation And Generation EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hommage-ds" = callPackage @@ -125025,6 +131284,8 @@ self: { testHaskellDepends = [ base ]; description = "Constructs FAlgebras from typeclasses, making Haskell functions homoiconic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "homotuple" = callPackage @@ -125068,6 +131329,8 @@ self: { ]; description = "Haskell code quality tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "homura-stopwatch" = callPackage @@ -125097,6 +131360,8 @@ self: { testSystemDepends = [ freenect OpenNI2 ]; description = "OpenNI 2 binding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {OpenNI2 = null; inherit (pkgs) freenect;}; "honk" = callPackage @@ -125126,6 +131391,8 @@ self: { ]; description = "Simple tool for fetching and merging hoogle data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hood" = callPackage @@ -125138,6 +131405,7 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "Debugging by observing in place"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hood-off" = callPackage @@ -125149,6 +131417,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Dummy package to disable Hood without having to remove all the calls to observe"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hood2" = callPackage @@ -125160,6 +131430,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Debugging by observing in place"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoodie" = callPackage @@ -125177,6 +131449,7 @@ self: { ]; description = "A small, toy roguelike"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hoodle" = callPackage @@ -125197,6 +131470,7 @@ self: { executableHaskellDepends = [ base cmdargs hoodle-core ]; description = "Executable for hoodle"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hoodle-builder" = callPackage @@ -125213,6 +131487,7 @@ self: { ]; description = "text builder for hoodle file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hoodle-core" = callPackage @@ -125245,6 +131520,7 @@ self: { librarySystemDepends = [ libX11 libXi ]; description = "Core library for hoodle"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXi;}; "hoodle-extra" = callPackage @@ -125270,6 +131546,7 @@ self: { ]; description = "extra hoodle tools"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hoodle-parser" = callPackage @@ -125287,6 +131564,7 @@ self: { ]; description = "Hoodle file parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hoodle-publish" = callPackage @@ -125313,6 +131591,7 @@ self: { ]; description = "publish hoodle files as a static web site"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hoodle-render" = callPackage @@ -125333,6 +131612,7 @@ self: { ]; description = "Hoodle file renderer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hoodle-types" = callPackage @@ -125349,6 +131629,8 @@ self: { ]; description = "Data types for programs for hoodle file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoogle" = callPackage @@ -125400,6 +131682,8 @@ self: { ]; description = "Easily generate Hoogle indices for installed packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hooks-dir" = callPackage @@ -125411,6 +131695,8 @@ self: { libraryHaskellDepends = [ base directory process text ]; description = "run executables in a directory as hooks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hookup" = callPackage @@ -125448,6 +131734,8 @@ self: { ]; description = "Object-Oriented Programming in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoopl" = callPackage @@ -125467,6 +131755,8 @@ self: { ]; description = "A library to support dataflow analysis and optimization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoovie" = callPackage @@ -125490,6 +131780,7 @@ self: { ]; description = "Haskell Media Server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hopencc" = callPackage @@ -125506,6 +131797,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Haskell binding to libopencc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) opencc;}; "hopencl" = callPackage @@ -125525,6 +131818,8 @@ self: { ]; description = "Haskell bindings for OpenCL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {OpenCL = null;}; "hopenpgp-tools" = callPackage @@ -125603,6 +131898,8 @@ self: { ]; description = "Hopfield Networks, Boltzmann Machines and Clusters"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {MagickCore = null; inherit (pkgs) imagemagick;}; "hopfield-networks" = callPackage @@ -125730,6 +132027,8 @@ self: { ]; description = "Handy Operations on Power Series"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hoq" = callPackage @@ -125749,6 +132048,7 @@ self: { executableToolDepends = [ alex happy ]; description = "A language based on homotopy type theory with an interval type"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "hora" = callPackage @@ -125777,6 +132077,8 @@ self: { libraryHaskellDepends = [ AC-Angle base time ]; description = "Sunrise and sunset UTC approximations from latitude and longitude coordinates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "horname" = callPackage @@ -125795,6 +132097,8 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "Rename function definitions returned by SMT solvers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hosc" = callPackage @@ -125830,6 +132134,8 @@ self: { ]; description = "Haskell Open Sound Control JSON Serialisation"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hosc-utils" = callPackage @@ -125909,6 +132215,8 @@ self: { ]; description = "An dns server which is extremely easy to config"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hothasktags" = callPackage @@ -125927,6 +132235,8 @@ self: { ]; description = "Generates ctags for Haskell, incorporating import lists and qualified imports"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hotswap" = callPackage @@ -125938,6 +132248,8 @@ self: { libraryHaskellDepends = [ base plugins ]; description = "Simple code hotswapping"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hourglass" = callPackage @@ -125968,6 +132280,8 @@ self: { libraryHaskellDepends = [ base hourglass parsec ]; description = "A small library for parsing more human friendly date/time formats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hourglass-orphans" = callPackage @@ -126013,6 +132327,8 @@ self: { ]; description = "A Haskell implementation of Foreman"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hout" = callPackage @@ -126041,6 +132357,8 @@ self: { ]; description = "Heap profiling helper library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hp2any-graph" = callPackage @@ -126062,6 +132380,7 @@ self: { executableSystemDepends = [ freeglut libGL libGLU ]; description = "Real-time heap graphing utility and profile stream server with a reusable graphing module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) freeglut; inherit (pkgs) libGL; inherit (pkgs) libGLU;}; @@ -126083,6 +132402,7 @@ self: { ]; description = "A utility to visualise and compare heap profiles"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hp2html" = callPackage @@ -126184,6 +132504,8 @@ self: { ]; description = "Convert Cabal manifests into hpack's package.yamls"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpack-dhall" = callPackage @@ -126231,6 +132553,7 @@ self: { ]; description = "Modular template compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hpaco-lib" = callPackage @@ -126248,6 +132571,7 @@ self: { ]; description = "Modular template compiler library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hpage" = callPackage @@ -126269,6 +132593,7 @@ self: { ]; description = "A scrapbook for Haskell developers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hpapi" = callPackage @@ -126308,6 +132633,7 @@ self: { ]; description = "Haskell paste web site"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hpasteit" = callPackage @@ -126327,6 +132653,8 @@ self: { ]; description = "A command-line client for hpaste.org"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpath" = callPackage @@ -126467,6 +132795,8 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Coveralls.io support for Haskell."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpc-lcov" = callPackage @@ -126539,6 +132869,7 @@ self: { ]; description = "Tracer with AJAX interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hpdft" = callPackage @@ -126575,6 +132906,8 @@ self: { executableHaskellDepends = [ base random ]; description = "a simple password generator"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpio" = callPackage @@ -126604,6 +132937,8 @@ self: { ]; description = "Monads for GPIO in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hplayground" = callPackage @@ -126635,6 +132970,8 @@ self: { executableHaskellDepends = [ base directory filepath process ]; description = "Application for managing playlist files on a music player"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpodder" = callPackage @@ -126654,6 +132991,8 @@ self: { ]; description = "Podcast Aggregator (downloader)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpp" = callPackage @@ -126703,6 +133042,8 @@ self: { ]; description = "Haskell bindings to libpqtypes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) postgresql;}; "hpqtypes-extras" = callPackage @@ -126728,6 +133069,7 @@ self: { benchmarkHaskellDepends = [ base deepseq tasty-bench ]; description = "Extra utilities for hpqtypes library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hprotoc" = callPackage @@ -126757,6 +133099,8 @@ self: { executableToolDepends = [ alex ]; description = "Parse Google Protocol Buffer specifications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hprotoc-fork" = callPackage @@ -126785,6 +133129,7 @@ self: { executableToolDepends = [ alex ]; description = "Parse Google Protocol Buffer specifications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hprox" = callPackage @@ -126819,6 +133164,7 @@ self: { libraryHaskellDepends = [ base filepath hcg-minus process ]; description = "Haskell Postscript"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hps-cairo" = callPackage @@ -126834,6 +133180,7 @@ self: { executableHaskellDepends = [ base cairo gtk hps random ]; description = "Cairo rendering for the haskell postscript library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hps-kmeans" = callPackage @@ -126845,6 +133192,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "A nice implementation of the k-Means algorithm"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpuz" = callPackage @@ -126873,6 +133222,8 @@ self: { ]; description = "Highlight source code using Pygments"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpylos" = callPackage @@ -126888,6 +133239,8 @@ self: { ]; description = "AI of Pylos game with GLUT interface"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpyrg" = callPackage @@ -126903,6 +133256,8 @@ self: { ]; description = "pyrg utility done right"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hpython" = callPackage @@ -126932,6 +133287,7 @@ self: { ]; description = "Python language tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hquantlib" = callPackage @@ -126961,6 +133317,7 @@ self: { ]; description = "HQuantLib is a port of essencial parts of QuantLib to Haskell"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hquantlib-time" = callPackage @@ -126972,6 +133329,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "HQuantLib Time is a business calendar functions extracted from HQuantLib"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hquery" = callPackage @@ -127002,6 +133361,7 @@ self: { executableHaskellDepends = [ base HCL NonEmpty ]; description = "Basic utility for ranking a list of items"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hreader" = callPackage @@ -127021,6 +133381,7 @@ self: { testHaskellDepends = [ base hset transformers-base ]; description = "Generalization of MonadReader and ReaderT using hset"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hreader-lens" = callPackage @@ -127036,6 +133397,7 @@ self: { ]; description = "Optics for hreader package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hreq-client" = callPackage @@ -127064,6 +133426,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "A Type dependent Highlevel HTTP client library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hreq-conduit" = callPackage @@ -127088,6 +133451,7 @@ self: { testToolDepends = [ hspec-discover markdown-unlit ]; description = "Conduit streaming support for Hreq"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hreq-core" = callPackage @@ -127108,6 +133472,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Core functionality for Hreq Http client library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hrfsize" = callPackage @@ -127133,6 +133499,8 @@ self: { executableHaskellDepends = [ base containers ]; description = "A Cricket scoring application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hriemann" = callPackage @@ -127242,6 +133610,7 @@ self: { benchmarkSystemDepends = [ libb2 ]; description = "A cryptohash-inspired library for blake2"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libb2;}; "hs-brotli" = callPackage @@ -127260,6 +133629,7 @@ self: { ]; description = "Compression and decompression in the brotli format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {brotlidec = null; brotlienc = null;}; "hs-captcha" = callPackage @@ -127300,6 +133670,8 @@ self: { ]; description = "Example Monte Carlo simulations implemented with Carbon"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-cdb" = callPackage @@ -127315,6 +133687,8 @@ self: { ]; description = "A library for reading CDB (Constant Database) files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-conllu" = callPackage @@ -127364,6 +133738,8 @@ self: { ]; description = "Dependency Injection library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-dotnet" = callPackage @@ -127376,6 +133752,8 @@ self: { librarySystemDepends = [ ole32 oleaut32 ]; description = "Pragmatic .NET interop for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {ole32 = null; oleaut32 = null;}; "hs-duktape" = callPackage @@ -127413,6 +133791,8 @@ self: { ]; description = "HS-Excelx provides basic read-only access to Excel 2007 and 2010 documents in XLSX format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-ffmpeg" = callPackage @@ -127424,6 +133804,7 @@ self: { libraryHaskellDepends = [ base bytestring haskell98 ]; description = "Bindings to FFMPEG library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hs-fltk" = callPackage @@ -127437,6 +133818,8 @@ self: { librarySystemDepends = [ fltk fltk_images ]; description = "Binding to GUI library FLTK"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fltk; fltk_images = null;}; "hs-functors" = callPackage @@ -127478,6 +133861,7 @@ self: { ]; description = "Utility to generate haskell-names interface files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hs-gizapp" = callPackage @@ -127493,6 +133877,8 @@ self: { ]; description = "Haskell wrapper around the GIZA++ toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-inspector" = callPackage @@ -127535,6 +133921,8 @@ self: { ]; description = "Java .class files assembler/disassembler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-json-rpc" = callPackage @@ -127548,6 +133936,8 @@ self: { ]; description = "JSON-RPC client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-logo" = callPackage @@ -127574,6 +133964,8 @@ self: { ]; description = "Logo interpreter written in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-mesos" = callPackage @@ -127632,6 +134024,8 @@ self: { executableHaskellDepends = [ base HandsomeSoup hxt random ]; description = "Name generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-openmoji-data" = callPackage @@ -127671,6 +134065,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "DSL for musical patterns and transformation, based on contravariant functors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-pgms" = callPackage @@ -127690,6 +134086,8 @@ self: { ]; description = "Programmer's Mine Sweeper in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-php-session" = callPackage @@ -127714,6 +134112,8 @@ self: { libraryHaskellDepends = [ base data-default-class text ]; description = "Create pkg-config configuration files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-pkpass" = callPackage @@ -127734,6 +134134,7 @@ self: { ]; description = "A library for Passbook pass creation & signing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hs-popen" = callPackage @@ -127770,6 +134171,8 @@ self: { libraryHaskellDepends = [ array base regex-base regex-posix ]; description = "Easy to use Regex"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-rqlite" = callPackage @@ -127786,6 +134189,8 @@ self: { ]; description = "A Haskell client for RQlite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-rs-notify" = callPackage @@ -127806,6 +134211,8 @@ self: { testHaskellDepends = [ base protolude ]; description = "Experimental! Wraps this awesome rust library so you can use it in haskell. https://docs.rs/crate/notify"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {notifier = null;}; "hs-scrape" = callPackage @@ -127826,6 +134233,8 @@ self: { ]; description = "Simple and easy web scraping and automation in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-server-starter" = callPackage @@ -127857,6 +134266,8 @@ self: { ]; description = "snowtify send your result of `stack build` (`stack test`) to notify-daemon :dog2:"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-speedscope" = callPackage @@ -127875,6 +134286,8 @@ self: { executableHaskellDepends = [ base ]; description = "Convert an eventlog into the speedscope json format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-swisstable-hashtables-class" = callPackage @@ -127887,6 +134300,7 @@ self: { testHaskellDepends = [ base hashtables swisstable ]; description = "Data.HashTable.Class instance definition for Data.HashTable.ST.Swiss"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hs-tags" = callPackage @@ -127904,6 +134318,8 @@ self: { ]; description = "Create tag files (ctags and etags) for Haskell code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-twitter" = callPackage @@ -127921,6 +134337,8 @@ self: { ]; description = "Haskell binding to the Twitter API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-twitterarchiver" = callPackage @@ -127935,6 +134353,8 @@ self: { executableHaskellDepends = [ base HTTP json mtl network pretty ]; description = "Commandline Twitter feed archiver"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-vcard" = callPackage @@ -127946,6 +134366,8 @@ self: { libraryHaskellDepends = [ base old-locale time ]; description = "Implements the RFC 2426 vCard 3.0 spec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-watchman" = callPackage @@ -127965,6 +134387,8 @@ self: { ]; description = "Client library for Facebook's Watchman tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs-zstd" = callPackage @@ -128051,6 +134475,8 @@ self: { ]; description = "Haskell to Brainfuck compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hs2dot" = callPackage @@ -128081,6 +134507,8 @@ self: { testHaskellDepends = [ base hspec template-haskell ]; description = "Translate Haskell types to PureScript"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsConfigure" = callPackage @@ -128105,6 +134533,8 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "I2C access for Haskell and Linux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsPID" = callPackage @@ -128133,6 +134563,8 @@ self: { ]; description = "Sqlite3 bindings"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsXenCtrl" = callPackage @@ -128145,6 +134577,8 @@ self: { librarySystemDepends = [ xenctrl ]; description = "FFI bindings to the Xen Control library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {xenctrl = null;}; "hsakamai" = callPackage @@ -128204,6 +134638,8 @@ self: { ]; description = "OASIS Security Assertion Markup Language (SAML) V2.0"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libxml2;}; "hsass" = callPackage @@ -128244,6 +134680,7 @@ self: { testHaskellDepends = [ base cpython hspec ]; description = "Haskell bindings for PyAutoGUI, a library for automating user interaction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsay" = callPackage @@ -128258,6 +134695,8 @@ self: { executableHaskellDepends = [ base Hclip HTTP process unix ]; description = "(ab)Use Google Translate as a speech synthesiser"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsb2hs" = callPackage @@ -128293,6 +134732,7 @@ self: { ]; description = "simple utility for rolling filesystem backups"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsbc" = callPackage @@ -128306,6 +134746,8 @@ self: { executableHaskellDepends = [ attoparsec base text vector ]; description = "A command line calculator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsbencher" = callPackage @@ -128328,6 +134770,8 @@ self: { ]; description = "Launch and gather data from Haskell and non-Haskell benchmarks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsbencher-codespeed" = callPackage @@ -128346,6 +134790,7 @@ self: { ]; description = "Backend for uploading benchmark data to CodeSpeed"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsbencher-fusion" = callPackage @@ -128369,6 +134814,7 @@ self: { ]; description = "Backend for uploading benchmark data to Google Fusion Tables"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsc2hs" = callPackage @@ -128409,6 +134855,8 @@ self: { ]; description = "Haskell SuperCollider"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsc3-auditor" = callPackage @@ -128424,6 +134872,7 @@ self: { ]; description = "Haskell SuperCollider Auditor"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-cairo" = callPackage @@ -128436,6 +134885,7 @@ self: { libraryHaskellDepends = [ base cairo gtk hosc hsc3 split ]; description = "haskell supercollider cairo drawing"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-data" = callPackage @@ -128453,6 +134903,7 @@ self: { ]; description = "haskell supercollider data"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-db" = callPackage @@ -128465,6 +134916,7 @@ self: { libraryHaskellDepends = [ base hsc3 safe ]; description = "Haskell SuperCollider Unit Generator Database"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-dot" = callPackage @@ -128477,6 +134929,7 @@ self: { libraryHaskellDepends = [ base directory filepath hsc3 process ]; description = "haskell supercollider graph drawing"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-forth" = callPackage @@ -128496,6 +134949,7 @@ self: { ]; description = "FORTH SUPERCOLLIDER"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-graphs" = callPackage @@ -128520,6 +134974,7 @@ self: { executableHaskellDepends = [ base ]; description = "Haskell SuperCollider Graphs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-lang" = callPackage @@ -128540,6 +134995,7 @@ self: { ]; description = "Haskell SuperCollider Language"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-lisp" = callPackage @@ -128559,6 +135015,7 @@ self: { ]; description = "LISP SUPERCOLLIDER"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-plot" = callPackage @@ -128576,6 +135033,7 @@ self: { ]; description = "Haskell SuperCollider Plotting"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-process" = callPackage @@ -128595,6 +135053,7 @@ self: { ]; description = "Create and control scsynth processes"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-rec" = callPackage @@ -128607,6 +135066,7 @@ self: { libraryHaskellDepends = [ base hsc3 ]; description = "Haskell SuperCollider Record Variants"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-rw" = callPackage @@ -128624,6 +135084,8 @@ self: { ]; description = "hsc3 re-writing"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsc3-server" = callPackage @@ -128650,6 +135112,7 @@ self: { ]; description = "SuperCollider server resource management and synchronization"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-sf" = callPackage @@ -128662,6 +135125,8 @@ self: { libraryHaskellDepends = [ base bytestring hosc ]; description = "Haskell SuperCollider SoundFile"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsc3-sf-hsndfile" = callPackage @@ -128678,6 +135143,7 @@ self: { ]; description = "Haskell SuperCollider SoundFile"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-unsafe" = callPackage @@ -128690,6 +135156,7 @@ self: { libraryHaskellDepends = [ base hsc3 ]; description = "Unsafe Haskell SuperCollider"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hsc3-utils" = callPackage @@ -128711,6 +135178,7 @@ self: { ]; description = "Haskell SuperCollider Utilities"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hscaffold" = callPackage @@ -128737,6 +135205,8 @@ self: { ]; description = "Very simple file/directory structure scaffolding writer monad EDSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hscamwire" = callPackage @@ -128751,6 +135221,8 @@ self: { librarySystemDepends = [ camwire_1394 dc1394_control raw1394 ]; description = "Haskell bindings to IIDC1394 cameras, via Camwire"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {camwire_1394 = null; dc1394_control = null; raw1394 = null;}; "hscassandra" = callPackage @@ -128781,6 +135253,8 @@ self: { executableHaskellDepends = [ aeson base bytestring ghc-prim HTTP ]; description = "Command line client and library for SoundCloud.com"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hscharm" = callPackage @@ -128889,6 +135363,8 @@ self: { executableHaskellDepends = [ base cairo glib gtk old-time ]; description = "An elegant analog clock using Haskell, GTK and Cairo"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hscolour" = callPackage @@ -128926,6 +135402,7 @@ self: { ]; description = "cscope like browser for Haskell code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hscrtmpl" = callPackage @@ -128960,6 +135437,8 @@ self: { testHaskellDepends = [ base containers text ]; description = "Collision-resistant IDs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hscurses" = callPackage @@ -129033,6 +135512,7 @@ self: { ]; description = "Haskell development library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsdif" = callPackage @@ -129045,6 +135525,8 @@ self: { libraryHaskellDepends = [ base bytestring hosc ]; description = "Haskell SDIF"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsdip" = callPackage @@ -129059,6 +135541,8 @@ self: { libraryHaskellDepends = [ base cairo containers HUnit parsec ]; description = "hsdip - a Diplomacy parser/renderer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsdns" = callPackage @@ -129091,6 +135575,8 @@ self: { ]; description = "Caching asynchronous DNS resolver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hse-cpp" = callPackage @@ -129182,6 +135668,8 @@ self: { ]; description = "Virtual Haskell Environment builder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hserv" = callPackage @@ -129207,6 +135695,7 @@ self: { testHaskellDepends = [ base HUnit tagged ]; description = "Primitive list with elements of unique types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsexif" = callPackage @@ -129236,6 +135725,7 @@ self: { libraryHaskellDepends = [ base containers language-puppet text ]; description = "A small and ugly library that emulates the output of the puppet facter program"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hsfcsh" = callPackage @@ -129251,6 +135741,8 @@ self: { ]; description = "Incremental builder for flash"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsfilt" = callPackage @@ -129264,6 +135756,8 @@ self: { executableHaskellDepends = [ base ghc ]; description = "Z-decoder"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsforce" = callPackage @@ -129287,6 +135781,8 @@ self: { ]; description = "Salesforce API Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsgnutls" = callPackage @@ -129299,6 +135795,8 @@ self: { librarySystemDepends = [ gcrypt gnutls ]; description = "Library wrapping the GnuTLS API"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gcrypt = null; inherit (pkgs) gnutls;}; "hsgnutls-yj" = callPackage @@ -129311,6 +135809,8 @@ self: { librarySystemDepends = [ gcrypt gnutls ]; description = "Library wrapping the GnuTLS API"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gcrypt = null; inherit (pkgs) gnutls;}; "hsgsom" = callPackage @@ -129323,6 +135823,8 @@ self: { libraryHaskellDepends = [ base containers random stm time ]; description = "An implementation of the GSOM clustering algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsgtd" = callPackage @@ -129413,6 +135915,8 @@ self: { doHaddock = false; description = "Extend the import list of a Haskell source file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsini" = callPackage @@ -129484,6 +135988,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "LSP interface over the hsinspect binary"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsinstall" = callPackage @@ -129515,6 +136021,8 @@ self: { libraryHaskellDepends = [ base Cabal ]; description = "Skeleton for new Haskell programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hslackbuilder" = callPackage @@ -129530,6 +136038,8 @@ self: { ]; description = "HSlackBuilder automatically generates slackBuild scripts from a cabal package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hslibsvm" = callPackage @@ -129543,6 +136053,8 @@ self: { librarySystemDepends = [ svm ]; description = "A FFI binding to libsvm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {svm = null;}; "hslinks" = callPackage @@ -129559,6 +136071,8 @@ self: { ]; description = "Resolves links to Haskell identifiers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hslogger" = callPackage @@ -129596,6 +136110,8 @@ self: { ]; description = "Parsing hslogger-produced logs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hslogger-template" = callPackage @@ -129607,6 +136123,8 @@ self: { libraryHaskellDepends = [ base hslogger mtl template-haskell ]; description = "Automatic generation of hslogger functions"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hslogger4j" = callPackage @@ -129645,6 +136163,7 @@ self: { ]; description = "A library to work with, or as, a logstash server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hslua" = callPackage @@ -129788,6 +136307,8 @@ self: { testHaskellDepends = [ aeson base bytestring colour containers ]; description = "HSLuv conversion utility"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsmagick" = callPackage @@ -129811,6 +136332,8 @@ self: { ]; description = "FFI bindings for the GraphicsMagick library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {GraphicsMagick = null; inherit (pkgs) bzip2; freetype2 = null; inherit (pkgs) jasper; inherit (pkgs) lcms; inherit (pkgs) libjpeg; inherit (pkgs) libpng; @@ -129848,6 +136371,8 @@ self: { ]; description = "Tool for generating .dir-locals.el for intero"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsmtpclient" = callPackage @@ -129859,6 +136384,8 @@ self: { libraryHaskellDepends = [ array base directory network old-time ]; description = "Simple SMTP Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsndfile" = callPackage @@ -129915,6 +136442,7 @@ self: { ]; description = "Nock 5K interpreter"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "hsnoise" = callPackage @@ -129939,6 +136467,8 @@ self: { executableHaskellDepends = [ base network pcap ]; description = "a miniature network sniffer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsnsq" = callPackage @@ -129957,6 +136487,8 @@ self: { ]; description = "Haskell NSQ client"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsntp" = callPackage @@ -129973,6 +136505,8 @@ self: { executableHaskellDepends = [ unix ]; description = "Libraries to use SNTP protocol and small client/server implementations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsoptions" = callPackage @@ -129997,6 +136531,8 @@ self: { ]; description = "Haskell library that supports command-line flag processing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsoz" = callPackage @@ -130035,6 +136571,8 @@ self: { ]; description = "Iron, Hawk, Oz: Web auth protocols"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsp" = callPackage @@ -130057,6 +136595,8 @@ self: { libraryHaskellDepends = [ base containers harp hsp network ]; description = "Facilitates running Haskell Server Pages web pages as CGI programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsparklines" = callPackage @@ -130089,6 +136629,8 @@ self: { ]; description = "A SPARQL query generator and DSL, and a client to query a SPARQL server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspear" = callPackage @@ -130104,6 +136646,8 @@ self: { ]; description = "Haskell Spear Parser"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec" = callPackage @@ -130310,6 +136854,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "An hspec expectation that asserts a value matches a pattern"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-expectations-pretty" = callPackage @@ -130325,6 +136871,7 @@ self: { ]; description = "hspec-expectations with pretty printing on failure"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hspec-expectations-pretty-diff" = callPackage @@ -130353,6 +136900,8 @@ self: { testHaskellDepends = [ base hspec-meta ]; description = "An experimental DSL for testing on top of Hspec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-golden" = callPackage @@ -130458,6 +137007,8 @@ self: { libraryHaskellDepends = [ base blaze-markup hspec ]; description = "Jenkins-friendly XML formatter for Hspec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-junit-formatter" = callPackage @@ -130556,6 +137107,8 @@ self: { ]; description = "Orphan instances of MonadBase and MonadBaseControl for SpecM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-multicheck" = callPackage @@ -130617,6 +137170,7 @@ self: { ]; description = "Helpers for creating database tests with hspec and pg-transact"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hspec-server" = callPackage @@ -130664,6 +137218,7 @@ self: { ]; description = "Add an hspec test-suite in one command"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hspec-shouldbe" = callPackage @@ -130675,6 +137230,7 @@ self: { libraryHaskellDepends = [ hspec test-shouldbe ]; description = "Convenience wrapper and utilities for hspec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hspec-slow" = callPackage @@ -130733,6 +137289,8 @@ self: { ]; description = "A library for testing with Hspec and the Snap Web Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-stack-rerun" = callPackage @@ -130754,6 +137312,8 @@ self: { sha256 = "008gm0qvhvp6z6a9sq5vpljqb90258apd83rkzy47k3bczy1sgmj"; libraryHaskellDepends = [ base hspec ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-tables" = callPackage @@ -130811,6 +137371,7 @@ self: { testHaskellDepends = [ base hspec test-sandbox ]; description = "Hspec convenience functions for use with test-sandbox"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hspec-wai" = callPackage @@ -130892,6 +137453,8 @@ self: { ]; description = "Write end2end web application tests using webdriver and hspec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec2" = callPackage @@ -130905,6 +137468,8 @@ self: { libraryHaskellDepends = [ base hspec hspec-discover ]; description = "Alpha version of Hspec 2.0"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspecVariant" = callPackage @@ -130916,6 +137481,7 @@ self: { libraryHaskellDepends = [ base hspec QuickCheckVariant ]; description = "Spec for testing properties for variant types"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hspkcs11" = callPackage @@ -130934,6 +137500,8 @@ self: { ]; description = "Wrapper for PKCS #11 interface"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspr-sh" = callPackage @@ -130960,6 +137528,8 @@ self: { ]; description = "A client library for the spread toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspresent" = callPackage @@ -130974,6 +137544,8 @@ self: { doHaddock = false; description = "A terminal presentation tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsprocess" = callPackage @@ -130999,6 +137571,7 @@ self: { ]; description = "The Haskell Stream Processor command line utility"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hsql" = callPackage @@ -131010,6 +137583,8 @@ self: { libraryHaskellDepends = [ base old-time ]; description = "Database access from Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsql-mysql" = callPackage @@ -131024,6 +137599,7 @@ self: { librarySystemDepends = [ mysqlclient ]; description = "MySQL driver for HSQL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {mysqlclient = null;}; "hsql-odbc" = callPackage @@ -131036,6 +137612,7 @@ self: { librarySystemDepends = [ unixODBC ]; description = "A Haskell Interface to ODBC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) unixODBC;}; "hsql-postgresql" = callPackage @@ -131048,6 +137625,7 @@ self: { librarySystemDepends = [ postgresql ]; description = "A Haskell Interface to PostgreSQL via the PQ library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) postgresql;}; "hsql-sqlite3" = callPackage @@ -131060,6 +137638,7 @@ self: { librarySystemDepends = [ sqlite ]; description = "SQLite3 driver for HSQL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) sqlite;}; "hsqml" = callPackage @@ -131223,6 +137802,7 @@ self: { ]; description = "Access to the Readability API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hsrelp" = callPackage @@ -131237,6 +137817,8 @@ self: { ]; description = "RELP (Reliable Event Logging Protocol) server implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsseccomp" = callPackage @@ -131250,6 +137832,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit unix ]; description = "Haskell bindings to libseccomp"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {seccomp = null;}; "hssh" = callPackage @@ -131321,6 +137905,8 @@ self: { ]; description = "SQL parser and type checker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hssqlppp-th" = callPackage @@ -131339,6 +137925,7 @@ self: { ]; description = "hssqlppp extras which need template-haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hstar" = callPackage @@ -131361,6 +137948,7 @@ self: { executableToolDepends = [ cpphs ]; description = "Haskell version of tar CLI utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hstatistics" = callPackage @@ -131387,6 +137975,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Statistical Computing in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hstatsd" = callPackage @@ -131398,6 +137988,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl network text ]; description = "Quick and dirty statsd interface"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hstest" = callPackage @@ -131415,6 +138007,8 @@ self: { ]; description = "Runs tests via QuickCheck1 and HUnit; like quickCheck-script but uses GHC api"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hstidy" = callPackage @@ -131428,6 +138022,8 @@ self: { executableHaskellDepends = [ base haskell-src-exts ]; description = "Takes haskell source on stdin, parses it, then prettyprints it to stdout"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hstorchat" = callPackage @@ -131484,6 +138080,7 @@ self: { testHaskellDepends = [ async base ]; description = "A Tox protocol implementation in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hstradeking" = callPackage @@ -131508,6 +138105,7 @@ self: { ]; description = "Tradeking API bindings for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hstyle" = callPackage @@ -131525,6 +138123,8 @@ self: { ]; description = "Checks Haskell source code for style compliance"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hstzaar" = callPackage @@ -131545,6 +138145,7 @@ self: { ]; description = "A two player abstract strategy game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsubconvert" = callPackage @@ -131566,6 +138167,7 @@ self: { ]; description = "One-time, faithful conversion of Subversion repositories to Git"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsudoku" = callPackage @@ -131594,6 +138196,8 @@ self: { ]; description = "Sudoku game with a GTK3 interface"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsverilog" = callPackage @@ -131625,6 +138229,7 @@ self: { librarySystemDepends = [ ncurses readline swipl ]; description = "embedding prolog in haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) ncurses; inherit (pkgs) readline; swipl = null;}; @@ -131641,6 +138246,8 @@ self: { libraryHaskellDepends = [ base haskell-src-exts mtl utf8-string ]; description = "HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsx-jmacro" = callPackage @@ -131654,6 +138261,7 @@ self: { ]; description = "hsp+jmacro support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsx-xhtml" = callPackage @@ -131665,6 +138273,7 @@ self: { libraryHaskellDepends = [ base hsx mtl ]; description = "XHTML utilities to use together with HSX"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsx2hs" = callPackage @@ -131698,6 +138307,8 @@ self: { libraryHaskellDepends = [ base ]; description = "FFI to syscalls"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsyslog" = callPackage @@ -131729,6 +138340,8 @@ self: { ]; description = "syslog over TCP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hsyslog-udp" = callPackage @@ -131757,6 +138370,8 @@ self: { librarySystemDepends = [ com_err zephyr ]; description = "Simple libzephyr bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {com_err = null; zephyr = null;}; "htaglib" = callPackage @@ -131808,6 +138423,8 @@ self: { ]; description = "Command-line tar archive utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "htaut" = callPackage @@ -131835,6 +138452,8 @@ self: { ]; description = "Beginner friendly graphics library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "htestu" = callPackage @@ -131850,6 +138469,8 @@ self: { executableHaskellDepends = [ base ]; description = "A library for testing correctness of pseudo random number generators in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gcc;}; "htiled" = callPackage @@ -131866,6 +138487,8 @@ self: { ]; description = "Import from the Tiled map editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "htime" = callPackage @@ -131906,6 +138529,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Heterogenous Set"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "html" = callPackage @@ -131941,6 +138566,8 @@ self: { ]; description = "Determine character encoding of HTML documents/fragments"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "html-conduit" = callPackage @@ -132038,6 +138665,8 @@ self: { libraryHaskellDepends = [ base hxt kure ]; description = "HTML rewrite engine, using KURE"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "html-minimalist" = callPackage @@ -132087,6 +138716,8 @@ self: { libraryHaskellDepends = [ base lens mtl tagsoup transformers ]; description = "Perform traversals of HTML structures using sets of rules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "html-tokenizer" = callPackage @@ -132109,6 +138740,8 @@ self: { ]; description = "An \"attoparsec\"-based HTML tokenizer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "html-truncate" = callPackage @@ -132277,6 +138910,7 @@ self: { libraryHaskellDepends = [ base hmt xml ]; description = "Haskell Music Typesetting"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "htsn" = callPackage @@ -132300,6 +138934,8 @@ self: { ]; description = "Parse XML files from The Sports Network feed"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "htsn-common" = callPackage @@ -132342,6 +138978,8 @@ self: { ]; description = "Import XML files from The Sports Network into an RDBMS"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "htssets" = callPackage @@ -132353,6 +138991,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Heterogenous Sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-accept" = callPackage @@ -132429,6 +139069,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring http-types ]; description = "Attoparsec parsers for http-types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-client" = callPackage @@ -132503,6 +139145,7 @@ self: { ]; description = "HTTP authorization (both basic and digest) done right"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "http-client-conduit" = callPackage @@ -132549,6 +139192,8 @@ self: { ]; description = "Optics for http-client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-client-multipart" = callPackage @@ -132638,6 +139283,8 @@ self: { ]; description = "Convenient monadic HTTP request modifiers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-client-restricted" = callPackage @@ -132669,6 +139316,8 @@ self: { ]; description = "A simple abstraction over the \"http-client\" connection manager"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-client-streams" = callPackage @@ -132685,6 +139334,8 @@ self: { ]; description = "http-client for io-streams supporting openssl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-client-tls" = callPackage @@ -132729,6 +139380,8 @@ self: { ]; description = "Glue code for http-client and websockets"; license = lib.licenses.cc0; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-common" = callPackage @@ -132800,6 +139453,8 @@ self: { ]; description = "Browser interface to the http-conduit package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-conduit-downloader" = callPackage @@ -132817,6 +139472,8 @@ self: { ]; description = "HTTP downloader tailored for web-crawler needs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-date" = callPackage @@ -132851,6 +139508,8 @@ self: { testHaskellDepends = [ base hspec text ]; description = "http directory listing library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-dispatch" = callPackage @@ -132868,6 +139527,8 @@ self: { testHaskellDepends = [ aeson base hspec ]; description = "High level HTTP client for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-download" = callPackage @@ -132935,6 +139596,7 @@ self: { ]; description = "HTTP client package with enumerator interface and HTTPS support. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "http-grammar" = callPackage @@ -132946,6 +139608,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring ]; description = "Attoparsec-based parsers for the RFC-2616 HTTP grammar rules"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-io-streams" = callPackage @@ -132967,6 +139631,7 @@ self: { ]; description = "HTTP and WebSocket client based on io-streams"; license = "BSD-3-Clause AND GPL-2.0-or-later"; + hydraPlatforms = lib.platforms.none; }) {}; "http-kinder" = callPackage @@ -132989,6 +139654,8 @@ self: { ]; description = "Generic kinds and types for working with HTTP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-kit" = callPackage @@ -133048,6 +139715,8 @@ self: { ]; description = "Listen to HTTP requests and handle them in arbitrary ways"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-media" = callPackage @@ -133105,6 +139774,8 @@ self: { ]; description = "Monad abstraction for HTTP allowing lazy transfer and non-I/O simulation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-pony" = callPackage @@ -133121,6 +139792,8 @@ self: { ]; description = "A type unsafe http library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-pony-serve-wai" = callPackage @@ -133140,6 +139813,8 @@ self: { ]; description = "Serve a WAI application with http-pony"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-pony-transformer-case-insensitive" = callPackage @@ -133210,6 +139885,8 @@ self: { ]; description = "A library for writing HTTP and HTTPS proxies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-query" = callPackage @@ -133241,6 +139918,8 @@ self: { ]; description = "The HTTP query builder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-response-decoder" = callPackage @@ -133260,6 +139939,8 @@ self: { ]; description = "Declarative DSL for parsing an HTTP response"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-reverse-proxy" = callPackage @@ -133319,6 +140000,8 @@ self: { ]; description = "A library for writing Haskell web servers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-shed" = callPackage @@ -133332,6 +140015,8 @@ self: { libraryHaskellDepends = [ base network ]; description = "A simple websever with an interact style API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http-streams" = callPackage @@ -133430,6 +140115,8 @@ self: { libraryHaskellDepends = [ base failure process transformers ]; description = "Provide a simple HTTP client interface by wrapping the wget command line tool. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http2" = callPackage @@ -133482,6 +140169,8 @@ self: { testHaskellDepends = [ base ]; description = "A native HTTP2 client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http2-client-exe" = callPackage @@ -133501,6 +140190,7 @@ self: { ]; description = "A command-line http2 client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "http2-client-grpc" = callPackage @@ -133520,6 +140210,7 @@ self: { testHaskellDepends = [ base ]; description = "Implement gRPC-over-HTTP2 clients"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "http2-grpc-proto-lens" = callPackage @@ -133536,6 +140227,8 @@ self: { ]; description = "Encoders based on `proto-lens` for gRPC over HTTP2"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http2-grpc-proto3-wire" = callPackage @@ -133604,6 +140297,7 @@ self: { ]; description = "High-level access to HTTPS Everywhere rulesets"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "https-everywhere-rules-raw" = callPackage @@ -133618,6 +140312,7 @@ self: { ]; description = "Low-level (i.e. XML) access to HTTPS Everywhere rulesets."; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "httpspec" = callPackage @@ -133635,6 +140330,7 @@ self: { ]; description = "Specification of HTTP request/response generators and parsers"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "htune" = callPackage @@ -133648,6 +140344,8 @@ self: { executableHaskellDepends = [ alsa-pcm base carray fft gloss ]; description = "harmonic analyser and tuner for musical instruments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "htvm" = callPackage @@ -133675,6 +140373,8 @@ self: { testSystemDepends = [ tvm_runtime ]; description = "Bindings for TVM machine learning framework"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {tvm_runtime = null;}; "htzaar" = callPackage @@ -133688,6 +140388,8 @@ self: { executableHaskellDepends = [ base OpenGL random SDL ]; description = "A two player abstract strategy game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hub" = callPackage @@ -133763,6 +140465,8 @@ self: { ]; description = "huck"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "huckleberry" = callPackage @@ -133794,6 +140498,8 @@ self: { executableHaskellDepends = [ base ]; description = "A fast-foward-based planner"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "huffman" = callPackage @@ -133805,6 +140511,8 @@ self: { libraryHaskellDepends = [ base containers fingertree ]; description = "Pure Haskell implementation of the Huffman encoding algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hugs2yc" = callPackage @@ -133821,6 +140529,7 @@ self: { ]; description = "Hugs Front-end to Yhc Core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hulk" = callPackage @@ -133847,6 +140556,7 @@ self: { ]; description = "IRC server written in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hum" = callPackage @@ -133891,6 +140601,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "A lawless typeclass for parsing text entered by humans"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "human-readable-duration" = callPackage @@ -133915,6 +140627,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "A lawless typeclass for converting values to human-friendly text"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "humble-prelude" = callPackage @@ -133926,6 +140640,8 @@ self: { libraryHaskellDepends = [ base bytestring deepseq ghc text ]; description = "Redefinition-free prelude alternative"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hums" = callPackage @@ -133950,6 +140666,8 @@ self: { ]; description = "Haskell UPnP Media Server"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hunch" = callPackage @@ -133972,6 +140690,8 @@ self: { ]; description = "CSS-like syntax for file system manipulation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hunit-dejafu" = callPackage @@ -133998,6 +140718,7 @@ self: { executableHaskellDepends = [ base cairo gtk haskell98 HUnit ]; description = "A GUI testrunner for HUnit"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "hunit-parsec" = callPackage @@ -134021,6 +140742,8 @@ self: { testHaskellDepends = [ base hspec HUnit rematch ]; description = "HUnit support for rematch"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hunp" = callPackage @@ -134039,6 +140762,7 @@ self: { ]; description = "Unpacker tool with DWIM"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hunspell-hs" = callPackage @@ -134055,6 +140779,8 @@ self: { benchmarkPkgconfigDepends = [ hunspell ]; description = "Hunspell thread-safe FFI bindings for spell checking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) hunspell;}; "hunt-searchengine" = callPackage @@ -134086,6 +140812,7 @@ self: { ]; description = "A search and indexing engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hunt-server" = callPackage @@ -134109,6 +140836,7 @@ self: { ]; description = "A search and indexing engine server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hunt-server-cli" = callPackage @@ -134162,6 +140890,8 @@ self: { ]; description = "Upload packages or documentation to a hackage server"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hurdle" = callPackage @@ -134177,6 +140907,7 @@ self: { ]; description = "Extract function names from Windows DLLs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hurl" = callPackage @@ -134219,6 +140950,8 @@ self: { ]; description = "Haskell bindings for Hurriyet API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "husk-scheme" = callPackage @@ -134275,6 +141008,7 @@ self: { ]; description = "A simple command line calculator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hutton" = callPackage @@ -134295,6 +141029,8 @@ self: { ]; description = "A program for the button on Reddit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "huttons-razor" = callPackage @@ -134308,6 +141044,8 @@ self: { executableHaskellDepends = [ base parsec parsec-numbers ]; description = "Quick implemention of Hutton's Razor"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "huzzy" = callPackage @@ -134319,6 +141057,7 @@ self: { libraryHaskellDepends = [ base easyplot ]; description = "Fuzzy logic library with support for T1, IT2, GT2"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hvect" = callPackage @@ -134407,6 +141146,7 @@ self: { ]; description = "Demo library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-aws-sqs-conduit" = callPackage @@ -134507,6 +141247,8 @@ self: { doHaddock = false; description = "CI Assistant for Haskell projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hw-conduit" = callPackage @@ -134607,6 +141349,7 @@ self: { ]; description = "Unbelievably fast streaming DSV file parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-dump" = callPackage @@ -134882,6 +141625,7 @@ self: { doHaddock = false; description = "Memory efficient JSON parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-json-lens" = callPackage @@ -134911,6 +141655,7 @@ self: { ]; description = "Lens for hw-json"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-json-simd" = callPackage @@ -134937,6 +141682,8 @@ self: { testToolDepends = [ doctest-discover ]; description = "SIMD-based JSON semi-indexer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hw-json-simple-cursor" = callPackage @@ -134974,6 +141721,7 @@ self: { ]; description = "Memory efficient JSON parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-json-standard-cursor" = callPackage @@ -135013,6 +141761,7 @@ self: { ]; description = "Memory efficient JSON parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-kafka-avro" = callPackage @@ -135039,6 +141788,7 @@ self: { ]; description = "Avro support for Kafka infrastructure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-kafka-client" = callPackage @@ -135332,6 +142082,8 @@ self: { ]; description = "SIMD library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hw-simd-cli" = callPackage @@ -135360,6 +142112,7 @@ self: { testToolDepends = [ doctest-discover ]; description = "SIMD library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-streams" = callPackage @@ -135475,6 +142228,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Supports IO on URIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hw-vector" = callPackage @@ -135550,6 +142304,8 @@ self: { ]; description = "Initial version of firewall Authentication for IITK network"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hweblib" = callPackage @@ -135572,6 +142328,8 @@ self: { ]; description = "Haskell Web Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hwhile" = callPackage @@ -135592,6 +142350,8 @@ self: { testHaskellDepends = [ array base Cabal containers mtl ]; description = "An implementation of Neil D. Jones' While language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hwk" = callPackage @@ -135631,6 +142391,8 @@ self: { ]; description = "A reliable at-least-once job queue built on top of redis"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hworker-ses" = callPackage @@ -135647,6 +142409,7 @@ self: { ]; description = "Library for sending email with Amazon's SES and hworker"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "hwormhole" = callPackage @@ -135679,6 +142442,7 @@ self: { ]; description = "magic-wormhole client"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hws" = callPackage @@ -135697,6 +142461,7 @@ self: { ]; description = "Simple Haskell Web Server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hwsl2" = callPackage @@ -135716,6 +142481,8 @@ self: { ]; description = "Hashing with SL2"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hwsl2-bytevector" = callPackage @@ -135727,6 +142494,7 @@ self: { libraryHaskellDepends = [ base bytestring fingertree hwsl2 ]; description = "A hashed byte-vector based on algebraic hashes and finger trees"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hwsl2-reducers" = callPackage @@ -135740,6 +142508,7 @@ self: { ]; description = "Semigroup and Reducer instances for Data.Hash.SL2"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hx" = callPackage @@ -135751,6 +142520,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell extras (missing utility functions)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hxmppc" = callPackage @@ -135769,6 +142540,7 @@ self: { ]; description = "Haskell XMPP (Jabber Client) Command Line Interface (CLI)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hxournal" = callPackage @@ -135795,6 +142567,7 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "A pen notetaking program written in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hxt" = callPackage @@ -135950,6 +142723,8 @@ self: { libraryHaskellDepends = [ base hxt mtl ]; description = "Utility functions for using HXT picklers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hxt-regex-xmlschema" = callPackage @@ -136054,6 +142829,7 @@ self: { libraryHaskellDepends = [ base bytestring encoding hxt mtl ]; description = "Helper functions for HXT"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hxweb" = callPackage @@ -136065,6 +142841,7 @@ self: { libraryHaskellDepends = [ base cgi fastcgi libxml mtl xslt ]; description = "Minimal webframework using fastcgi, libxml2 and libxslt"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hyahtzee" = callPackage @@ -136099,6 +142876,8 @@ self: { ]; description = "Literate-style Documentation Generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hybrid" = callPackage @@ -136115,6 +142894,7 @@ self: { ]; description = "A implementation of a type-checker for Lambda-H"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hybrid-vectors" = callPackage @@ -136143,6 +142923,8 @@ self: { testHaskellDepends = [ base ]; description = "Haskell binding to the Sixense SDK for the Razer Hydra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {sixense_x64 = null;}; "hydra-print" = callPackage @@ -136174,6 +142956,8 @@ self: { ]; description = "NCurses interface to view multiple ByteString streams in parallel"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hydrogen" = callPackage @@ -136190,6 +142974,8 @@ self: { testHaskellDepends = [ base Cabal containers mtl QuickCheck ]; description = "An alternate Prelude"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hydrogen-cli" = callPackage @@ -136210,6 +142996,7 @@ self: { ]; description = "Hydrogen Data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-cli-args" = callPackage @@ -136225,6 +143012,7 @@ self: { ]; description = "Hydrogen Command Line Arguments Parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-data" = callPackage @@ -136236,6 +143024,7 @@ self: { libraryHaskellDepends = [ base hydrogen-parsing hydrogen-prelude ]; description = "Hydrogen Data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-multimap" = callPackage @@ -136247,6 +143036,8 @@ self: { libraryHaskellDepends = [ base containers ghc-prim ]; description = "Hydrogen Multimap"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hydrogen-parsing" = callPackage @@ -136260,6 +143051,7 @@ self: { ]; description = "Hydrogen Parsing Utilities"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-prelude" = callPackage @@ -136279,6 +143071,7 @@ self: { ]; description = "Hydrogen Prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-prelude-parsec" = callPackage @@ -136290,6 +143083,7 @@ self: { libraryHaskellDepends = [ base hydrogen-prelude parsec ]; description = "Hydrogen Prelude /w Parsec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-syntax" = callPackage @@ -136306,6 +143100,7 @@ self: { ]; description = "Hydrogen Syntax"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-util" = callPackage @@ -136320,6 +143115,7 @@ self: { ]; description = "Hydrogen Tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hydrogen-version" = callPackage @@ -136348,6 +143144,7 @@ self: { ]; description = "Simple web application server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hylide" = callPackage @@ -136369,6 +143166,8 @@ self: { ]; description = "WebGL live-coding environment for writing shaders with Hylogen"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hylogen" = callPackage @@ -136395,6 +143194,8 @@ self: { ]; description = "Tools for hybrid logics related programs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hylotab" = callPackage @@ -136409,6 +143210,7 @@ self: { executableHaskellDepends = [ base hylolib mtl ]; description = "Tableau based theorem prover for hybrid logics"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hyloutils" = callPackage @@ -136424,6 +143226,7 @@ self: { ]; description = "Very small programs for hybrid logics"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "hyper" = callPackage @@ -136487,6 +143290,8 @@ self: { ]; description = "a fast, trustworthy HTTP(s) server built"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hyperfunctions" = callPackage @@ -136502,6 +143307,8 @@ self: { ]; description = "Hyperfunctions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hyperion" = callPackage @@ -136529,6 +143336,8 @@ self: { ]; description = "Reliable performance measurement with robust data export"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hyperloglog" = callPackage @@ -136563,6 +143372,8 @@ self: { testHaskellDepends = [ base HUnit semigroups tasty tasty-hunit ]; description = "Approximate cardinality estimation using constant space"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hyperpublic" = callPackage @@ -136578,6 +143389,7 @@ self: { ]; description = "A thin wrapper for the Hyperpublic API"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "hyphenate" = callPackage @@ -136634,6 +143446,8 @@ self: { ]; description = "A Haskell neo4j client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hyraxAbif" = callPackage @@ -136764,6 +143578,8 @@ self: { ]; description = "A haskell wrapper for the Zulip API"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "i18n" = callPackage @@ -136784,6 +143600,8 @@ self: { ]; description = "Internationalization for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "i3blocks-hs-contrib" = callPackage @@ -136820,6 +143638,8 @@ self: { testHaskellDepends = [ aeson base bytestring hspec ]; description = "A type-safe wrapper around i3's IPC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iCalendar" = callPackage @@ -136867,6 +143687,8 @@ self: { ]; description = "A simple wrapper of In-App-Purchase receipt validate APIs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ib-api" = callPackage @@ -136883,6 +143705,8 @@ self: { ]; description = "An API for the Interactive Brokers Trading Workstation written in pure Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iban" = callPackage @@ -136901,6 +143725,8 @@ self: { testHaskellDepends = [ base HUnit tasty tasty-hunit text ]; description = "Validate and generate IBANs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ibus-hs" = callPackage @@ -136933,6 +143759,8 @@ self: { testHaskellDepends = [ base ]; description = "iCalendar format parser and org-mode converter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ice40-prim" = callPackage @@ -136949,6 +143777,7 @@ self: { ]; description = "Lattice iCE40 Primitive IP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "icepeak" = callPackage @@ -136994,6 +143823,8 @@ self: { ]; description = "A fast JSON document store with push notification support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "icfpc2020-galaxy" = callPackage @@ -137043,6 +143874,8 @@ self: { testHaskellDepends = [ base ]; description = "Type safe iconv wrapper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ide-backend" = callPackage @@ -137089,6 +143922,7 @@ self: { ]; description = "An IDE backend library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ide-backend-common" = callPackage @@ -137113,6 +143947,7 @@ self: { ]; description = "Shared library used be ide-backend and ide-backend-server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ide-backend-rts" = callPackage @@ -137147,6 +143982,7 @@ self: { ]; description = "An IDE backend server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ideas" = callPackage @@ -137166,6 +144002,8 @@ self: { ]; description = "Feedback services for intelligent tutoring systems"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ideas-math" = callPackage @@ -137183,6 +144021,7 @@ self: { ]; description = "Interactive domain reasoner for logic and mathematics"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "ideas-math-types" = callPackage @@ -137196,6 +144035,7 @@ self: { ]; description = "Common types for mathematical domain reasoners"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "ideas-statistics" = callPackage @@ -137211,6 +144051,7 @@ self: { ]; description = "Interactive domain reasoner for statistics"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "idempotent" = callPackage @@ -137223,6 +144064,8 @@ self: { testHaskellDepends = [ base containers hspec QuickCheck ]; description = "Idempotent monoids"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "identicon" = callPackage @@ -137289,6 +144132,8 @@ self: { ]; description = "Numeric identifiers for values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "idiii" = callPackage @@ -137314,6 +144159,8 @@ self: { ]; description = "ID3v2 (tagging standard for MP3 files) library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "idna" = callPackage @@ -137336,6 +144183,8 @@ self: { libraryHaskellDepends = [ base punycode split ]; description = "Converts Unicode hostnames into ASCII"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "idringen" = callPackage @@ -137422,6 +144271,8 @@ self: { libraryHaskellDepends = [ base ]; description = "ieee-utils"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ieee-utils-tempfix" = callPackage @@ -137471,6 +144322,8 @@ self: { testHaskellDepends = [ base bytestring HUnit stocks ]; description = "Library for the IEX Trading API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "if" = callPackage @@ -137496,6 +144349,8 @@ self: { testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; description = "put if statements within type constraints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iff" = callPackage @@ -137544,6 +144399,8 @@ self: { ]; description = "Bindings to Instagram's API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ige" = callPackage @@ -137566,6 +144423,8 @@ self: { ]; description = "An keyboard-driven interactive graph editor"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ige-mac-integration" = callPackage @@ -137584,6 +144443,7 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Bindings for the Gtk/OS X integration library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {ige-mac-integration = null;}; "ignore" = callPackage @@ -137603,6 +144463,8 @@ self: { testHaskellDepends = [ base HTF text ]; description = "Handle ignore files of different VCSes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "igraph" = callPackage @@ -137620,6 +144482,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to the igraph C library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) igraph;}; "igrf" = callPackage @@ -137854,6 +144718,8 @@ self: { ]; description = "IHaskell display instances for Parsec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ihaskell-plot" = callPackage @@ -137882,6 +144748,7 @@ self: { ]; description = "a rDisp quasiquote to show plots from Rlang-QQ in IHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ihaskell-widgets" = callPackage @@ -137899,6 +144766,8 @@ self: { ]; description = "IPython standard widgets for IHaskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ihs" = callPackage @@ -137930,6 +144799,7 @@ self: { executableHaskellDepends = [ base network ]; description = "Incremental HTTP iteratee"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ilist" = callPackage @@ -137967,6 +144837,8 @@ self: { executableToolDepends = [ alex ]; description = "A fast syntax highlighting library built with alex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "image-type" = callPackage @@ -138035,6 +144907,8 @@ self: { ]; description = "Command-line image paste utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "imagesize-conduit" = callPackage @@ -138081,6 +144955,7 @@ self: { ]; description = "An efficient IMAP client library, with SSL and streaming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "imapget" = callPackage @@ -138098,6 +144973,8 @@ self: { ]; description = "Downloads email from imap SSL servers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "imbib" = callPackage @@ -138119,6 +144996,7 @@ self: { ]; description = "Minimalistic reference manager"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "imgur" = callPackage @@ -138134,6 +145012,8 @@ self: { ]; description = "A function to post an image to imgur"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "imgurder" = callPackage @@ -138154,6 +145034,7 @@ self: { ]; description = "Uploader for Imgur"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "imj-animation" = callPackage @@ -138166,6 +145047,7 @@ self: { testHaskellDepends = [ base ]; description = "Animation Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "imj-base" = callPackage @@ -138190,6 +145072,7 @@ self: { ]; description = "Game engine with geometry, easing, animated text, delta rendering"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "imj-game-hamazed" = callPackage @@ -138210,6 +145093,7 @@ self: { testHaskellDepends = [ base imj-base mtl text ]; description = "A game with flying numbers and 8-bit color animations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "imj-measure-stdout" = callPackage @@ -138225,6 +145109,7 @@ self: { ]; description = "An application to determine the maximum capacity of stdout buffer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "imj-prelude" = callPackage @@ -138236,6 +145121,8 @@ self: { libraryHaskellDepends = [ base mtl text ]; description = "Prelude library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "imm" = callPackage @@ -138274,6 +145161,7 @@ self: { ]; description = "Execute arbitrary actions for each item from RSS/Atom feeds"; license = lib.licenses.cc0; + hydraPlatforms = lib.platforms.none; }) {}; "immortal_0_2_2_1" = callPackage @@ -138335,6 +145223,8 @@ self: { ]; description = "Create worker threads that logs exceptions and restarts"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "imparse" = callPackage @@ -138358,6 +145248,7 @@ self: { ]; description = "Multi-platform parser analyzer and generator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "imperative-edsl" = callPackage @@ -138383,6 +145274,8 @@ self: { ]; description = "Deep embedding of imperative programs with code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "imperative-edsl-vhdl" = callPackage @@ -138399,6 +145292,7 @@ self: { ]; description = "Deep embedding of VHDL programs with code generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "impl" = callPackage @@ -138411,6 +145305,8 @@ self: { doHaddock = false; description = "Framework for defaulting superclasses"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "implicit" = callPackage @@ -138500,6 +145396,8 @@ self: { libraryHaskellDepends = [ base mtl time transformers ]; description = "A logging framework built around implicit parameters"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "implicit-params" = callPackage @@ -138511,6 +145409,8 @@ self: { libraryHaskellDepends = [ base data-default-class ]; description = "Named and unnamed implicit parameters with defaults"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "importify" = callPackage @@ -138543,6 +145443,7 @@ self: { ]; description = "Tool for haskell imports refactoring"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "imports" = callPackage @@ -138555,6 +145456,8 @@ self: { testHaskellDepends = [ base directory filepath mtl ]; description = "Generate code for importing directories automatically"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "impossible" = callPackage @@ -138566,6 +145469,8 @@ self: { libraryHaskellDepends = [ base lens ]; description = "Set of data and type definitions of impossible types. Impossible types are useful when declaring type classes / type families instances that should not be expanded by GHC until a specific type is provided in order to keep the types nice and readable."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "imprevu" = callPackage @@ -138623,6 +145528,8 @@ self: { testHaskellDepends = [ base binary constraints hspec ]; description = "Serialization of arbitrary Haskell expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "improve" = callPackage @@ -138634,6 +145541,7 @@ self: { libraryHaskellDepends = [ base mtl yices ]; description = "An imperative, verifiable programming language for high assurance applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "impure-containers" = callPackage @@ -138742,6 +145650,7 @@ self: { ]; description = "A type-checker for Haskell with integer constraints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "inchworm" = callPackage @@ -138753,6 +145662,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Simple parser combinators for lexical analysis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "include-file" = callPackage @@ -138807,6 +145718,7 @@ self: { benchmarkHaskellDepends = [ base containers deepseq QuickCheck ]; description = "Incremental computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "incremental-maps" = callPackage @@ -138830,6 +145742,7 @@ self: { ]; description = "Package for doing incremental computations on maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "incremental-parser" = callPackage @@ -138883,6 +145796,7 @@ self: { ]; description = "type classes for incremental updates to data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "indent" = callPackage @@ -138913,6 +145827,7 @@ self: { ]; description = "Indentation sensitive parsing combinators for Parsec and Trifecta"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "indentation-core" = callPackage @@ -138924,6 +145839,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Indentation sensitive parsing combinators core library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "indentation-parsec" = callPackage @@ -138938,6 +145855,7 @@ self: { testHaskellDepends = [ base parsec tasty tasty-hunit ]; description = "Indentation sensitive parsing combinators for Parsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "indentation-trifecta" = callPackage @@ -138954,6 +145872,7 @@ self: { testHaskellDepends = [ base tasty tasty-hunit trifecta ]; description = "Indentation sensitive parsing combinators for Trifecta"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "indentparser" = callPackage @@ -138992,6 +145911,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Indexed Types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "indexation" = callPackage @@ -139013,6 +145934,7 @@ self: { ]; description = "Tools for entity indexation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "indexed" = callPackage @@ -139145,6 +146067,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "A series of type families and constraints for \"indexable\" types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "indian-language-font-converter" = callPackage @@ -139171,6 +146095,8 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Multi-dimensional statically bounded indices"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "indieweb-algorithms" = callPackage @@ -139196,6 +146122,7 @@ self: { ]; description = "A collection of implementations of IndieWeb algorithms"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "indigo" = callPackage @@ -139245,6 +146172,8 @@ self: { testHaskellDepends = [ array base deepseq QuickCheck text vector ]; description = "Non-contiguous interval data types with potentially infinite ranges"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "infer-license" = callPackage @@ -139280,6 +146209,8 @@ self: { ]; description = "Find the repository from where a given repo was forked"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "infernal" = callPackage @@ -139320,6 +146251,7 @@ self: { executableHaskellDepends = [ base optparse-applicative parsec ]; description = "Type inference and checker for JavaScript (experimental)"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "infinite-search" = callPackage @@ -139346,6 +146278,8 @@ self: { base binary Cabal filepath ghc irc plugins ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "infix" = callPackage @@ -139357,6 +146291,8 @@ self: { libraryHaskellDepends = [ base containers haskell-src ]; description = "Infix expression re-parsing (for HsParser library)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "inflections" = callPackage @@ -139388,6 +146324,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "An infinite list type and operations thereon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "influxdb" = callPackage @@ -139443,6 +146381,8 @@ self: { ]; description = "A yesod subsite serving a wiki"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ini" = callPackage @@ -139473,6 +146413,8 @@ self: { testHaskellDepends = [ base HUnit ini raw-strings-qq text ]; description = "Quasiquoter for INI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "inilist" = callPackage @@ -139492,6 +146434,8 @@ self: { ]; description = "Processing for .ini files with duplicate sections and options"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "initialize" = callPackage @@ -139503,6 +146447,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Initialization and Deinitialization of 'Storable' values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "inj" = callPackage @@ -139554,6 +146500,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Monadic functions with injected parameters"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "inline-asm" = callPackage @@ -139667,6 +146615,7 @@ self: { ]; description = "Java interop via inline Java code in Haskell modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "inline-r" = callPackage @@ -139787,6 +146736,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring dlist ]; description = "Stupid simple bytestring templates"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "inspection-proxy" = callPackage @@ -139842,6 +146793,7 @@ self: { testHaskellDepends = [ base ]; description = "Create benchmarks from the HAR files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "instana-haskell-trace-sdk" = callPackage @@ -139878,6 +146830,8 @@ self: { ]; description = "SDK for adding custom Instana tracing support to Haskell applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "instance-control" = callPackage @@ -139905,6 +146859,8 @@ self: { ]; description = "Template haskell utilities for helping with deserialization etc. of existential types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "instant-aeson" = callPackage @@ -139921,6 +146877,7 @@ self: { ]; description = "Generic Aeson instances through instant-generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "instant-bytes" = callPackage @@ -139937,6 +146894,7 @@ self: { ]; description = "Generic Serial instances through instant-generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "instant-deepseq" = callPackage @@ -139948,6 +146906,7 @@ self: { libraryHaskellDepends = [ base deepseq instant-generics ]; description = "Generic NFData instances through instant-generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "instant-generics" = callPackage @@ -139961,6 +146920,8 @@ self: { libraryHaskellDepends = [ base containers syb template-haskell ]; description = "Generic programming library with a sum of products view"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "instant-hashable" = callPackage @@ -139972,6 +146933,7 @@ self: { libraryHaskellDepends = [ base hashable instant-generics ]; description = "Generic Hashable instances through instant-generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "instant-zipper" = callPackage @@ -139985,6 +146947,7 @@ self: { libraryHaskellDepends = [ base instant-generics mtl ]; description = "Heterogenous Zipper in Instant Generics"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "instapaper-sender" = callPackage @@ -140004,6 +146967,7 @@ self: { ]; description = "Basic HTTP gateway to save articles to Instapaper"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "instinct" = callPackage @@ -140015,6 +146979,8 @@ self: { libraryHaskellDepends = [ base containers mersenne-random vector ]; description = "Fast artifical neural networks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "instrument" = callPackage @@ -140095,6 +147061,8 @@ self: { ]; description = "A data structure that associates each Int key with a set of values"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "intcode" = callPackage @@ -140109,6 +147077,8 @@ self: { testHaskellDepends = [ base containers doctest primitive ]; description = "Advent of Code 2019 intcode interpreter"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "integer-gmp_1_0_3_0" = callPackage @@ -140149,6 +147119,8 @@ self: { sha256 = "0lrhf6mw90bfph3hbyxv3n7g2n2xnjfq4qnhyhw4ml76k4yybmxa"; description = "A pure-Haskell implementation of arbitrary-precision Integers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "integer-roots" = callPackage @@ -140215,6 +147187,8 @@ self: { ]; description = "Integrate different assays"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "intel-aes" = callPackage @@ -140233,6 +147207,8 @@ self: { librarySystemDepends = [ intel_aes ]; description = "Hardware accelerated AES encryption and Random Number Generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {intel_aes = null;}; "intensional-datatys" = callPackage @@ -140253,6 +147229,8 @@ self: { doHaddock = false; description = "A GHC Core plugin for intensional datatype refinement checking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "interact" = callPackage @@ -140365,6 +147343,8 @@ self: { ]; description = "Prelude replacement based on protolude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "intern" = callPackage @@ -140398,6 +147378,8 @@ self: { ]; description = "Shell command for constructing custom stamps for German Post"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "intero" = callPackage @@ -140424,6 +147406,8 @@ self: { ]; description = "Complete interactive development program for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "interp" = callPackage @@ -140478,6 +147462,8 @@ self: { ]; description = "GHC preprocessor and library to enable variable interpolation in strings"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "interpolate" = callPackage @@ -140527,6 +147513,7 @@ self: { ]; description = "QuasiQuoter for Ruby-style multi-line interpolated strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "interpolatedstring-qq-mwotton" = callPackage @@ -140542,6 +147529,7 @@ self: { ]; description = "DO NOT USE THIS. interpolatedstring-qq works now."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "interpolatedstring-qq2" = callPackage @@ -140560,6 +147548,8 @@ self: { ]; description = "QuasiQuoter for multi-line interpolated strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "interpolation" = callPackage @@ -140629,6 +147619,8 @@ self: { testHaskellDepends = [ base Cabal either transformers ]; description = "Monad transformers that can be run and resumed later, conserving their context"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "interspersed" = callPackage @@ -140654,6 +147646,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Intervals with adherences"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "interval-algebra" = callPackage @@ -140728,6 +147722,8 @@ self: { executablePkgconfigDepends = [ ncurses ]; description = "A game of competitive puzzle-design"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ncurses;}; "intrinsic-superclasses" = callPackage @@ -140780,6 +147776,8 @@ self: { doHaddock = false; description = "Intro reexported as Prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "introduction" = callPackage @@ -140800,6 +147798,8 @@ self: { ]; description = "A prelude for safe new projects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "introduction-test" = callPackage @@ -140819,6 +147819,7 @@ self: { ]; description = "A prelude for the tests of safe new projects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "intset" = callPackage @@ -140830,6 +147831,7 @@ self: { libraryHaskellDepends = [ base bits-extras bytestring deepseq ]; description = "Pure, mergeable, succinct Int sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "intset-imperative" = callPackage @@ -140917,6 +147919,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Automatically generate a function's inverse"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "invertible" = callPackage @@ -140967,6 +147971,7 @@ self: { libraryHaskellDepends = [ base HList invertible ]; description = "invertible functions and instances for HList"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "invertible-hxt" = callPackage @@ -140991,6 +147996,8 @@ self: { libraryHaskellDepends = [ base partial-isomorphisms ]; description = "Invertible syntax descriptions for both parsing and pretty printing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "involutive-semigroups" = callPackage @@ -141020,6 +148027,8 @@ self: { ]; description = "Capture IO actions' stdout and stderr"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "io-choice" = callPackage @@ -141039,6 +148048,8 @@ self: { ]; description = "Choice for IO and lifted IO"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "io-machine" = callPackage @@ -141090,6 +148101,8 @@ self: { executableHaskellDepends = [ base ]; description = "An API for generating TIMBER style reactive objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "io-region" = callPackage @@ -141218,6 +148231,8 @@ self: { libraryHaskellDepends = [ base network unix ]; description = "Type-safe I/O control package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ion" = callPackage @@ -141238,6 +148253,7 @@ self: { ]; description = "EDSL for concurrent, realtime, embedded programming on top of Ivory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ioref-stable" = callPackage @@ -141260,6 +148276,8 @@ self: { libraryHaskellDepends = [ base bytestring path text ]; description = "A class of strings that can be involved in IO"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iothread" = callPackage @@ -141271,6 +148289,8 @@ self: { libraryHaskellDepends = [ base ]; description = "run IOs in a single thread"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iotransaction" = callPackage @@ -141282,6 +148302,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Supports the automatic undoing of IO operations when an exception is thrown"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ip" = callPackage @@ -141312,6 +148334,7 @@ self: { ]; description = "Library for IP and MAC addresses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ip-quoter" = callPackage @@ -141326,6 +148349,8 @@ self: { testHaskellDepends = [ base cpu network tasty tasty-hunit ]; description = "Quasiquoter for IP addresses"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ip2location" = callPackage @@ -141337,6 +148362,8 @@ self: { libraryHaskellDepends = [ base binary bytestring iproute ]; description = "IP2Location Haskell package for IP geolocation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ip2proxy" = callPackage @@ -141348,6 +148375,8 @@ self: { libraryHaskellDepends = [ base binary bytestring iproute ]; description = "IP2Proxy Haskell package for proxy detection"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ip6addr" = callPackage @@ -141395,6 +148424,7 @@ self: { ]; description = "interactive patch editor"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "ipc" = callPackage @@ -141410,6 +148440,7 @@ self: { ]; description = "High level inter-process communication library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ipcvar" = callPackage @@ -141452,6 +148483,8 @@ self: { ]; description = "Access IPFS locally and remotely"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ipfs-api" = callPackage @@ -141510,6 +148543,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "haskell binding to ipopt and nlopt including automatic differentiation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ipopt; inherit (pkgs) nlopt;}; "ipprint" = callPackage @@ -141521,6 +148556,7 @@ self: { libraryHaskellDepends = [ base haskell-src sr-extra ]; description = "Tiny helper for pretty-printing values in ghci console"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "iproute" = callPackage @@ -141558,6 +148594,8 @@ self: { executableHaskellDepends = [ base QuickCheck syb ]; description = "iptables rules parser/printer library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iptadmin" = callPackage @@ -141582,6 +148620,7 @@ self: { ]; description = "web-interface for iptables"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ipynb" = callPackage @@ -141757,6 +148796,8 @@ self: { ]; description = "A DCC message parsing and helper library for IRC clients"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "irc-fun-bot" = callPackage @@ -141777,6 +148818,7 @@ self: { ]; description = "Library for writing fun IRC bots"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "irc-fun-client" = callPackage @@ -141795,6 +148837,7 @@ self: { ]; description = "Another library for writing IRC clients"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "irc-fun-color" = callPackage @@ -141811,6 +148854,7 @@ self: { testHaskellDepends = [ base text ]; description = "Add color and style decorations to IRC messages"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "irc-fun-messages" = callPackage @@ -141824,6 +148868,7 @@ self: { ]; description = "Types and functions for working with the IRC protocol"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "irc-fun-types" = callPackage @@ -141835,6 +148880,8 @@ self: { libraryHaskellDepends = [ base hashable text ]; description = "Common types for IRC related packages"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ircbot" = callPackage @@ -141903,6 +148950,7 @@ self: { ]; description = "RFC-based resource identifier library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "iridium" = callPackage @@ -141930,6 +148978,8 @@ self: { ]; description = "Automated Local Cabal Package Testing and Uploading"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iron-mq" = callPackage @@ -141941,6 +148991,8 @@ self: { libraryHaskellDepends = [ aeson base http-client lens text wreq ]; description = "Iron.IO message queueing client library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ironforge" = callPackage @@ -141963,6 +149015,7 @@ self: { ]; description = "A technical demo for Antisplice"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "irt" = callPackage @@ -141974,6 +149027,8 @@ self: { libraryHaskellDepends = [ ad base data-default-class statistics ]; description = "Item Response Theory functions for use in computerized adaptive testing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "is" = callPackage @@ -142017,6 +149072,8 @@ self: { ]; description = "An executable and library to determine if a file is a DICOM file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "isevaluated" = callPackage @@ -142028,6 +149085,7 @@ self: { libraryHaskellDepends = [ base vacuum ]; description = "Check whether a value has been evaluated"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "isiz" = callPackage @@ -142068,6 +149126,7 @@ self: { ]; description = "Advanced ESMTP library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "iso-deriving" = callPackage @@ -142139,6 +149198,8 @@ self: { ]; description = "Types and parser for ISO8601 durations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iso8601-time" = callPackage @@ -142176,6 +149237,8 @@ self: { ]; description = "A parser and generator for the ISO-14496-12/14 base media file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "isobmff-builder" = callPackage @@ -142200,6 +149263,7 @@ self: { ]; description = "A (bytestring-) builder for the ISO-14496-12 base media file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "isohunt" = callPackage @@ -142216,6 +149280,7 @@ self: { ]; description = "Bindings to the isoHunt torrent search API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "isotope" = callPackage @@ -142234,6 +149299,8 @@ self: { ]; description = "Isotopic masses and relative abundances"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ispositive" = callPackage @@ -142258,6 +149325,8 @@ self: { testHaskellDepends = [ base generic-lens QuickCheck ]; description = "Automatically derivable Has instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "itanium-abi" = callPackage @@ -142294,6 +149363,8 @@ self: { ]; description = "Issue Tracker for the CLI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "itemfield" = callPackage @@ -142321,6 +149392,8 @@ self: { ]; description = "A brick Widget for selectable summary of many elements on a terminal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iter-stats" = callPackage @@ -142339,6 +149412,7 @@ self: { ]; description = "iteratees for statistical processing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "iterIO" = callPackage @@ -142357,6 +149431,8 @@ self: { librarySystemDepends = [ zlib ]; description = "Iteratee-based IO with pipe operators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) zlib;}; "iterable" = callPackage @@ -142400,6 +149476,8 @@ self: { ]; description = "Iteratee-based I/O"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iteratee-compress" = callPackage @@ -142412,6 +149490,7 @@ self: { librarySystemDepends = [ bzip2 zlib ]; description = "Enumeratees for compressing and decompressing streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) bzip2; inherit (pkgs) zlib;}; "iteratee-mtl" = callPackage @@ -142429,6 +149508,7 @@ self: { ]; description = "Iteratee-based I/O"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "iteratee-parsec" = callPackage @@ -142444,6 +149524,7 @@ self: { ]; description = "Package allowing parsec parser initeratee"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "iteratee-stm" = callPackage @@ -142457,6 +149538,7 @@ self: { ]; description = "Concurrent iteratees using STM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "iterio-server" = callPackage @@ -142473,6 +149555,7 @@ self: { ]; description = "Library for building servers with IterIO"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "iterm-show" = callPackage @@ -142519,6 +149602,7 @@ self: { ]; description = "Orphan Show instances for diagrams package that render inline in some terminals"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ival" = callPackage @@ -142564,6 +149648,7 @@ self: { ]; description = "Theorem proving library based on dependent type theory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory" = callPackage @@ -142582,6 +149667,8 @@ self: { libraryToolDepends = [ alex happy ]; description = "Safe embedded C programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ivory-artifact" = callPackage @@ -142610,6 +149697,7 @@ self: { ]; description = "Ivory register bindings for the Atmega328p"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-backend-c" = callPackage @@ -142630,6 +149718,7 @@ self: { ]; description = "Ivory C backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-bitdata" = callPackage @@ -142648,6 +149737,7 @@ self: { executableHaskellDepends = [ base ivory ivory-backend-c ]; description = "Ivory bit-data support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-eval" = callPackage @@ -142666,6 +149756,7 @@ self: { ]; description = "Simple concrete evaluator for Ivory programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-examples" = callPackage @@ -142688,6 +149779,7 @@ self: { ]; description = "Ivory examples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-hw" = callPackage @@ -142700,6 +149792,7 @@ self: { libraryHaskellDepends = [ base filepath ivory ivory-artifact ]; description = "Ivory hardware model (STM32F4)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-opts" = callPackage @@ -142716,6 +149809,7 @@ self: { ]; description = "Ivory compiler optimizations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-quickcheck" = callPackage @@ -142737,6 +149831,7 @@ self: { ]; description = "QuickCheck driver for Ivory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-serialize" = callPackage @@ -142753,6 +149848,7 @@ self: { ]; description = "Serialization library for Ivory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivory-stdlib" = callPackage @@ -142765,6 +149861,7 @@ self: { libraryHaskellDepends = [ base filepath ivory ivory-artifact ]; description = "Ivory standard library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ivy-web" = callPackage @@ -142780,6 +149877,7 @@ self: { ]; description = "A lightweight web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "iwlib" = callPackage @@ -142838,6 +149936,8 @@ self: { executableHaskellDepends = [ base preprocessor-tools syb ]; description = "A preprocessor for expanding \"ixdo\" notation for indexed monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ixmonad" = callPackage @@ -142851,6 +149951,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Embeds effect systems into Haskell using parameteric effect monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ixset" = callPackage @@ -142942,6 +150044,8 @@ self: { ]; description = "A shallow embedding of the OpenGL Shading Language in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "iyql" = callPackage @@ -142961,6 +150065,7 @@ self: { ]; description = "CLI (command line interface) to YQL"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "j" = callPackage @@ -142975,6 +150080,8 @@ self: { testHaskellDepends = [ base bytestring repa tasty tasty-hunit ]; description = "J in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "j2hs" = callPackage @@ -142995,6 +150102,7 @@ self: { ]; description = "j2hs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ja-base-extra" = callPackage @@ -143039,6 +150147,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "DEPRECATED Bindings to the JACK Audio Connection Kit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libjack2;}; "jackminimix" = callPackage @@ -143050,6 +150160,8 @@ self: { libraryHaskellDepends = [ base hosc ]; description = "control JackMiniMix"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jacobi-roots" = callPackage @@ -143062,6 +150174,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Roots of two shifted Jacobi polynomials (Legendre and Radau) to double precision"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jaeger-flamegraph" = callPackage @@ -143087,6 +150201,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Generate flamegraphs from Jaeger .json dumps."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jail" = callPackage @@ -143102,6 +150218,7 @@ self: { ]; description = "Jailed IO monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jailbreak-cabal" = callPackage @@ -143151,6 +150268,8 @@ self: { ]; description = "Higher level functions for linear algebra. Wraps BLAS and LAPACKE."; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) blas; cblas = null; lapacke = null;}; "jammittools" = callPackage @@ -143216,6 +150335,8 @@ self: { ]; description = "Tool for searching java classes, members and fields in classfiles and JAR archives"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jarify" = callPackage @@ -143237,6 +150358,8 @@ self: { doHaddock = false; description = "Jarification of Haskell sources"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jason" = callPackage @@ -143256,6 +150379,8 @@ self: { testHaskellDepends = [ aeson base bytestring text ]; description = "A fast JASONETTE-iOS JSON combinator library for haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "java-adt" = callPackage @@ -143295,6 +150420,8 @@ self: { ]; description = "Bindings to the JNI and a high level interface generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "java-bridge-extras" = callPackage @@ -143306,6 +150433,7 @@ self: { libraryHaskellDepends = [ base java-bridge transformers ]; description = "Utilities for working with the java-bridge package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "java-character" = callPackage @@ -143317,6 +150445,7 @@ self: { libraryHaskellDepends = [ base diet ]; description = "Functions to simulate Java's Character class"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "java-poker" = callPackage @@ -143342,6 +150471,7 @@ self: { libraryHaskellDepends = [ base containers hx java-bridge ]; description = "Tools for reflecting on Java classes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "javaclass" = callPackage @@ -143384,6 +150514,8 @@ self: { testHaskellDepends = [ aeson base scotty stm text time wai-extra ]; description = "Remote Monad for JavaScript on the browser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "javascript-extras" = callPackage @@ -143424,6 +150556,7 @@ self: { ]; description = "A utility to print the SourceFile attribute of one or more Java class files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "javav" = callPackage @@ -143440,6 +150573,8 @@ self: { ]; description = "A utility to print the target version of Java class files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jbi" = callPackage @@ -143461,6 +150596,8 @@ self: { ]; description = "Just Build It - a \"do what I mean\" abstraction for Haskell build tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jcdecaux-vls" = callPackage @@ -143476,6 +150613,8 @@ self: { ]; description = "JCDecaux self-service bicycles API client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jdi" = callPackage @@ -143494,6 +150633,8 @@ self: { executableHaskellDepends = [ base mtl network ]; description = "Implementation of Java Debug Interface"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jenga" = callPackage @@ -143515,6 +150656,8 @@ self: { executableHaskellDepends = [ base optparse-applicative text ]; description = "Generate a cabal freeze file from a stack.yaml"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jenkinsPlugins2nix" = callPackage @@ -143538,6 +150681,8 @@ self: { testHaskellDepends = [ base containers tasty-hspec text ]; description = "Generate nix for Jenkins plugins"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jespresso" = callPackage @@ -143567,6 +150712,8 @@ self: { ]; description = "Extract all JavaScript from an HTML page and consolidate it in one script"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jinquantities" = callPackage @@ -143589,6 +150736,8 @@ self: { ]; description = "Unit conversion and manipulation library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jira-wiki-markup" = callPackage @@ -143630,6 +150779,7 @@ self: { ]; description = "QuasiQuotation library for programmatic generation of Javascript code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jmacro-rpc" = callPackage @@ -143648,6 +150798,7 @@ self: { ]; description = "JSON-RPC clients and servers using JMacro, and evented client-server Reactive Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jmacro-rpc-happstack" = callPackage @@ -143664,6 +150815,7 @@ self: { ]; description = "Happstack backend for jmacro-rpc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jmacro-rpc-snap" = callPackage @@ -143679,6 +150831,7 @@ self: { ]; description = "Snap backend for jmacro-rpc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jml-web-service" = callPackage @@ -143699,6 +150852,8 @@ self: { testHaskellDepends = [ base protolude tasty ]; description = "Common utilities for running a web service"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jmonkey" = callPackage @@ -143711,6 +150866,7 @@ self: { testHaskellDepends = [ base casing free jmacro ]; description = "Jmonkey is very restricted but handy EDSL for JavaScript"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jni" = callPackage @@ -143733,6 +150889,8 @@ self: { testHaskellDepends = [ base hspec singletons ]; description = "Complete JNI raw bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) jdk;}; "jobqueue" = callPackage @@ -143758,6 +150916,8 @@ self: { ]; description = "A job queue library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jobs-ui" = callPackage @@ -143778,6 +150938,7 @@ self: { ]; description = "A library for creating a jobs management website running custom jobs"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "join" = callPackage @@ -143790,6 +150951,7 @@ self: { libraryHaskellDepends = [ base haskell98 multisetrewrite stm ]; description = "Parallel Join Patterns with Guards and Propagation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "join-api" = callPackage @@ -143803,6 +150965,8 @@ self: { ]; description = "Bindings for Join push notifications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "joinlist" = callPackage @@ -143814,6 +150978,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Join list - symmetric list type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "joint" = callPackage @@ -143844,6 +151010,8 @@ self: { ]; description = "An implementation of the Jonathan's Card API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jord" = callPackage @@ -143948,6 +151116,7 @@ self: { ]; description = "Tiny markdown notebook"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "jpeg" = callPackage @@ -143959,6 +151128,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A library for decoding JPEG files written in pure Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jps" = callPackage @@ -144020,6 +151191,8 @@ self: { libraryHaskellDepends = [ base wl-pprint ]; description = "Javascript: The Good Parts -- AST & Pretty Printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "js-jquery" = callPackage @@ -144099,6 +151272,8 @@ self: { executableHaskellDepends = [ base jsaddle lens text ]; description = "JSaddle Hello World, an example package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsaddle-warp" = callPackage @@ -144180,6 +151355,8 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsc" = callPackage @@ -144208,6 +151385,7 @@ self: { libraryHaskellDepends = [ base DOM mtl WebBits ]; description = "Javascript Monadic Writer base package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json" = callPackage @@ -144236,6 +151414,8 @@ self: { libraryHaskellDepends = [ aeson base ]; description = "Union 'alternative' or Either that has untagged JSON encoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-api" = callPackage @@ -144296,6 +151476,8 @@ self: { ]; description = "Test that your (Aeson) JSON encoding matches your expectations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-ast" = callPackage @@ -144328,6 +151510,7 @@ self: { ]; description = "Encoders of JSON AST"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "json-ast-quickcheck" = callPackage @@ -144342,6 +151525,8 @@ self: { ]; description = "Compatibility layer for \"json-ast\" and \"QuickCheck\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-autotype" = callPackage @@ -144376,6 +151561,7 @@ self: { ]; description = "Automatic type declaration for JSON input data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json-b" = callPackage @@ -144398,6 +151584,7 @@ self: { ]; description = "JSON parser that uses byte strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json-builder" = callPackage @@ -144416,6 +151603,8 @@ self: { ]; description = "Data structure agnostic JSON serialization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-bytes-builder" = callPackage @@ -144470,6 +151659,8 @@ self: { ]; description = "A direct-to-bytes single-pass JSON encoder with a declarative DSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-enumerator" = callPackage @@ -144487,6 +151678,7 @@ self: { ]; description = "Pure-Haskell utilities for dealing with JSON with the enumerator package. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json-extra" = callPackage @@ -144503,6 +151695,8 @@ self: { ]; description = "Utility functions to extend Aeson"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-feed" = callPackage @@ -144540,6 +151734,8 @@ self: { ]; description = "Generic JSON serialization / deserialization"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-incremental-decoder" = callPackage @@ -144564,6 +151760,7 @@ self: { ]; description = "Incremental JSON parser with early termination and a declarative DSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "json-litobj" = callPackage @@ -144576,6 +151773,8 @@ self: { testHaskellDepends = [ base hspec json QuickCheck ]; description = "Extends Text.JSON to handle literal JS objects."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-pointer" = callPackage @@ -144620,6 +151819,8 @@ self: { ]; description = "JSON Pointer extensions for Hasql"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-pointy" = callPackage @@ -144644,6 +151845,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "JSON Pointer (RFC 6901) parsing, access, and modification"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-python" = callPackage @@ -144660,6 +151863,8 @@ self: { libraryPkgconfigDepends = [ python ]; description = "Call python inline from haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {python = null;}; "json-qq" = callPackage @@ -144699,6 +151904,7 @@ self: { ]; description = "Kitchen sink for querying JSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json-rpc" = callPackage @@ -144757,6 +151963,8 @@ self: { ]; description = "JSON-RPC 2.0 on the client side."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-rpc-generic" = callPackage @@ -144826,6 +152034,8 @@ self: { ]; description = "Types and type classes for defining JSON schemas"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-sop" = callPackage @@ -144905,6 +152115,7 @@ self: { ]; description = "High-performance JSON parser and encoder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json-to-haskell" = callPackage @@ -144953,6 +152164,7 @@ self: { ]; description = "Effectful parsing of JSON documents"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "json-tokens" = callPackage @@ -144980,6 +152192,7 @@ self: { ]; description = "Tokenize JSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json-tools" = callPackage @@ -144999,6 +152212,8 @@ self: { ]; description = "A collection of JSON tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-tracer" = callPackage @@ -145022,6 +152237,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "A polymorphic, type-safe, json-structured tracing library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json-types" = callPackage @@ -145049,6 +152266,8 @@ self: { ]; description = "Library provides support for JSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "json2-hdbc" = callPackage @@ -145064,6 +152283,7 @@ self: { ]; description = "Support JSON for SQL Database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "json2-types" = callPackage @@ -145123,6 +152343,8 @@ self: { ]; description = "Filter select values in JSON objects to unix programs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsonifier" = callPackage @@ -145143,6 +152365,7 @@ self: { ]; description = "Fast and simple JSON encoding toolkit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jsonnet" = callPackage @@ -145176,6 +152399,8 @@ self: { ]; description = "Jsonnet implementaton in pure Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsonpath" = callPackage @@ -145212,6 +152437,8 @@ self: { ]; description = "Parser and datatypes for the JSON Resume format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsonrpc-conduit" = callPackage @@ -145264,6 +152491,7 @@ self: { ]; description = "JSON to JSON Schema"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jsonschema-gen" = callPackage @@ -145285,6 +152513,8 @@ self: { ]; description = "JSON Schema generator from Algebraic data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsonsql" = callPackage @@ -145305,6 +152535,8 @@ self: { ]; description = "Interpolate JSON object values into SQL strings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsontsv" = callPackage @@ -145325,6 +152557,8 @@ self: { ]; description = "JSON to TSV transformer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsonxlsx" = callPackage @@ -145345,6 +152579,8 @@ self: { ]; description = "json to xlsx converter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jsop" = callPackage @@ -145384,6 +152620,7 @@ self: { ]; description = "Extract substructures from JSON by following a path"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "juandelacosa" = callPackage @@ -145433,6 +152670,8 @@ self: { ]; description = "Tableau-based theorem prover for justification logic"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "judy" = callPackage @@ -145448,6 +152687,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Fast, scalable, mutable dynamic arrays, maps and hashes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {Judy = null;}; "juicy-draw" = callPackage @@ -145569,6 +152810,8 @@ self: { ]; description = "A library for creating and using Jupyter kernels"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "justified-containers" = callPackage @@ -145610,6 +152853,7 @@ self: { ]; description = "Call JVM methods from Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jvm-batching" = callPackage @@ -145636,6 +152880,7 @@ self: { ]; description = "Provides batched marshalling of values between Java and Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jvm-binary" = callPackage @@ -145668,6 +152913,8 @@ self: { ]; description = "A library for reading Java class-files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jvm-parser" = callPackage @@ -145684,6 +152931,8 @@ self: { ]; description = "A parser for JVM bytecode files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jvm-streaming" = callPackage @@ -145710,6 +152959,7 @@ self: { ]; description = "Expose Java iterators as streams from the streaming package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "jwt" = callPackage @@ -145759,6 +153009,8 @@ self: { ]; description = "An implementation of the Kademlia DHT Protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kafka" = callPackage @@ -145789,6 +153041,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Low-level Haskell client library for Apache Kafka 0.7."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kafka-client-sync" = callPackage @@ -145803,6 +153057,8 @@ self: { testHaskellDepends = [ base hw-kafka-client monad-parallel text ]; description = "Synchronous Kafka Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kafka-device" = callPackage @@ -145823,6 +153079,7 @@ self: { ]; description = "UI device events via a Kafka message broker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kafka-device-glut" = callPackage @@ -145837,6 +153094,7 @@ self: { executableHaskellDepends = [ base GLUT kafka-device OpenGL ]; description = "GLUT events via a Kafka message broker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kafka-device-joystick" = callPackage @@ -145857,6 +153115,7 @@ self: { ]; description = "Linux joystick events via a Kafka message broker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kafka-device-leap" = callPackage @@ -145875,6 +153134,7 @@ self: { ]; description = "Leap Motion events via a Kafka message broker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kafka-device-spacenav" = callPackage @@ -145895,6 +153155,7 @@ self: { ]; description = "Linux SpaceNavigator events via a Kafka message broker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kafka-device-vrpn" = callPackage @@ -145909,6 +153170,7 @@ self: { executableHaskellDepends = [ base kafka-device vrpn ]; description = "VRPN events via a Kafka message broker"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kaleidoscope" = callPackage @@ -145931,6 +153193,7 @@ self: { doHaddock = false; description = "Haskell Kaleidoscope tutorial"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kalman" = callPackage @@ -145950,6 +153213,8 @@ self: { ]; description = "Kalman and particle filters and smoothers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kan-extensions" = callPackage @@ -145979,6 +153244,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Binary parsing with random access"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kanji" = callPackage @@ -146046,6 +153313,7 @@ self: { ]; description = "Kansas Lava is a hardware simulator and VHDL generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kansas-lava-cores" = callPackage @@ -146065,6 +153333,7 @@ self: { ]; description = "FPGA Cores Written in Kansas Lava"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kansas-lava-papilio" = callPackage @@ -146083,6 +153352,7 @@ self: { ]; description = "Kansas Lava support files for the Papilio FPGA board"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kansas-lava-shake" = callPackage @@ -146099,6 +153369,7 @@ self: { ]; description = "Shake rules for building Kansas Lava projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "karakuri" = callPackage @@ -146114,6 +153385,7 @@ self: { ]; description = "Good stateful automata"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "karps" = callPackage @@ -146141,6 +153413,8 @@ self: { ]; description = "Haskell bindings for Spark Dataframes and Datasets"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "karver" = callPackage @@ -146247,6 +153521,7 @@ self: { ]; description = "ElasticSearch scribe for the Katip logging framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "katip-kafka" = callPackage @@ -146260,6 +153535,8 @@ self: { ]; description = "Katip scribe to send logs to Kafka"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "katip-logstash" = callPackage @@ -146318,6 +153595,8 @@ self: { ]; description = "Katip scribe for raven (https://sentry.io)"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "katip-rollbar" = callPackage @@ -146334,6 +153613,7 @@ self: { ]; description = "Katip scribe that logs to Rollbar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "katip-scalyr-scribe" = callPackage @@ -146352,6 +153632,8 @@ self: { ]; description = "A katip scribe for logging to json"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "katip-syslog" = callPackage @@ -146368,6 +153650,8 @@ self: { testHaskellDepends = [ base ]; description = "Syslog Katip Scribe"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "katt" = callPackage @@ -146389,6 +153673,8 @@ self: { testHaskellDepends = [ base bytestring directory mtl ]; description = "Client for the Kattis judge system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "katydid" = callPackage @@ -146422,6 +153708,8 @@ self: { ]; description = "A haskell implementation of Katydid"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kawa" = callPackage @@ -146468,6 +153756,7 @@ self: { ]; description = "Utilities for serving static sites and blogs with Wai/Warp"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "kawhi" = callPackage @@ -146490,6 +153779,8 @@ self: { ]; description = "stats.NBA.com library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kazura-queue" = callPackage @@ -146559,6 +153850,8 @@ self: { ]; description = "A simple k-d tree implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kdesrc-build-extra" = callPackage @@ -146577,6 +153870,8 @@ self: { ]; description = "Build profiles for kdesrc-build"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kdesrc-build-profiles" = callPackage @@ -146639,6 +153934,8 @@ self: { ]; description = "cryptographic functions based on the sponge construction"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "keenser" = callPackage @@ -146705,6 +154002,7 @@ self: { ]; description = "Rapid Gtk Application Development - I18N"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-mvc-controller" = callPackage @@ -146732,6 +154030,7 @@ self: { ]; description = "Haskell on Gtk rails - Gtk-based global environment for MVC applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-mvc-model-lightmodel" = callPackage @@ -146748,6 +154047,7 @@ self: { ]; description = "Rapid Gtk Application Development - Reactive Protected Light Models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-mvc-model-protectedmodel" = callPackage @@ -146764,6 +154064,7 @@ self: { ]; description = "Rapid Gtk Application Development - Protected Reactive Models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-mvc-solutions-config" = callPackage @@ -146796,6 +154097,7 @@ self: { ]; description = "Haskell on Gtk rails - Common solutions to recurrent problems in Gtk applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-mvc-view" = callPackage @@ -146838,6 +154140,7 @@ self: { ]; description = "Reactive Haskell on Rails - CBMVars as reactive values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactive-fs" = callPackage @@ -146853,6 +154156,7 @@ self: { ]; description = "Haskell on Rails - Files as Reactive Values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactive-gtk" = callPackage @@ -146869,6 +154173,7 @@ self: { ]; description = "Haskell on Gtk rails - Reactive Fields for Gtk widgets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactive-htmldom" = callPackage @@ -146886,6 +154191,7 @@ self: { ]; description = "Keera Hails Reactive bindings for HTML DOM via GHCJS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactive-network" = callPackage @@ -146901,6 +154207,7 @@ self: { ]; description = "Haskell on Rails - Sockets as Reactive Values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactive-polling" = callPackage @@ -146915,6 +154222,7 @@ self: { ]; description = "Haskell on Rails - Polling based Readable RVs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactive-wx" = callPackage @@ -146928,6 +154236,7 @@ self: { ]; description = "Haskell on Rails - Reactive Fields for WX widgets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactive-yampa" = callPackage @@ -146943,6 +154252,7 @@ self: { ]; description = "Haskell on Rails - FRP Yampa Signal Functions as RVs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactivelenses" = callPackage @@ -146954,6 +154264,7 @@ self: { libraryHaskellDepends = [ base keera-hails-reactivevalues lens ]; description = "Reactive Haskell on Rails - Lenses applied to Reactive Values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keera-hails-reactivevalues" = callPackage @@ -146973,6 +154284,8 @@ self: { testToolDepends = [ cabal-install ]; description = "Haskell on Rails - Reactive Values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "keera-posture" = callPackage @@ -147064,6 +154377,8 @@ self: { doHaddock = false; description = "Kempe compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kerry" = callPackage @@ -147086,6 +154401,8 @@ self: { ]; description = "Manage and abstract your packer configurations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kesha" = callPackage @@ -147140,6 +154457,8 @@ self: { ]; description = "Web application deployment manager, focusing on Haskell web frameworks"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kevin" = callPackage @@ -147160,6 +154479,7 @@ self: { ]; description = "a dAmn ↔ IRC proxy"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "key" = callPackage @@ -147246,6 +154566,8 @@ self: { libraryHaskellDepends = [ base containers vector ]; description = "Generic indexing for many data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "keylayouts" = callPackage @@ -147270,6 +154592,8 @@ self: { libraryHaskellDepends = [ base udbus ]; description = "Keyring access"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "keys" = callPackage @@ -147317,6 +154641,7 @@ self: { ]; description = "back up a secret key securely to the cloud"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "keystore" = callPackage @@ -147364,6 +154689,7 @@ self: { ]; description = "Pure Haskell key/value store implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "keyword-args" = callPackage @@ -147385,6 +154711,7 @@ self: { ]; description = "Extract data from a keyword-args config file format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "khph" = callPackage @@ -147404,6 +154731,8 @@ self: { ]; description = "Command-line file tagging and organization tool"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ki" = callPackage @@ -147448,6 +154777,7 @@ self: { ]; description = "Parser and writer for KiCad files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kickass-torrents-dump-parser" = callPackage @@ -147465,6 +154795,8 @@ self: { ]; description = "Parses kat.ph torrent dumps"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kickchan" = callPackage @@ -147483,6 +154815,8 @@ self: { ]; description = "Kick Channels: bounded channels with non-blocking writes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kif-parser" = callPackage @@ -147501,6 +154835,7 @@ self: { ]; description = "Process KIF iOS test logs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kind-apply" = callPackage @@ -147570,6 +154905,7 @@ self: { ]; description = "A dependency manager for Xcode (Objective-C) projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kleene" = callPackage @@ -147591,6 +154927,7 @@ self: { ]; description = "Kleene algebra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kleene-list" = callPackage @@ -147640,6 +154977,7 @@ self: { ]; description = "Sequential and parallel implementations of Lloyd's algorithm"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "kmeans-vector" = callPackage @@ -147656,6 +154994,7 @@ self: { benchmarkHaskellDepends = [ base criterion QuickCheck vector ]; description = "An implementation of the kmeans clustering algorithm based on the vector package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kmonad" = callPackage @@ -147675,6 +155014,8 @@ self: { executableHaskellDepends = [ base ]; description = "Advanced keyboard remapping utility"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kmp-dfa" = callPackage @@ -147687,6 +155028,8 @@ self: { testHaskellDepends = [ array base QuickCheck ]; description = "KMP algorithm implementation, based on Deterministic Finite State Automata"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "knead" = callPackage @@ -147708,6 +155051,7 @@ self: { ]; description = "Repa-like array processing using LLVM JIT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "knead-arithmetic" = callPackage @@ -147721,6 +155065,7 @@ self: { ]; description = "Linear algebra and interpolation using LLVM JIT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "knit" = callPackage @@ -147772,6 +155117,7 @@ self: { ]; description = "a minimal Rmarkdown sort-of-thing for haskell, by way of Pandoc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "knob" = callPackage @@ -147801,6 +155147,7 @@ self: { executableHaskellDepends = [ base containers parallel ]; description = "Khovanov homology computations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "koellner-phonetic" = callPackage @@ -147814,6 +155161,8 @@ self: { doHaddock = false; description = "\"map German words to code representing pronunciation\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "koji" = callPackage @@ -147853,6 +155202,8 @@ self: { ]; description = "JSON config file parsing based on unjson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kontrakcja-templates" = callPackage @@ -147922,6 +155273,7 @@ self: { ]; description = "The Korfu ORF Utility"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "kparams" = callPackage @@ -147938,6 +155290,8 @@ self: { doHaddock = false; description = "Extracts values from /proc/cmdline"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kqueue" = callPackage @@ -147951,6 +155305,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "A binding to the kqueue event library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kraken" = callPackage @@ -147968,6 +155324,8 @@ self: { ]; description = "Kraken.io API client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "krank" = callPackage @@ -148023,6 +155381,8 @@ self: { ]; description = "Haskell bindings for Spark Dataframes and Datasets"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "krpc" = callPackage @@ -148048,6 +155408,8 @@ self: { ]; description = "KRPC protocol implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ks-test" = callPackage @@ -148059,6 +155421,7 @@ self: { libraryHaskellDepends = [ base gamma random-fu roots vector ]; description = "Kolmogorov distribution and Kolmogorov-Smirnov test"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "ksystools" = callPackage @@ -148082,6 +155445,8 @@ self: { libraryPkgconfigDepends = [ egl glew ]; description = "A binding for libktx from Khronos"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {egl = null; inherit (pkgs) glew;}; "ktx-codec" = callPackage @@ -148101,6 +155466,8 @@ self: { ]; description = "Khronos texture format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kubernetes-client" = callPackage @@ -148136,6 +155503,7 @@ self: { ]; description = "Client library for Kubernetes"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "kubernetes-client-core" = callPackage @@ -148190,6 +155558,8 @@ self: { libraryHaskellDepends = [ base boxes containers lens ]; description = "A Quantitative Information Flow aware programming language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kure" = callPackage @@ -148212,6 +155582,8 @@ self: { libraryHaskellDepends = [ base kure template-haskell ]; description = "Generator for Boilerplate KURE Combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kurita" = callPackage @@ -148244,6 +155616,7 @@ self: { testHaskellDepends = [ base ]; description = "Find the alpha emoji"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "kvitable" = callPackage @@ -148288,6 +155661,8 @@ self: { librarySystemDepends = [ lbfgsb ]; description = "Bindings to L-BFGS-B, Fortran code for limited-memory quasi-Newton bound-constrained optimization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {lbfgsb = null;}; "l10n" = callPackage @@ -148310,6 +155685,8 @@ self: { libraryHaskellDepends = [ base labeled-tree ]; description = "Labeled graph structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "labeled-tree" = callPackage @@ -148355,6 +155732,7 @@ self: { ]; description = "an experiment management framework"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "labsat" = callPackage @@ -148378,6 +155756,7 @@ self: { ]; description = "LabSat TCP Interface Wrapper"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "labyrinth" = callPackage @@ -148399,6 +155778,7 @@ self: { ]; description = "A complicated turn-based game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "labyrinth-server" = callPackage @@ -148432,6 +155812,7 @@ self: { ]; description = "A complicated turn-based game - Web server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lackey" = callPackage @@ -148475,6 +155856,8 @@ self: { ]; description = "Solve Lagrange multiplier problems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "laika" = callPackage @@ -148494,6 +155877,7 @@ self: { ]; description = "Minimalistic type-checked compile-time template engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lambda-ast" = callPackage @@ -148519,6 +155903,8 @@ self: { executableHaskellDepends = [ base ]; description = "A bridge from Haskell (on a CPU) to VHDL on a FPGA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambda-calculator" = callPackage @@ -148538,6 +155924,7 @@ self: { testHaskellDepends = [ base containers hlint hspec HUnit ]; description = "A lambda calculus interpreter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lambda-calculus-interpreter" = callPackage @@ -148564,6 +155951,8 @@ self: { libraryHaskellDepends = [ base GLUT mtl OpenGL time ]; description = "Educational drawing canvas for FP explorers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambda-devs" = callPackage @@ -148590,6 +155979,7 @@ self: { ]; description = "a Paralell-DEVS implementaion based on distributed-process"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambda-options" = callPackage @@ -148604,6 +155994,7 @@ self: { ]; description = "Declarative command-line parser with type-driven pattern matching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambda-placeholders" = callPackage @@ -148644,6 +156035,8 @@ self: { executableHaskellDepends = [ base ]; description = "An application to work with the lambda calculus (for learning)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambda2js" = callPackage @@ -148657,6 +156050,8 @@ self: { executableHaskellDepends = [ base parsec ]; description = "Untyped Lambda calculus to JavaScript compiler"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambdaBase" = callPackage @@ -148668,6 +156063,8 @@ self: { libraryHaskellDepends = [ base parsec ]; testHaskellDepends = [ base parsec ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambdaFeed" = callPackage @@ -148681,6 +156078,7 @@ self: { executableHaskellDepends = [ base haskell98 html ]; description = "RSS 2.0 feed generator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "lambdaLit" = callPackage @@ -148698,6 +156096,7 @@ self: { ]; description = "..."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lambdabot" = callPackage @@ -148888,6 +156287,8 @@ self: { ]; description = "Utility libraries for the advanced IRC bot, Lambdabot"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambdabot-xmpp" = callPackage @@ -148934,6 +156335,7 @@ self: { testHaskellDepends = [ base hspec HUnit text ]; description = "Lambdabot for Zulip Chat"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacat" = callPackage @@ -148977,6 +156379,8 @@ self: { ]; description = "LambdaCms 'core' subsite for Yesod apps"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambdacms-media" = callPackage @@ -148993,6 +156397,7 @@ self: { ]; description = "LambdaCms \"media\" extension"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube" = callPackage @@ -149006,6 +156411,7 @@ self: { executableHaskellDepends = [ base editline mtl pretty ]; description = "A simple lambda cube type checker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-bullet" = callPackage @@ -149019,6 +156425,7 @@ self: { ]; description = "Example for combining LambdaCube and Bullet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-compiler" = callPackage @@ -149043,6 +156450,7 @@ self: { ]; description = "LambdaCube 3D is a DSL to program GPUs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-core" = callPackage @@ -149058,6 +156466,7 @@ self: { ]; description = "LambdaCube 3D IR"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-edsl" = callPackage @@ -149074,6 +156483,7 @@ self: { ]; description = "LambdaCube 3D EDSL definition"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-engine" = callPackage @@ -149093,6 +156503,7 @@ self: { ]; description = "3D rendering engine written entirely in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-examples" = callPackage @@ -149109,6 +156520,7 @@ self: { ]; description = "Examples for LambdaCube"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-gl" = callPackage @@ -149127,6 +156539,7 @@ self: { ]; description = "OpenGL 3.3 Core Profile backend for LambdaCube 3D"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacube-ir" = callPackage @@ -149138,6 +156551,8 @@ self: { libraryHaskellDepends = [ aeson base containers mtl text vector ]; description = "LambdaCube 3D intermediate representation of 3D graphics pipelines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambdacube-samples" = callPackage @@ -149159,6 +156574,7 @@ self: { ]; description = "Samples for LambdaCube 3D"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdatex" = callPackage @@ -149179,6 +156595,8 @@ self: { ]; description = "Type-Safe LaTeX EDSL"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambdatwit" = callPackage @@ -149204,6 +156622,8 @@ self: { ]; description = "Lambdabot running as a twitter bot. Similar to the @fsibot f# bot."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lambdaya-bus" = callPackage @@ -149217,6 +156637,7 @@ self: { ]; description = "Fpga bus core and serialization for RedPitaya"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "lambdiff" = callPackage @@ -149234,6 +156655,7 @@ self: { ]; description = "Diff Viewer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lame" = callPackage @@ -149259,6 +156681,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Fairly complete high-level binding to LAME encoder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {mp3lame = null;}; "lame-tester" = callPackage @@ -149275,6 +156699,8 @@ self: { testHaskellDepends = [ bizzlelude containers tasty tasty-hunit ]; description = "A strange and unnecessary selective test-running library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lang" = callPackage @@ -149286,6 +156712,7 @@ self: { libraryHaskellDepends = [ base bytestring http-streams Mapping ]; description = "A Lisp"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "language-Modula2" = callPackage @@ -149318,6 +156745,7 @@ self: { ]; description = "Parser, pretty-printer, and more for the Modula-2 programming language"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; }) {}; "language-asn" = callPackage @@ -149336,6 +156764,8 @@ self: { ]; description = "ASN.1 encoding and decoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-asn1" = callPackage @@ -149437,6 +156867,7 @@ self: { ]; description = "Interpreter and language infrastructure for Boogie"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "language-c" = callPackage @@ -149487,6 +156918,8 @@ self: { libraryToolDepends = [ alex ]; description = "Extracting comments from C code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-c-inline" = callPackage @@ -149503,6 +156936,8 @@ self: { ]; description = "Inline C & Objective-C code in Haskell for language interoperability"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-c-quote" = callPackage @@ -149596,6 +157031,8 @@ self: { ]; description = "Conf parsers and pretty-printers for the Haskell programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-csharp" = callPackage @@ -149610,6 +157047,8 @@ self: { libraryToolDepends = [ alex ]; description = "C# source code manipulation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-css" = callPackage @@ -149633,6 +157072,8 @@ self: { testHaskellDepends = [ base hspec raw-strings-qq ]; description = "Manipulating Dart source: abstract syntax and pretty-printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-dickinson" = callPackage @@ -149721,6 +157162,8 @@ self: { ]; description = "Dockerfile linter, parser, pretty-printer and embedded DSL"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-dot" = callPackage @@ -149794,6 +157237,7 @@ self: { libraryToolDepends = [ alex ]; description = "Parser and pretty printer for the Eiffel language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "language-elm" = callPackage @@ -149811,6 +157255,8 @@ self: { testToolDepends = [ doctest ]; description = "Generate elm code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-fortran" = callPackage @@ -149835,6 +157281,8 @@ self: { libraryHaskellDepends = [ base bifunctors parsers ]; description = "Something similar to Dijkstra's guarded command language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-gemini" = callPackage @@ -149880,6 +157328,8 @@ self: { libraryHaskellDepends = [ array base parsec utf8-string ]; description = "A library for analysis and synthesis of Go code"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-guess" = callPackage @@ -149892,6 +157342,8 @@ self: { libraryHaskellDepends = [ base bytestring cereal containers ]; description = "Guess at which language a text is written in using trigrams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-haskell-extract" = callPackage @@ -149929,6 +157381,8 @@ self: { ]; description = "HCL parsers and pretty-printers for the Haskell programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-java" = callPackage @@ -149965,6 +157419,8 @@ self: { ]; description = "Parser for Java .class files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-javascript" = callPackage @@ -150021,6 +157477,7 @@ self: { ]; description = "Parser and serializer for the Kort information language"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "language-lua" = callPackage @@ -150061,6 +157518,8 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-lua2" = callPackage @@ -150086,6 +157545,8 @@ self: { ]; description = "Lua parser and pretty printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-mixal" = callPackage @@ -150100,6 +157561,8 @@ self: { executableHaskellDepends = [ base pretty ]; description = "Parser, pretty-printer, and AST types for the MIXAL assembly language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-ninja" = callPackage @@ -150138,6 +157601,7 @@ self: { ]; description = "A library for dealing with the Ninja build language"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "language-nix" = callPackage @@ -150185,6 +157649,7 @@ self: { ]; description = "Parser, pretty-printer, and more for the Oberon programming language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "language-objc" = callPackage @@ -150202,6 +157667,8 @@ self: { libraryToolDepends = [ alex happy ]; description = "Analysis and generation of Objective C code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-ocaml" = callPackage @@ -150227,6 +157694,8 @@ self: { ]; description = "Language tools for manipulating OCaml programs in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) zlib;}; "language-openscad" = callPackage @@ -150243,6 +157712,8 @@ self: { executableHaskellDepends = [ attoparsec base bytestring ]; description = "A simple parser for OpenSCAD"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-pig" = callPackage @@ -150263,6 +157734,8 @@ self: { ]; description = "Pig parser in haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-protobuf" = callPackage @@ -150316,6 +157789,8 @@ self: { ]; description = "Tools to parse and evaluate the Puppet DSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-python" = callPackage @@ -150347,6 +157822,7 @@ self: { ]; description = "Generate coloured XHTML for Python code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "language-python-test" = callPackage @@ -150376,6 +157852,7 @@ self: { ]; description = "Utilities for working with the Qux language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "language-rust" = callPackage @@ -150405,6 +157882,8 @@ self: { ]; description = "Parsing and pretty printing of Rust code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-sally" = callPackage @@ -150433,6 +157912,8 @@ self: { ]; description = "A package for parsing shell scripts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-slice" = callPackage @@ -150471,6 +157952,7 @@ self: { ]; description = "Various tools to detect/correct mistakes in words"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "language-sqlite" = callPackage @@ -150486,6 +157968,8 @@ self: { ]; description = "Full parser and generator for SQL as implemented by SQLite3"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-sygus" = callPackage @@ -150500,6 +157984,8 @@ self: { testHaskellDepends = [ base deepseq tasty tasty-hunit text ]; description = "A parser and printer for the SyGuS 2.0 language."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-thrift" = callPackage @@ -150544,6 +158030,8 @@ self: { ]; description = "A Parser for the Type Language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-typescript" = callPackage @@ -150555,6 +158043,8 @@ self: { libraryHaskellDepends = [ base containers parsec pretty ]; description = "A library for working with TypeScript Definition files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-vhdl" = callPackage @@ -150566,6 +158056,8 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "VHDL AST and pretty printer in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-webidl" = callPackage @@ -150578,6 +158070,8 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Parser and Pretty Printer for WebIDL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "laop" = callPackage @@ -150622,6 +158116,7 @@ self: { ]; description = "Numerical Linear Algebra using LAPACK"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lapack-carray" = callPackage @@ -150638,6 +158133,7 @@ self: { ]; description = "Auto-generated interface to Fortran LAPACK via CArrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lapack-comfort-array" = callPackage @@ -150654,6 +158150,7 @@ self: { ]; description = "Auto-generated interface to Fortran LAPACK via comfort-array"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lapack-ffi" = callPackage @@ -150666,6 +158163,8 @@ self: { libraryPkgconfigDepends = [ liblapack ]; description = "Auto-generated interface to Fortran LAPACK"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {liblapack = null;}; "lapack-ffi-tools" = callPackage @@ -150718,6 +158217,8 @@ self: { ]; description = "Efficiently hash (large) Haskell values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "largeword" = callPackage @@ -150754,6 +158255,7 @@ self: { ]; description = "Tool to track security alerts on LWN"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "latest-npm-version" = callPackage @@ -150784,6 +158286,8 @@ self: { ]; description = "Find the latest version of a package on npm"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "latex" = callPackage @@ -150813,6 +158317,7 @@ self: { ]; description = "Use actual LaTeX to render formulae inside Hakyll pages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "latex-formulae-image" = callPackage @@ -150831,6 +158336,8 @@ self: { ]; description = "A library for rendering LaTeX formulae as images using an actual LaTeX installation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "latex-formulae-pandoc" = callPackage @@ -150852,6 +158359,7 @@ self: { ]; description = "Render LaTeX formulae in pandoc documents to images with an actual LaTeX installation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "latex-function-tables" = callPackage @@ -150904,6 +158412,7 @@ self: { ]; description = "Use actual LaTeX to render formulae inside Hakyll pages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "latex-svg-image" = callPackage @@ -150921,6 +158430,8 @@ self: { ]; description = "A library for rendering LaTeX formulae as SVG using an actual LaTeX"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "latex-svg-pandoc" = callPackage @@ -150940,6 +158451,7 @@ self: { executableHaskellDepends = [ base latex-svg-image pandoc-types ]; description = "Render LaTeX formulae in pandoc documents to images with an actual LaTeX"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lattices" = callPackage @@ -151015,6 +158527,8 @@ self: { executableHaskellDepends = [ base ]; description = "High and low-level interface to the Novation Launchpad midi controller"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lawful" = callPackage @@ -151047,6 +158561,8 @@ self: { benchmarkHaskellDepends = [ base machines time ]; description = "Concurrent networked stream transducers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lawz" = callPackage @@ -151091,6 +158607,7 @@ self: { ]; description = "Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "layers" = callPackage @@ -151102,6 +158619,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Modular type class machinery for monad transformer stacks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "layers-game" = callPackage @@ -151121,6 +158640,7 @@ self: { ]; description = "A prototypical 2d platform game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "layout" = callPackage @@ -151132,6 +158652,8 @@ self: { libraryHaskellDepends = [ base convertible hinduce-missingh ]; description = "Turn values into pretty text or markup"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "layout-bootstrap" = callPackage @@ -151143,6 +158665,8 @@ self: { libraryHaskellDepends = [ base blaze-html containers text ]; description = "Template and widgets for Bootstrap2 to use with Text.Blaze.Html5"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "layout-rules" = callPackage @@ -151169,6 +158693,7 @@ self: { ]; description = "General layouting library. Currently supports layouting 2D areas and can be used as a backend for text pretty printing or automatic windows layouting managers."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "lazy" = callPackage @@ -151212,6 +158737,7 @@ self: { ]; description = "Identifiers for not-yet-computed values"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "lazy-hash-cache" = callPackage @@ -151232,6 +158758,7 @@ self: { ]; description = "Storing computed values for re-use when the same program runs again"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "lazy-io" = callPackage @@ -151272,6 +158799,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Lazy-Spined Monadic Priority Queues"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lazy-search" = callPackage @@ -151294,6 +158823,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Efficient implementation of lazy monolithic arrays (lazy in indexes)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lazyboy" = callPackage @@ -151313,6 +158844,8 @@ self: { ]; description = "An EDSL for programming the Game Boy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lazyio" = callPackage @@ -151343,6 +158876,8 @@ self: { ]; description = "Set and Map from lazy/infinite lists"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lazysmallcheck" = callPackage @@ -151411,6 +158946,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Data structures for representing arbitrary intervals"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lda" = callPackage @@ -151426,6 +158963,8 @@ self: { ]; description = "Online Latent Dirichlet Allocation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ldap-client" = callPackage @@ -151462,6 +159001,7 @@ self: { ]; description = "LDIF idempotent apply tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ldif" = callPackage @@ -151484,6 +159024,8 @@ self: { testHaskellDepends = [ base HUnit ]; description = "The LDAP Data Interchange Format (LDIF) tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "leaf" = callPackage @@ -151502,6 +159044,8 @@ self: { ]; description = "A simple portfolio generator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "leaky" = callPackage @@ -151520,6 +159064,7 @@ self: { ]; description = "Robust space leak, and its strictification"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lean" = callPackage @@ -151535,6 +159080,7 @@ self: { ]; description = "Bonds to Lean theorem prover"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lean-peano" = callPackage @@ -151650,6 +159196,8 @@ self: { libraryHaskellDepends = [ base time ]; testHaskellDepends = [ base tasty tasty-hunit time ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "leapseconds-announced" = callPackage @@ -151673,6 +159221,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Learning Algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "learn-physics" = callPackage @@ -151710,6 +159260,8 @@ self: { ]; description = "examples for learn-physics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "learning-hmm" = callPackage @@ -151744,6 +159296,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion deepseq ]; description = "LEB128 encoding logic for and in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "leb128-cereal" = callPackage @@ -151774,6 +159328,8 @@ self: { executableHaskellDepends = [ base containers ]; description = "Leetify text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "left4deadrl" = callPackage @@ -151808,6 +159364,7 @@ self: { ]; description = "Distributed, stateful, homogeneous microservice framework"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "legion-discovery" = callPackage @@ -151833,6 +159390,7 @@ self: { testHaskellDepends = [ base ]; description = "A discovery service based on Legion"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "legion-discovery-client" = callPackage @@ -151852,6 +159410,7 @@ self: { testHaskellDepends = [ base ]; description = "Client library for communicating with legion-discovery"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "legion-extra" = callPackage @@ -151873,6 +159432,7 @@ self: { testHaskellDepends = [ base ]; description = "Extra non-essential utilities for building legion applications"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "leksah" = callPackage @@ -151948,6 +159508,7 @@ self: { ]; description = "Metadata collection for leksah"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "lendingclub" = callPackage @@ -151964,6 +159525,8 @@ self: { ]; description = "Bindings for the LendingClub marketplace API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens" = callPackage @@ -152220,6 +159783,8 @@ self: { ]; description = "Lens interface for your filesystem; still a bit experimental"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-labels" = callPackage @@ -152231,6 +159796,8 @@ self: { libraryHaskellDepends = [ base ghc-prim profunctors tagged ]; description = "Integration of lenses with OverloadedLabels"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-misc" = callPackage @@ -152270,6 +159837,8 @@ self: { ]; description = "Alternate prelude that exports lens combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-process" = callPackage @@ -152287,6 +159856,8 @@ self: { ]; description = "Optics for system processes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-properties" = callPackage @@ -152359,6 +159930,8 @@ self: { ]; description = "simplified import of elementary lens-family combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-sop" = callPackage @@ -152383,6 +159956,8 @@ self: { libraryHaskellDepends = [ base bytestring lens text ]; description = "Isomorphisms and prisms for text <=> bytestring conversions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-th-rewrite" = callPackage @@ -152397,6 +159972,8 @@ self: { executableHaskellDepends = [ base ghc ghc-exactprint lens ]; description = "Rewrites Template Haskell splices using the API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-time" = callPackage @@ -152408,6 +159985,8 @@ self: { libraryHaskellDepends = [ base lens time ]; description = "lens for Data.Time"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-toml-parser" = callPackage @@ -152424,6 +160003,8 @@ self: { ]; description = "Lenses for toml-parser"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-tutorial" = callPackage @@ -152436,6 +160017,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Tutorial for the lens library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-typelevel" = callPackage @@ -152447,6 +160030,8 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Type-level lenses using singletons"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-utils" = callPackage @@ -152463,6 +160048,7 @@ self: { ]; description = "Collection of missing lens utilities"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "lens-xml" = callPackage @@ -152500,6 +160086,8 @@ self: { testHaskellDepends = [ base ]; description = "References which can be joined and on which lenses can be applied"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lentil" = callPackage @@ -152618,6 +160206,8 @@ self: { libraryHaskellDepends = [ base fmlist ]; description = "Non-Determinism Monad for Level-Wise Search"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "leveldb-haskell" = callPackage @@ -152708,6 +160298,7 @@ self: { benchmarkHaskellDepends = [ base gauge util ]; description = "See README for more info"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lexer-applicative" = callPackage @@ -152736,6 +160327,8 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "L-Fuzzy Set Theory implementation in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lgtk" = callPackage @@ -152763,6 +160356,7 @@ self: { ]; description = "Lens GUI Toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lha" = callPackage @@ -152774,6 +160368,7 @@ self: { libraryHaskellDepends = [ haskell2010 ]; description = "Data structures for the Les Houches Accord"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lhae" = callPackage @@ -152793,6 +160388,7 @@ self: { ]; description = "Simple spreadsheet program"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "lhc" = callPackage @@ -152806,6 +160402,8 @@ self: { enableSeparateDataOutput = true; description = "LHC Haskell Compiler"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lhe" = callPackage @@ -152817,6 +160415,7 @@ self: { libraryHaskellDepends = [ bytestring haskell2010 HaXml lha ]; description = "Parser and writer for Les-Houches event files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lhs2TeX-hl" = callPackage @@ -152835,6 +160434,8 @@ self: { ]; description = "Literate highlighter preprocessor for lhs2tex"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lhs2html" = callPackage @@ -152884,6 +160485,8 @@ self: { ]; description = "Tool for using pdflatex with .lhs files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libBF" = callPackage @@ -152915,6 +160518,8 @@ self: { ]; description = "A natural language generator (specifically, an FB-LTAG surface realiser)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libarchive" = callPackage @@ -152981,6 +160586,7 @@ self: { testHaskellDepends = [ base doctest doctest-prop lens ]; description = "Haskell bindings to libconfig"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libconfig;}; "libcspm" = callPackage @@ -153001,6 +160607,7 @@ self: { ]; description = "A library providing a parser, type checker and evaluator for CSPM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "libexpect" = callPackage @@ -153013,6 +160620,8 @@ self: { librarySystemDepends = [ expect tcl ]; description = "Library for interacting with console applications via pseudoterminals"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) expect; inherit (pkgs) tcl;}; "libffi" = callPackage @@ -153062,6 +160671,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion unix ]; description = "A Haskell binding for libfuse-3.x"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fuse3;}; "libgit" = callPackage @@ -153113,6 +160724,8 @@ self: { ]; description = "Backend for text editors to provide better Haskell editing support"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libinfluxdb" = callPackage @@ -153131,6 +160744,8 @@ self: { ]; description = "libinfluxdb"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libiserv_9_0_1" = callPackage @@ -153175,6 +160790,8 @@ self: { ]; description = "Jenkins API interface"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libjwt-typed" = callPackage @@ -153205,6 +160822,8 @@ self: { ]; description = "A Haskell implementation of JSON Web Token (JWT)"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "liblastfm" = callPackage @@ -153231,6 +160850,7 @@ self: { ]; description = "Lastfm API interface"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "liblawless" = callPackage @@ -153266,6 +160886,7 @@ self: { ]; description = "Prelude based on protolude for GHC 8 and beyond"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "liblinear-enumerator" = callPackage @@ -153279,6 +160900,7 @@ self: { ]; description = "liblinear iteratee"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "libltdl" = callPackage @@ -153292,6 +160914,8 @@ self: { libraryHaskellDepends = [ base ]; description = "FFI interface to libltdl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libmodbus" = callPackage @@ -153339,6 +160963,7 @@ self: { ]; description = "Prelude based on protolude for GHC 8 and beyond"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "libmpd" = callPackage @@ -153380,6 +161005,8 @@ self: { ]; description = "Bindings to the nix package manager"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libnotify" = callPackage @@ -153432,6 +161059,8 @@ self: { testHaskellDepends = [ base ]; description = "Bindings to liboath"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {liboath = null; oath = null;}; "liboleg" = callPackage @@ -153447,6 +161076,8 @@ self: { ]; description = "An evolving collection of Oleg Kiselyov's Haskell modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libpafe" = callPackage @@ -153460,6 +161091,8 @@ self: { testHaskellDepends = [ base bytestring iconv transformers ]; description = "Wrapper for libpafe"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {pafe = null;}; "libpq" = callPackage @@ -153472,6 +161105,8 @@ self: { librarySystemDepends = [ postgresql ]; description = "libpq binding for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) postgresql;}; "libraft" = callPackage @@ -153523,6 +161158,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "Raft consensus algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "librandomorg" = callPackage @@ -153534,6 +161170,8 @@ self: { libraryHaskellDepends = [ base bytestring curl ]; description = "Wrapper to Random.org API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "librato" = callPackage @@ -153554,6 +161192,7 @@ self: { ]; description = "Bindings to the Librato API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "libravatar" = callPackage @@ -153650,6 +161289,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "FFI bindings to libssh2 SSH2 client library (http://libssh2.org/)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libssh2;}; "libssh2-conduit" = callPackage @@ -153667,6 +161308,7 @@ self: { ]; description = "Conduit wrappers for libssh2 FFI bindings (see libssh2 package)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "libstackexchange" = callPackage @@ -153704,6 +161346,8 @@ self: { ]; description = "Haskell bindings for libsystemd-daemon"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {libsystemd-daemon = null; systemd-daemon = null;}; "libsystemd-journal" = callPackage @@ -153740,6 +161384,8 @@ self: { libraryPkgconfigDepends = [ taglib ]; description = "Binding to TagLib C library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) taglib;}; "libtelnet" = callPackage @@ -153806,6 +161452,8 @@ self: { libraryHaskellDepends = [ base bindings-DSL ]; description = "Bindings to libxls"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libxml" = callPackage @@ -153836,6 +161484,7 @@ self: { ]; description = "Enumerator-based API for libXML's SAX interface"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "libxml-sax" = callPackage @@ -153861,6 +161510,8 @@ self: { librarySystemDepends = [ xslt ]; description = "Binding to libxslt"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {xslt = null;}; "libyaml" = callPackage @@ -153923,6 +161574,8 @@ self: { executableHaskellDepends = [ base ]; description = "Lie Algebras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "life" = callPackage @@ -153963,6 +161616,8 @@ self: { ]; description = "Synchronize personal configs across multiple machines"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lifetimes" = callPackage @@ -153982,6 +161637,7 @@ self: { ]; description = "Flexible manual resource management"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "lift-generics" = callPackage @@ -154092,6 +161748,7 @@ self: { ]; description = "lifted IO operations from the base library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lifted-protolude" = callPackage @@ -154109,6 +161766,8 @@ self: { ]; description = "A sensible set of defaults for writing lifted custom Preludes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lifted-stm" = callPackage @@ -154158,6 +161817,8 @@ self: { ]; description = "A boulderdash-like game and solution validator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ligature" = callPackage @@ -154169,6 +161830,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Expand ligatures in unicode text"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ligd" = callPackage @@ -154215,6 +161878,7 @@ self: { ]; description = "Haskell client for lightning-viz REST API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lightstep-haskell" = callPackage @@ -154246,6 +161910,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "LightStep OpenTracing client library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "lighttpd-conf" = callPackage @@ -154262,6 +161927,7 @@ self: { libraryToolDepends = [ alex happy ]; description = "Lighttpd configuration file tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lighttpd-conf-qq" = callPackage @@ -154278,6 +161944,7 @@ self: { ]; description = "A QuasiQuoter for lighttpd configuration files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lilypond" = callPackage @@ -154294,6 +161961,8 @@ self: { ]; description = "Bindings to Lilypond"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "limp" = callPackage @@ -154327,6 +161996,8 @@ self: { ]; description = "bindings for integer linear programming solver Coin/CBC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lin-alg" = callPackage @@ -154349,6 +162020,8 @@ self: { libraryHaskellDepends = [ base hmatrix HUnit ]; description = "LINear Discriminant Analysis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linden" = callPackage @@ -154378,6 +162051,8 @@ self: { ]; description = "Zen gardening, based on l-systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lindenmayer" = callPackage @@ -154471,6 +162146,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "raster line drawing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "line-size" = callPackage @@ -154562,6 +162239,8 @@ self: { ]; description = "A linear algebra library with bindings to BLAS and LAPACK"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linear-base" = callPackage @@ -154588,6 +162267,8 @@ self: { ]; description = "Standard library for linear types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linear-circuit" = callPackage @@ -154609,6 +162290,7 @@ self: { ]; description = "Compute resistance of linear electrical circuits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "linear-code" = callPackage @@ -154634,6 +162316,8 @@ self: { ]; description = "A simple library for linear codes (coding theory, error correction)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linear-grammar" = callPackage @@ -154660,6 +162344,8 @@ self: { libraryHaskellDepends = [ base containers HUnit ]; description = "Finite maps for linear use"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linear-opengl" = callPackage @@ -154675,6 +162361,8 @@ self: { ]; description = "Isomorphisms between linear and OpenGL types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linear-socket" = callPackage @@ -154713,6 +162401,8 @@ self: { libraryHaskellDepends = [ base random ]; description = "A low-dimensional linear algebra library, operating on the Num typeclass"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linearEqSolver" = callPackage @@ -154746,6 +162436,7 @@ self: { ]; description = "Native, complete, matrix-free linear algebra"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "linearscan" = callPackage @@ -154759,6 +162450,8 @@ self: { ]; description = "Linear scan register allocator, formally verified in Coq"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linearscan-hoopl" = callPackage @@ -154779,6 +162472,7 @@ self: { ]; description = "Makes it easy to use the linearscan register allocator with Hoopl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "linebreak" = callPackage @@ -154821,6 +162515,8 @@ self: { libraryHaskellDepends = [ base containers mtl safe ]; description = "Lines of Action, 2-player strategy board game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lingo" = callPackage @@ -154886,6 +162582,7 @@ self: { ]; description = "linkchk is a network interface link ping monitor"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "linkcore" = callPackage @@ -154902,6 +162599,7 @@ self: { ]; description = "Combines multiple GHC Core modules into a single module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "linked-list-with-iterator" = callPackage @@ -154914,6 +162612,8 @@ self: { testHaskellDepends = [ base ]; description = "A pure linked list which is mutable through iterators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linkedhashmap" = callPackage @@ -154936,6 +162636,8 @@ self: { ]; description = "Persistent LinkedHashMap data structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linklater" = callPackage @@ -154958,6 +162660,8 @@ self: { ]; description = "A Haskell library for the Slack API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linnet" = callPackage @@ -155042,6 +162746,8 @@ self: { ]; description = "Bindings to the Linode API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linode-v4" = callPackage @@ -155058,6 +162764,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Haskell wrapper for the Linode v4 API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linux-blkid" = callPackage @@ -155074,6 +162782,8 @@ self: { libraryPkgconfigDepends = [ blkid ]; description = "Linux libblkid"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {blkid = null;}; "linux-capabilities" = callPackage @@ -155096,6 +162806,8 @@ self: { libraryHaskellDepends = [ base filepath ]; description = "Very basic interface to the Linux CGroup Virtual Filesystem"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linux-evdev" = callPackage @@ -155157,6 +162869,8 @@ self: { libraryPkgconfigDepends = [ libkmod ]; description = "Linux kernel modules support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {libkmod = null;}; "linux-mount" = callPackage @@ -155201,6 +162915,8 @@ self: { ]; description = "Read files generated by perf on Linux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "linux-ptrace" = callPackage @@ -155218,6 +162934,7 @@ self: { ]; description = "Wrapping of Linux' ptrace(2)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "linux-xattr" = callPackage @@ -155249,6 +162966,8 @@ self: { ]; description = "Implementation of the Enea LINX gateway protocol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lio" = callPackage @@ -155276,6 +162995,7 @@ self: { ]; description = "Labeled IO library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "lio-fs" = callPackage @@ -155318,6 +163038,8 @@ self: { ]; description = "LIO support for the Simple web framework"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lion" = callPackage @@ -155335,6 +163057,7 @@ self: { ]; description = "RISC-V Core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lipsum-gen" = callPackage @@ -155346,6 +163069,8 @@ self: { libraryHaskellDepends = [ base QuickCheck ]; description = "Generators for random sequences of English-like nonsense text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "liquid" = callPackage @@ -155370,6 +163095,8 @@ self: { benchmarkHaskellDepends = [ aeson attoparsec base criterion text ]; description = "Liquid template language library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "liquid-base" = callPackage @@ -155383,6 +163110,7 @@ self: { libraryHaskellDepends = [ base liquid-ghc-prim liquidhaskell ]; description = "Drop-in base replacement for LiquidHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquid-bytestring" = callPackage @@ -155398,6 +163126,7 @@ self: { libraryHaskellDepends = [ bytestring liquid-base liquidhaskell ]; description = "LiquidHaskell specs for the bytestring package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquid-containers" = callPackage @@ -155413,6 +163142,7 @@ self: { libraryHaskellDepends = [ containers liquid-base liquidhaskell ]; description = "LiquidHaskell specs for the containers package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquid-fixpoint" = callPackage @@ -155460,6 +163190,7 @@ self: { libraryHaskellDepends = [ ghc-prim liquidhaskell ]; description = "Drop-in ghc-prim replacement for LiquidHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquid-parallel" = callPackage @@ -155474,6 +163205,7 @@ self: { libraryHaskellDepends = [ liquid-base liquidhaskell parallel ]; description = "LiquidHaskell specs for the parallel package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquid-platform" = callPackage @@ -155493,6 +163225,7 @@ self: { ]; description = "A battery-included platform for LiquidHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquid-prelude" = callPackage @@ -155509,6 +163242,7 @@ self: { ]; description = "General utility modules for LiquidHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquid-vector" = callPackage @@ -155522,6 +163256,7 @@ self: { libraryHaskellDepends = [ liquid-base liquidhaskell vector ]; description = "LiquidHaskell specs for the vector package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "liquidhaskell" = callPackage @@ -155562,6 +163297,8 @@ self: { testSystemDepends = [ z3 ]; description = "Liquid Types for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) z3;}; "liquidhaskell-cabal" = callPackage @@ -155575,6 +163312,8 @@ self: { libraryHaskellDepends = [ base Cabal directory filepath ]; description = "Liquid Haskell integration for Cabal and Stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "liquidhaskell-cabal-demo" = callPackage @@ -155649,6 +163388,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "testing list fusion for success"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "list-grouping" = callPackage @@ -155671,6 +163412,8 @@ self: { libraryHaskellDepends = [ base ]; description = "List Multiplexing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "list-predicate" = callPackage @@ -155703,6 +163446,8 @@ self: { ]; description = "A simple list prompt UI for the terminal"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "list-remote-forwards" = callPackage @@ -155729,6 +163474,8 @@ self: { ]; description = "List all remote forwards for mail accounts stored in a SQL database"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "list-singleton" = callPackage @@ -155774,6 +163521,7 @@ self: { ]; description = "An \"attoparsec\" adapter for \"list-t\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "list-t-html-parser" = callPackage @@ -155797,6 +163545,7 @@ self: { ]; description = "Streaming HTML parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "list-t-http-client" = callPackage @@ -155812,6 +163561,8 @@ self: { ]; description = "A streaming HTTP client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "list-t-libcurl" = callPackage @@ -155847,6 +163598,8 @@ self: { ]; description = "A streaming text codec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "list-transformer" = callPackage @@ -155914,6 +163667,7 @@ self: { ]; description = "Witnesses for working with type-level lists"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "list-zip-def" = callPackage @@ -155925,6 +163679,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Provides zips with default values"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "list-zipper" = callPackage @@ -155947,6 +163703,8 @@ self: { ]; description = "A list zipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "listenbrainz-client" = callPackage @@ -155964,6 +163722,7 @@ self: { ]; description = "A client library to the ListenBrainz project"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "listlike-instances" = callPackage @@ -155975,6 +163734,8 @@ self: { libraryHaskellDepends = [ base bytestring ListLike text vector ]; description = "Extra instances of the ListLike class"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lists" = callPackage @@ -156043,6 +163804,8 @@ self: { ]; description = "Append only key-list database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lit" = callPackage @@ -156062,6 +163825,8 @@ self: { ]; description = "A simple tool for literate programming"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "literals" = callPackage @@ -156073,6 +163838,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Non-overloaded functions for concrete literals"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "little-logger" = callPackage @@ -156135,6 +163902,7 @@ self: { ]; description = "Live coding of MIDI music"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "liveplot" = callPackage @@ -156170,6 +163938,8 @@ self: { libraryHaskellDepends = [ base ]; librarySystemDepends = [ picosat ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) picosat;}; "llrbtree" = callPackage @@ -156201,6 +163971,8 @@ self: { ]; description = "An implementation of the LLSD data system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "llvm" = callPackage @@ -156217,6 +163989,7 @@ self: { ]; description = "Bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-analysis" = callPackage @@ -156244,6 +164017,7 @@ self: { ]; description = "A Haskell library for analyzing LLVM bitcode"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-base" = callPackage @@ -156255,6 +164029,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "FFI bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "llvm-base-types" = callPackage @@ -156275,6 +164051,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "The base types for a mostly pure Haskell LLVM analysis library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-base-util" = callPackage @@ -156286,6 +164063,7 @@ self: { libraryHaskellDepends = [ base llvm-base ]; description = "Utilities for bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-data-interop" = callPackage @@ -156306,6 +164084,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "A low-level data interoperability binding for LLVM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-dsl" = callPackage @@ -156323,6 +164102,7 @@ self: { ]; description = "Support for writing an EDSL with LLVM-JIT as target"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-extension" = callPackage @@ -156341,6 +164121,7 @@ self: { ]; description = "Processor specific intrinsics for the llvm interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-extra" = callPackage @@ -156366,6 +164147,7 @@ self: { doHaddock = false; description = "Utility functions for the llvm interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-ffi" = callPackage @@ -156380,6 +164162,8 @@ self: { librarySystemDepends = [ LLVM ]; description = "FFI bindings to the LLVM compiler toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {LLVM = null;}; "llvm-ffi-tools" = callPackage @@ -156397,6 +164181,8 @@ self: { ]; description = "Tools for maintaining the llvm-ffi package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "llvm-general" = callPackage @@ -156423,6 +164209,7 @@ self: { ]; description = "General purpose LLVM bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {llvm-config = null;}; "llvm-general-pure" = callPackage @@ -156443,6 +164230,8 @@ self: { ]; description = "Pure Haskell LLVM functionality (no FFI)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "llvm-general-quote" = callPackage @@ -156466,6 +164255,7 @@ self: { ]; description = "QuasiQuoting llvm code for llvm-general"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-hs" = callPackage @@ -156547,6 +164337,8 @@ self: { ]; description = "Bindings to the LLVM compiler toolkit with some custom extensions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "llvm-pkg-config" = callPackage @@ -156565,6 +164357,8 @@ self: { ]; description = "Generate Pkg-Config configuration file for LLVM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "llvm-pretty" = callPackage @@ -156581,6 +164375,8 @@ self: { ]; description = "A pretty printing library inspired by the llvm binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "llvm-pretty-bc-parser" = callPackage @@ -156607,6 +164403,7 @@ self: { ]; description = "LLVM bitcode parsing library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-tf" = callPackage @@ -156628,6 +164425,7 @@ self: { doHaddock = false; description = "Bindings to the LLVM compiler toolkit using type families"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "llvm-tools" = callPackage @@ -156655,6 +164453,7 @@ self: { ]; description = "Useful tools built on llvm-analysis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lmdb" = callPackage @@ -156724,6 +164523,8 @@ self: { ]; description = "LMonad is an Information Flow Control (IFC) framework for Haskell applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lmonad-yesod" = callPackage @@ -156744,6 +164545,7 @@ self: { ]; description = "LMonad for Yesod integrates LMonad's IFC with Yesod web applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "load-balancing" = callPackage @@ -156755,6 +164557,8 @@ self: { libraryHaskellDepends = [ base containers hslogger PSQueue stm ]; description = "Client-side load balancing utilities"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "load-env" = callPackage @@ -156787,6 +164591,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "A cross platform library for loading bundled fonts into your application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "loadavg" = callPackage @@ -156832,6 +164638,8 @@ self: { libraryHaskellDepends = [ base network ]; description = "Functions to get local interface address"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "local-search" = callPackage @@ -156848,6 +164656,7 @@ self: { ]; description = "Generalised local search within Haskell, for applications in combinatorial optimisation"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "localization" = callPackage @@ -156877,6 +164686,7 @@ self: { ]; description = "GNU Gettext-based messages localization library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "located" = callPackage @@ -156888,6 +164698,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Source location helpers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "located-base" = callPackage @@ -156912,6 +164724,8 @@ self: { libraryHaskellDepends = [ base monad-logger text ]; description = "Location-aware logging without Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "locators" = callPackage @@ -156944,6 +164758,8 @@ self: { executableHaskellDepends = [ base ]; description = "Support for precise error locations in source files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "loch-th" = callPackage @@ -156996,6 +164812,7 @@ self: { ]; description = "Very simple poll lock"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lockfree-queue" = callPackage @@ -157053,6 +164870,7 @@ self: { ]; description = "Structured logging solution with multiple backends"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "log-base" = callPackage @@ -157167,6 +164985,7 @@ self: { ]; description = "Structured logging solution (PostgreSQL back end)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "log-utils" = callPackage @@ -157189,6 +165008,7 @@ self: { ]; description = "Utils for working with logs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "log-warper" = callPackage @@ -157224,6 +165044,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Flexible, configurable, monadic and pretty logging"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "log2json" = callPackage @@ -157237,6 +165059,8 @@ self: { executableHaskellDepends = [ base containers json parsec ]; description = "Turn log file records into JSON"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "log4hs" = callPackage @@ -157267,6 +165091,8 @@ self: { ]; description = "A python logging style log library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "logentries" = callPackage @@ -157286,6 +165112,8 @@ self: { ]; description = "Request logger middleware for Logentries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "logfloat" = callPackage @@ -157314,6 +165142,8 @@ self: { ]; description = "Fast & extensible logging framework"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "logger-thread" = callPackage @@ -157392,6 +165222,7 @@ self: { executableHaskellDepends = [ base ]; description = "Supplemental packages for `logging-effect`"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "logging-effect-extra-file" = callPackage @@ -157410,6 +165241,8 @@ self: { executableHaskellDepends = [ base logging-effect prettyprinter ]; description = "TH splices to augment log messages with file info"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "logging-effect-extra-handler" = callPackage @@ -157428,6 +165261,8 @@ self: { executableHaskellDepends = [ base logging-effect prettyprinter ]; description = "Handy logging handler combinators"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "logging-facade" = callPackage @@ -157521,6 +165356,7 @@ self: { ]; description = "Framework for propositional and first order logic, theorem proving"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "logicst" = callPackage @@ -157532,6 +165368,8 @@ self: { libraryHaskellDepends = [ base logict transformers ]; description = "Backtracking mutable references in the ST and IO monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "logict" = callPackage @@ -157557,6 +165395,8 @@ self: { libraryHaskellDepends = [ base logict mtl transformers ]; description = "Library for logic programming based on haskell package logict"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "loglevel" = callPackage @@ -157581,6 +165421,8 @@ self: { testHaskellDepends = [ base hspec time ]; description = "Parse Heroku application/logplex documents"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "logsink" = callPackage @@ -157633,6 +165475,7 @@ self: { executableHaskellDepends = [ haskell98 ]; description = "Useful utilities for the Lojban language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lojbanParser" = callPackage @@ -157647,6 +165490,8 @@ self: { executableHaskellDepends = [ base ]; description = "lojban parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lojbanXiragan" = callPackage @@ -157661,6 +165506,8 @@ self: { executableHaskellDepends = [ base ]; description = "lojban to xiragan"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lojysamban" = callPackage @@ -157674,6 +165521,7 @@ self: { executableHaskellDepends = [ base lojbanParser yjtools ]; description = "Prolog with lojban"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lol" = callPackage @@ -157702,6 +165550,8 @@ self: { testHaskellDepends = [ base test-framework ]; description = "A library for lattice cryptography"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lol-apps" = callPackage @@ -157722,6 +165572,7 @@ self: { ]; description = "Lattice-based cryptographic applications using ."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "lol-benches" = callPackage @@ -157738,6 +165589,7 @@ self: { ]; description = "A library for benchmarking ."; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "lol-calculus" = callPackage @@ -157759,6 +165611,8 @@ self: { ]; description = "Calculus for LOL (λω language)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lol-cpp" = callPackage @@ -157778,6 +165632,7 @@ self: { benchmarkHaskellDepends = [ base DRBG lol lol-apps MonadRandom ]; description = "A fast C++ backend for ."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "lol-repa" = callPackage @@ -157797,6 +165652,7 @@ self: { benchmarkHaskellDepends = [ base DRBG lol lol-benches ]; description = "A repa backend for ."; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "lol-tests" = callPackage @@ -157816,6 +165672,7 @@ self: { testHaskellDepends = [ base lol test-framework ]; description = "A library for testing ."; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "lol-typing" = callPackage @@ -157840,6 +165697,7 @@ self: { ]; description = "Type inferencer for LOL (λω language)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "loli" = callPackage @@ -157857,6 +165715,7 @@ self: { ]; description = "A minimum web dev DSL in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "long-double" = callPackage @@ -157879,6 +165738,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Dependently-typed linked list implementation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "longshot" = callPackage @@ -157910,6 +165771,7 @@ self: { ]; description = "Fast Brute-force search using parallelism"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lookup-tables" = callPackage @@ -157924,6 +165786,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Statically generate lookup tables using Template Haskell"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "loop" = callPackage @@ -157951,6 +165815,7 @@ self: { libraryHaskellDepends = [ base effin ]; description = "control-monad-loop port for effin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "loop-while" = callPackage @@ -157962,6 +165827,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A monad transformer supporting various styles of while loop"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "loopbreaker" = callPackage @@ -157979,6 +165846,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "inline self-recursive definitions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "looper" = callPackage @@ -157996,6 +165865,8 @@ self: { aeson base hspec optparse-applicative text time unliftio ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "loops" = callPackage @@ -158013,6 +165884,8 @@ self: { benchmarkHaskellDepends = [ base criterion transformers vector ]; description = "Fast imperative-style loops"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "loopy" = callPackage @@ -158031,6 +165904,8 @@ self: { ]; description = "Find all biological feedback loops within an ecosystem graph"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lord" = callPackage @@ -158071,6 +165946,8 @@ self: { ]; description = "A command line interface to online radios"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lorem" = callPackage @@ -158085,6 +165962,8 @@ self: { executableHaskellDepends = [ base ]; description = "Library for generating filler text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lorentz" = callPackage @@ -158107,6 +165986,7 @@ self: { ]; description = "EDSL for the Michelson Language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "loris" = callPackage @@ -158120,6 +166000,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "interface to Loris API"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {loris = null;}; "loshadka" = callPackage @@ -158138,6 +166020,8 @@ self: { ]; description = "Minecraft 1.7 server proxy that answers to queries when the server is offline"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lostcities" = callPackage @@ -158155,6 +166039,7 @@ self: { ]; description = "An implementation of an adictive two-player card game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "louis" = callPackage @@ -158188,6 +166073,7 @@ self: { executableHaskellDepends = [ base optparse-generic shakers ]; description = "Amazon Simple Workflow Service Wrapper for Work Pools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lowgl" = callPackage @@ -158199,6 +166085,8 @@ self: { libraryHaskellDepends = [ base gl linear vector ]; description = "Basic gl wrapper and reference"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lowlin" = callPackage @@ -158248,6 +166136,8 @@ self: { ]; description = "SVG Backend for lp-diagrams"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lrucache" = callPackage @@ -158308,6 +166198,7 @@ self: { ]; description = "List USB devices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lscabal" = callPackage @@ -158325,6 +166216,8 @@ self: { ]; description = "List exported modules from a set of .cabal files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lsfrom" = callPackage @@ -158343,6 +166236,8 @@ self: { testHaskellDepends = [ base directory filepath simple-cmd ]; description = "List dir files starting from a specific name"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lsp" = callPackage @@ -158486,6 +166381,7 @@ self: { ]; description = "Paint an L-System Grammar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ltext" = callPackage @@ -158517,6 +166413,8 @@ self: { ]; description = "Parameterized file evaluator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lti13" = callPackage @@ -158537,6 +166435,7 @@ self: { ]; description = "Core functionality for LTI 1.3."; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "ltiv1p1" = callPackage @@ -158576,6 +166475,8 @@ self: { libraryPkgconfigDepends = [ gtk3 ]; description = "Leksah tool kit"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtk3;}; "ltl" = callPackage @@ -158617,6 +166518,8 @@ self: { ]; description = "Lua bytecode parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lua-bytecode" = callPackage @@ -158649,6 +166552,7 @@ self: { ]; description = "Library functions for reading and writing Lua chunks"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "luautils" = callPackage @@ -158670,6 +166574,8 @@ self: { ]; description = "Helpers for Haskell integration with Lua"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lub" = callPackage @@ -158726,6 +166632,7 @@ self: { libraryHaskellDepends = [ base colonnade lucid text ]; description = "Helper functions for using lucid with colonnade"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lucid-extras" = callPackage @@ -158792,6 +166699,7 @@ self: { ]; description = "Server side feed aggregator/reader"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "luhn" = callPackage @@ -158803,6 +166711,7 @@ self: { libraryHaskellDepends = [ base digits QuickCheck ]; description = "An implementation of Luhn's check digit algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lui" = callPackage @@ -158818,6 +166727,7 @@ self: { ]; description = "Purely FunctionaL User Interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "luis-client" = callPackage @@ -158832,6 +166742,8 @@ self: { ]; description = "An unofficial client for the LUIS NLP service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "luka" = callPackage @@ -158845,6 +166757,8 @@ self: { librarySystemDepends = [ objc ]; description = "Simple ObjectiveC runtime binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {objc = null;}; "lukko" = callPackage @@ -158901,6 +166815,8 @@ self: { ]; description = "Type-safe, type-level and stateless graphics framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "luminance-samples" = callPackage @@ -158919,6 +166835,7 @@ self: { ]; description = "Luminance samples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lushtags" = callPackage @@ -158932,6 +166849,8 @@ self: { executableHaskellDepends = [ base haskell-src-exts text vector ]; description = "Create ctags compatible tags files for Haskell programs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "luthor" = callPackage @@ -158944,6 +166863,8 @@ self: { testHaskellDepends = [ base mtl parsec ]; description = "Tools for lexing and utilizing lexemes that integrate with Parsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lvar" = callPackage @@ -158982,6 +166903,7 @@ self: { ]; description = "Parallel scheduler, LVar data structures, and infrastructure to build more"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lvmlib" = callPackage @@ -159004,6 +166926,8 @@ self: { ]; description = "The Lazy Virtual Machine (LVM)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lvmrun" = callPackage @@ -159027,6 +166951,8 @@ self: { libraryHaskellDepends = [ base bindings-lxc mtl transformers ]; description = "High level Haskell bindings to LXC (Linux containers)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lxd-client" = callPackage @@ -159056,6 +166982,8 @@ self: { ]; description = "LXD client written in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lxd-client-config" = callPackage @@ -159093,6 +167021,8 @@ self: { ]; description = "A Lilypond-compiling music box"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lz4" = callPackage @@ -159149,6 +167079,7 @@ self: { ]; description = "LZ4 compression for conduits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lz4-frame-conduit" = callPackage @@ -159177,6 +167108,8 @@ self: { ]; description = "Conduit implementing the official LZ4 frame streaming format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lz4-hs" = callPackage @@ -159206,6 +167139,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Lzip compression / Lzlib bindings"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lzlib" = callPackage @@ -159298,6 +167233,7 @@ self: { ]; description = "Enumerator interface for lzma/xz compression"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) xz;}; "lzma-static" = callPackage @@ -159334,6 +167270,8 @@ self: { ]; description = "IO-Streams interface for lzma/xz compression"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lzo" = callPackage @@ -159349,6 +167287,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "minilzo bundled for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mDNSResponder-client" = callPackage @@ -159381,6 +167321,8 @@ self: { ]; description = "Monadic Abstracting Abstract Machines (MAAM) built on Galois Transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mac" = callPackage @@ -159392,6 +167334,8 @@ self: { libraryHaskellDepends = [ base network transformers ]; description = "Static Mandatory Access Control in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "macaroon-shop" = callPackage @@ -159412,6 +167356,8 @@ self: { ]; description = "A toolkit for working with macaroons"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "macbeth-lib" = callPackage @@ -159437,6 +167383,7 @@ self: { testHaskellDepends = [ attoparsec base bytestring hspec ]; description = "Macbeth - A beautiful and minimalistic FICS client"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "maccatcher" = callPackage @@ -159480,6 +167427,8 @@ self: { ]; description = "Arrow based stream transducers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "machines" = callPackage @@ -159523,6 +167472,7 @@ self: { ]; description = "Machine transducers for Amazonka calls"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "machines-attoparsec" = callPackage @@ -159565,6 +167515,8 @@ self: { libraryHaskellDepends = [ base bytestring machines ]; description = "ByteString support for machines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "machines-directory" = callPackage @@ -159580,6 +167532,8 @@ self: { ]; description = "Directory (system) utilities for the machines library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "machines-encoding" = callPackage @@ -159591,6 +167545,8 @@ self: { libraryHaskellDepends = [ base bytestring machines text ]; description = "Transcode encodings with machines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "machines-io" = callPackage @@ -159634,6 +167590,8 @@ self: { ]; description = "Decompression support for machines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "macho" = callPackage @@ -159646,6 +167604,8 @@ self: { libraryHaskellDepends = [ base binary bytestring ]; description = "Parser for Mach-O object format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mackerel-client" = callPackage @@ -159693,6 +167653,8 @@ self: { ]; description = "Control screen and keyboard backlights on MACs under Linux"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "macos-corelibs" = callPackage @@ -159708,6 +167670,8 @@ self: { ]; description = "Haskell bindings to C-based Mac OS SDK frameworks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "macosx-make-standalone" = callPackage @@ -159727,6 +167691,7 @@ self: { ]; description = "Make a macosx app standalone deployable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "macrm" = callPackage @@ -159751,6 +167716,8 @@ self: { ]; description = "Alternative rm command for macOS that remove files/dirs to the system trash"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mad-props" = callPackage @@ -159803,6 +167770,8 @@ self: { benchmarkHaskellDepends = [ base criterion megaparsec text ]; description = "Randomized templating language DSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mage" = callPackage @@ -159818,6 +167787,8 @@ self: { executableSystemDepends = [ ncurses ]; description = "Rogue-like"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ncurses;}; "magic" = callPackage @@ -159841,6 +167812,8 @@ self: { libraryHaskellDepends = [ base ghc ghc-tcplugins-extra syb ]; description = "Write plugins for magic type families with ease"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "magic-wormhole" = callPackage @@ -159871,6 +167844,7 @@ self: { ]; description = "Interact with Magic Wormhole"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "magicbane" = callPackage @@ -159901,6 +167875,7 @@ self: { ]; description = "A web framework that integrates Servant, RIO, EKG, fast-logger, wai-cli…"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "magico" = callPackage @@ -159918,6 +167893,7 @@ self: { ]; description = "Compute solutions for Magico puzzle"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "magma" = callPackage @@ -159931,6 +167907,8 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "magma is an algebraic structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "magmas" = callPackage @@ -159962,6 +167940,7 @@ self: { ]; description = "ImageBoards to XMPP gate"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "maid" = callPackage @@ -159983,6 +167962,7 @@ self: { ]; description = "A simple static web server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mail-pool" = callPackage @@ -160005,6 +167985,7 @@ self: { ]; description = "Preconfigured email connection pool on top of smtp"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "mail-reports" = callPackage @@ -160062,6 +168043,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Bindings for the MailChimp API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mailchimp-subscribe" = callPackage @@ -160080,6 +168063,8 @@ self: { ]; description = "MailChimp subscription request handler"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mailgun" = callPackage @@ -160099,6 +168084,7 @@ self: { ]; description = "API binding for Mailgun"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "main-tester" = callPackage @@ -160148,6 +168134,7 @@ self: { ]; description = "Majordomo protocol for ZeroMQ"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "majority" = callPackage @@ -160159,6 +168146,7 @@ self: { libraryHaskellDepends = [ haskell2010 ]; description = "Boyer-Moore Majority Vote Algorithm"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "make-hard-links" = callPackage @@ -160176,6 +168164,8 @@ self: { ]; description = "Change duplicated files into hard-links"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "make-monofoldable-foldable" = callPackage @@ -160187,6 +168177,8 @@ self: { libraryHaskellDepends = [ base mono-traversable ]; description = "Make a MonoFoldable type into an ordinary Foldable type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "make-package" = callPackage @@ -160207,6 +168199,8 @@ self: { ]; description = "Make a cabalized package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "makedo" = callPackage @@ -160218,6 +168212,8 @@ self: { libraryHaskellDepends = [ base directory filepath HSH process ]; description = "Helper for writing redo scripts in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "makefile" = callPackage @@ -160235,6 +168231,8 @@ self: { ]; description = "Simple Makefile parser and generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mallard" = callPackage @@ -160262,6 +168260,8 @@ self: { ]; description = "Database migration and testing as a library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mameya" = callPackage @@ -160308,6 +168308,7 @@ self: { ]; description = "The Haskell/Gtk+ Integrated Live Environment"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-all" = callPackage @@ -160354,6 +168355,7 @@ self: { ]; description = "Multithread interactive input/search framework for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-browser" = callPackage @@ -160397,6 +168399,7 @@ self: { ]; description = "The core of Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-curl" = callPackage @@ -160419,6 +168422,7 @@ self: { ]; description = "Download Manager extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-editor" = callPackage @@ -160439,6 +168443,7 @@ self: { ]; description = "Editor extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-filemanager" = callPackage @@ -160459,6 +168464,7 @@ self: { ]; description = "File manager extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-imageviewer" = callPackage @@ -160479,6 +168485,7 @@ self: { ]; description = "Image viewer extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-ircclient" = callPackage @@ -160503,6 +168510,7 @@ self: { ]; description = "IRC client extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-mplayer" = callPackage @@ -160524,6 +168532,7 @@ self: { ]; description = "Mplayer client extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-pdfviewer" = callPackage @@ -160544,6 +168553,7 @@ self: { ]; description = "PDF viewer extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-processmanager" = callPackage @@ -160563,6 +168573,7 @@ self: { ]; description = "Process manager extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-reader" = callPackage @@ -160603,6 +168614,7 @@ self: { ]; description = "Template code to create Manatee application"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-terminal" = callPackage @@ -160622,6 +168634,7 @@ self: { ]; description = "Terminal Emulator extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-welcome" = callPackage @@ -160641,6 +168654,7 @@ self: { ]; description = "Welcome module to help user play Manatee quickly"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "mancala" = callPackage @@ -160678,6 +168692,8 @@ self: { ]; description = "Library for interfacing with the Mandrill JSON API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mandulia" = callPackage @@ -160696,6 +168712,8 @@ self: { ]; description = "A zooming visualisation of the Mandelbrot Set as many Julia Sets"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mangopay" = callPackage @@ -160734,6 +168752,8 @@ self: { ]; description = "Bindings to the MangoPay API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mangrove" = callPackage @@ -160771,6 +168791,7 @@ self: { ]; description = "Sampling random points on general manifolds"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manifolds" = callPackage @@ -160800,6 +168821,7 @@ self: { ]; description = "Coordinate-free hypersurfaces"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manifolds-core" = callPackage @@ -160841,6 +168863,8 @@ self: { executableHaskellDepends = [ base bytestring cassava containers ]; description = "Extensions to Data.Map"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "map-reduce-folds" = callPackage @@ -160906,6 +168930,8 @@ self: { ]; description = "Efficient, polymorphic Map Algebra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mappy" = callPackage @@ -160928,6 +168954,8 @@ self: { testHaskellDepends = [ base containers hspec parsec QuickCheck ]; description = "A functional programming language focused around maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mapquest-api" = callPackage @@ -160987,6 +169015,7 @@ self: { ]; description = "A study of marionetta movements"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "markdown" = callPackage @@ -161032,6 +169061,8 @@ self: { ]; description = "Convert Markdown to HTML, with XSS protection"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "markdown-pap" = callPackage @@ -161043,6 +169074,7 @@ self: { libraryHaskellDepends = [ base monads-tf papillon ]; description = "markdown parser with papillon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "markdown-unlit" = callPackage @@ -161082,6 +169114,7 @@ self: { ]; description = "markdown to svg converter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "marked-pretty" = callPackage @@ -161094,6 +169127,8 @@ self: { testHaskellDepends = [ base ]; description = "Pretty-printing library, with scoping, based on pretty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "markov" = callPackage @@ -161149,6 +169184,7 @@ self: { testHaskellDepends = [ assertions base bifunctors memoize random ]; description = "Hidden Markov processes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "markov-realization" = callPackage @@ -161179,6 +169215,7 @@ self: { ]; description = "Abstraction for HTML-embedded content"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "markup-preview" = callPackage @@ -161227,6 +169264,7 @@ self: { ]; description = "Upload packages to Marmalade"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "marquise" = callPackage @@ -161261,6 +169299,7 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Client library for Vaultaire"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mars" = callPackage @@ -161276,6 +169315,8 @@ self: { ]; description = "Generates mountainous terrain using a random walk algorithm"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "marshal-contt" = callPackage @@ -161325,6 +169366,7 @@ self: { testHaskellDepends = [ base hspec ]; description = "A framework for modular, portable chat bots"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "marvin-interpolate" = callPackage @@ -161341,6 +169383,8 @@ self: { testHaskellDepends = [ base hspec text ]; description = "Compile time string interpolation a la Scala and CoffeeScript"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "marxup" = callPackage @@ -161386,6 +169430,7 @@ self: { ]; description = "@minamiyama1994_bot on haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "mason" = callPackage @@ -161464,6 +169509,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Compatibility of 'massiv' with 'persist'"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "massiv-scheduler" = callPackage @@ -161501,6 +169548,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Compatibility of 'massiv' with 'serialise'"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "massiv-test" = callPackage @@ -161547,6 +169596,7 @@ self: { ]; description = "The project management tool for hackers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "mastermind" = callPackage @@ -161621,6 +169671,7 @@ self: { librarySystemDepends = [ pcre ]; description = "Text matchers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) pcre;}; "math-extras" = callPackage @@ -161673,6 +169724,8 @@ self: { testHaskellDepends = [ array base containers hspec random ]; description = "Library containing graph data structures and graph algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "math-interpolate" = callPackage @@ -161684,6 +169737,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Class for interpolation of values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "math-metric" = callPackage @@ -161695,6 +169750,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Typeclass for metric spaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "math-programming" = callPackage @@ -161713,6 +169770,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "A library for formulating and solving math programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "math-programming-glpk" = callPackage @@ -161735,6 +169794,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "A GLPK backend to the math-programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) glpk;}; "math-programming-tests" = callPackage @@ -161750,6 +169810,7 @@ self: { ]; description = "Utility functions for testing implementations of the math-programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mathblog" = callPackage @@ -161776,6 +169837,7 @@ self: { ]; description = "A program for creating and managing a static weblog with LaTeX math and diagrams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mathexpr" = callPackage @@ -161806,6 +169868,8 @@ self: { ]; description = "Dependently typed tensorflow modeler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mathgenealogy" = callPackage @@ -161864,6 +169928,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "Write Mathematica packages in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "matlab" = callPackage @@ -161962,6 +170027,8 @@ self: { ]; description = "Read and Display Jones-Faithful notation for spacegroup and planegroup"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "matrix-lens" = callPackage @@ -161991,6 +170058,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Read and write NIST Matrix Market files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "matrix-market-attoparsec" = callPackage @@ -162042,6 +170111,8 @@ self: { ]; description = "Haskell matrix library with interface to C++ linear algebra libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "matrix-static" = callPackage @@ -162092,6 +170163,7 @@ self: { ]; description = "ncurses XMPP client"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "matterhorn" = callPackage @@ -162193,6 +170265,8 @@ self: { ]; description = "An interface to the Maude rewriting system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "maxent" = callPackage @@ -162214,6 +170288,7 @@ self: { ]; description = "Compute Maximum Entropy Distributions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "maxent-learner-hw" = callPackage @@ -162237,6 +170312,8 @@ self: { ]; description = "Hayes and Wilson's maxent learning algorithm for phonotactic grammars"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "maxent-learner-hw-gui" = callPackage @@ -162258,6 +170335,7 @@ self: { ]; description = "GUI for maxent-learner-hw"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "maximal-cliques" = callPackage @@ -162290,6 +170368,7 @@ self: { ]; description = "Maximal sharing of terms in the lambda calculus with letrec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "maybe-justify" = callPackage @@ -162320,6 +170399,8 @@ self: { ]; description = "Automated benchmarking tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mbox" = callPackage @@ -162351,6 +170432,8 @@ self: { ]; description = "A collection of tools to process mbox files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mbox-utility" = callPackage @@ -162412,6 +170495,8 @@ self: { ]; description = "download bugs mailboxes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mcaeson" = callPackage @@ -162453,6 +170538,8 @@ self: { ]; description = "Bindings to mcl, a generic and fast pairing-based cryptography library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gmpxx; mcl = null; inherit (pkgs) openssl;}; "mcm" = callPackage @@ -162472,6 +170559,8 @@ self: { ]; description = "Machine Configuration Manager"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mcmaster-gloss-examples" = callPackage @@ -162484,6 +170573,8 @@ self: { isExecutable = true; executableHaskellDepends = [ base gloss ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mcmc" = callPackage @@ -162511,6 +170602,7 @@ self: { ]; description = "Sample from a posterior using Markov chain Monte Carlo"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; }) {}; "mcmc-samplers" = callPackage @@ -162526,6 +170618,7 @@ self: { ]; description = "Combinators for MCMC sampling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mcmc-synthesis" = callPackage @@ -162537,6 +170630,8 @@ self: { libraryHaskellDepends = [ base MonadRandom ]; description = "MCMC applied to probabilistic program synthesis"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mcmc-types" = callPackage @@ -162564,6 +170659,8 @@ self: { executableHaskellDepends = [ base transformers ]; description = "Connect to MineCraft running on a Raspberry PI"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mdapi" = callPackage @@ -162582,6 +170679,8 @@ self: { ]; description = "Haskell interface to Fedora's mdapi"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mdcat" = callPackage @@ -162601,6 +170700,8 @@ self: { ]; description = "Markdown viewer in your terminal"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mdo" = callPackage @@ -162630,6 +170731,8 @@ self: { testHaskellDepends = [ base HTF HUnit QuickCheck vector ]; description = "Tools for solving Markov Decision Processes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mealstrom" = callPackage @@ -162652,6 +170755,8 @@ self: { ]; description = "Manipulate FSMs and store them in PostgreSQL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mealy" = callPackage @@ -162672,6 +170777,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "means" = callPackage @@ -162695,6 +170801,8 @@ self: { librarySystemDepends = [ mecab ]; description = "A Haskell binding to MeCab"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) mecab;}; "mech" = callPackage @@ -162706,6 +170814,8 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mecha" = callPackage @@ -162730,6 +170840,8 @@ self: { libraryHaskellDepends = [ base machines ]; description = "mecha are the most complex composite machines known to humanity, lets build them well!"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "med-module" = callPackage @@ -162804,6 +170916,8 @@ self: { ]; description = "Multimedia streaming on top of Conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mediabus-fdk-aac" = callPackage @@ -162831,6 +170945,7 @@ self: { ]; description = "Mediabus plugin for the Frauenhofer ISO-14496-3 AAC FDK"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {fdk-aac = null;}; "mediabus-rtp" = callPackage @@ -162868,6 +170983,7 @@ self: { ]; description = "Receive and Send RTP Packets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "median-stream" = callPackage @@ -162898,6 +171014,8 @@ self: { ]; description = "Interfacing with the MediaWiki API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mediawiki2latex" = callPackage @@ -162941,6 +171059,8 @@ self: { ]; description = "Haskell SDK for communicating with the Medium API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "meep" = callPackage @@ -162979,6 +171099,8 @@ self: { ]; description = "Handles uploading to Hackage from mega repos"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "megalisp" = callPackage @@ -162990,6 +171112,8 @@ self: { libraryHaskellDepends = [ base megaparsec mtl text ]; description = "lisp parser using mega-parsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "megaparsec" = callPackage @@ -163071,6 +171195,8 @@ self: { ]; description = "Control physical access devices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mellon-gpio" = callPackage @@ -163082,6 +171208,7 @@ self: { libraryHaskellDepends = [ base hpio mellon-core protolude ]; description = "GPIO support for mellon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mellon-web" = callPackage @@ -163123,6 +171250,7 @@ self: { ]; description = "A REST web service for Mellon controllers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "melody" = callPackage @@ -163144,6 +171272,8 @@ self: { ]; description = "A functional scripting language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "membership" = callPackage @@ -163216,6 +171346,7 @@ self: { ]; description = "Conduit library for memcache procotol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "memcache-haskell" = callPackage @@ -163238,6 +171369,8 @@ self: { ]; description = "Memcache procotol library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "memcached" = callPackage @@ -163272,6 +171405,8 @@ self: { ]; description = "memcached client using binary protocol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "memdb" = callPackage @@ -163337,6 +171472,8 @@ self: { ]; description = "Memis Efficient Manual Image Sorting"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "memo-ptr" = callPackage @@ -163348,6 +171485,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Pointer equality memoization"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "memo-sqlite" = callPackage @@ -163375,6 +171514,8 @@ self: { testHaskellDepends = [ base hspec time time-units ]; description = "Utilities for memoizing functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "memoize" = callPackage @@ -163448,6 +171589,8 @@ self: { ]; description = "basic memory pool outside of haskell heap/GC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "memscript" = callPackage @@ -163489,6 +171632,8 @@ self: { ]; description = "Haskell binding for Menoh DNN inference library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {menoh = null;}; "menshen" = callPackage @@ -163507,6 +171652,8 @@ self: { ]; description = "Data Validation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mercury-api" = callPackage @@ -163591,6 +171738,7 @@ self: { ]; description = "Support for using mergeful from persistent-based databases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "mergeless" = callPackage @@ -163629,6 +171777,7 @@ self: { ]; description = "Support for using mergeless from persistent-based databases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "merkle-log" = callPackage @@ -163680,6 +171829,7 @@ self: { ]; description = "A modified Merkle Patricia DB"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "merkle-tree" = callPackage @@ -163699,6 +171849,8 @@ self: { ]; description = "An implementation of a Merkle tree and merkle tree proofs of inclusion"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mersenne-random" = callPackage @@ -163762,6 +171914,8 @@ self: { ]; description = "Message Pack RPC over TCP"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "messente" = callPackage @@ -163775,6 +171929,8 @@ self: { ]; description = "Messente SMS Gateway"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "meta-misc" = callPackage @@ -163786,6 +171942,8 @@ self: { libraryHaskellDepends = [ base loch-th template-haskell ]; description = "Utility library providing miscellaneous meta-programming utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "meta-par" = callPackage @@ -163802,6 +171960,8 @@ self: { ]; description = "Provides the monad-par interface, but based on modular scheduler \"mix-ins\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "meta-par-accelerate" = callPackage @@ -163819,6 +171979,7 @@ self: { ]; description = "Support for integrated Accelerate computations within Meta-par"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "metadata" = callPackage @@ -163830,6 +171991,8 @@ self: { libraryHaskellDepends = [ base text time ]; description = "metadata library for semantic web"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "metaheuristics" = callPackage @@ -163841,6 +172004,8 @@ self: { libraryHaskellDepends = [ arrows base random Stream ]; description = "Generalised local search within Haskell, for applications in combinatorial optimisation"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "metamorphic" = callPackage @@ -163864,6 +172029,7 @@ self: { libraryHaskellDepends = [ base Cabal filepath ghc haskell98 ]; description = "a tiny ghc api wrapper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "metar" = callPackage @@ -163889,6 +172055,7 @@ self: { ]; description = "Australian METAR"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "metar-http" = callPackage @@ -163913,6 +172080,7 @@ self: { ]; description = "HTTP for METAR"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "method" = callPackage @@ -163951,6 +172119,8 @@ self: { ]; description = "Metric spaces"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "metrics" = callPackage @@ -163984,6 +172154,8 @@ self: { libraryHaskellDepends = [ base network ]; description = "Client for the metrics aggregator Metricsd"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "metro" = callPackage @@ -164085,6 +172257,7 @@ self: { ]; description = "Time Synchronized execution"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mezzo" = callPackage @@ -164105,6 +172278,8 @@ self: { ]; description = "Typesafe music composition"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mezzolens" = callPackage @@ -164116,6 +172291,8 @@ self: { libraryHaskellDepends = [ base containers mtl transformers ]; description = "Pure Profunctor Functional Lenses"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mfsolve" = callPackage @@ -164145,6 +172322,8 @@ self: { ]; description = "Generics with multiple parameters"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mi" = callPackage @@ -164160,6 +172339,8 @@ self: { ]; description = "Multiple Instance for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "miconix-test" = callPackage @@ -164175,6 +172356,8 @@ self: { executableHaskellDepends = [ base ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "micro-gateway" = callPackage @@ -164203,6 +172386,7 @@ self: { ]; description = "A Micro service gateway"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "micro-recursion-schemes" = callPackage @@ -164220,6 +172404,8 @@ self: { testHaskellDepends = [ base HUnit template-haskell ]; description = "Simple recursion schemes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "microaeson" = callPackage @@ -164255,6 +172441,8 @@ self: { doHaddock = false; description = "A minimal base to work around GHC bugs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "microbench" = callPackage @@ -164317,6 +172505,7 @@ self: { ]; description = "A Microformats 2 parser"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "microformats2-types" = callPackage @@ -164332,6 +172521,7 @@ self: { ]; description = "Microformats 2 types (with Aeson instances)"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "microgroove" = callPackage @@ -164343,6 +172533,8 @@ self: { libraryHaskellDepends = [ base primitive vector ]; description = "Array-backed extensible records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "microlens" = callPackage @@ -164397,6 +172589,8 @@ self: { libraryHaskellDepends = [ base microlens ]; description = "'each' for microlens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "microlens-ghc" = callPackage @@ -164494,6 +172688,8 @@ self: { testHaskellDepends = [ aeson base hspec text ]; description = "A super simple logging module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "microsoft-translator" = callPackage @@ -164511,6 +172707,8 @@ self: { ]; description = "Bindings to the Microsoft Translator API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "microspec" = callPackage @@ -164586,6 +172784,8 @@ self: { ]; description = "Language for algorithmic generation of MIDI files"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "midair" = callPackage @@ -164654,6 +172854,8 @@ self: { ]; description = "Convert MIDI file to music box punch tape"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "midi-simple" = callPackage @@ -164705,6 +172907,8 @@ self: { ]; description = "Utilities for working with MIDI data"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "midimory" = callPackage @@ -164724,6 +172928,7 @@ self: { ]; description = "A Memory-like (Concentration, Pairs, ...) game for tones"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "midisurface" = callPackage @@ -164741,6 +172946,8 @@ self: { ]; description = "A control midi surface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mighttpd" = callPackage @@ -164761,6 +172968,7 @@ self: { ]; description = "Simple Web Server in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mighttpd2" = callPackage @@ -164847,6 +173055,8 @@ self: { ]; description = "Semi-automatic database schema migrations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "migrant-postgresql-simple" = callPackage @@ -164867,6 +173077,8 @@ self: { ]; description = "Semi-automatic database schema migrations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "migrant-sqlite-simple" = callPackage @@ -164897,6 +173109,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "MikMod bindings"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mikrokosmos" = callPackage @@ -164922,6 +173136,8 @@ self: { ]; description = "Lambda calculus interpreter"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "miku" = callPackage @@ -164938,6 +173154,8 @@ self: { ]; description = "A minimum web dev DSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "milena" = callPackage @@ -164961,6 +173179,8 @@ self: { ]; description = "A Kafka client for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mime" = callPackage @@ -164989,6 +173209,8 @@ self: { ]; description = "A library for parsing/printing the text/directory mime type"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mime-mail" = callPackage @@ -165109,6 +173331,7 @@ self: { ]; description = "a DSL for generating minecraft commands and levels"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mines" = callPackage @@ -165143,6 +173366,7 @@ self: { ]; description = "Minesweeper game which is always solvable without guessing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mini-egison" = callPackage @@ -165164,6 +173388,7 @@ self: { testHaskellDepends = [ base hspec primes ]; description = "Template Haskell Implementation of Egison Pattern Matching"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "miniball" = callPackage @@ -165196,6 +173421,7 @@ self: { ]; description = "Miniature FORTH-like interpreter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "minilens" = callPackage @@ -165211,6 +173437,8 @@ self: { ]; description = "A minimalistic lens library, providing only the simplest, most basic lens functionality"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "minilight" = callPackage @@ -165242,6 +173470,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "A SDL2-based graphics library, batteries-included"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "minilight-lua" = callPackage @@ -165262,6 +173492,7 @@ self: { executableHaskellDepends = [ base lens minilight mtl ]; description = "A binding library of minilight for Lua langauge"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "minimal-configuration" = callPackage @@ -165303,6 +173534,7 @@ self: { executableHaskellDepends = [ base GLUT haskell98 unix ]; description = "Shows how to run grabber on Mac OS X"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "minio-hs" = callPackage @@ -165355,6 +173587,8 @@ self: { ]; description = "A fast parallel ssh tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "minioperational" = callPackage @@ -165371,6 +173605,7 @@ self: { ]; description = "fast and simple operational monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "miniplex" = callPackage @@ -165387,6 +173622,8 @@ self: { ]; description = "simple 1-to-N interprocess communication"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "minirotate" = callPackage @@ -165406,6 +173643,8 @@ self: { ]; description = "Minimalistic file rotation utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "minisat" = callPackage @@ -165447,6 +173686,8 @@ self: { ]; description = "an interpreter for an operational semantics for the STG machine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "minitypeset-opengl" = callPackage @@ -165498,6 +173739,8 @@ self: { ]; description = "A set of helpers to call minizinc models"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "minlen" = callPackage @@ -165525,6 +173768,8 @@ self: { testHaskellDepends = [ base binary directory hspec vector ]; description = "Read and write IDX data that is used in e.g. the MINST database."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mintty" = callPackage @@ -165559,6 +173804,8 @@ self: { ]; description = "A Minisat-based CDCL SAT solver in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mirror-tweet" = callPackage @@ -165577,6 +173824,8 @@ self: { ]; description = "Tweet mirror"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "misfortune" = callPackage @@ -165733,6 +173982,8 @@ self: { libraryHaskellDepends = [ aeson base ghcjs-base miso ]; description = "Miso state transition logger"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "miso-examples" = callPackage @@ -165745,6 +173996,8 @@ self: { isExecutable = true; description = "A tasty Haskell front-end framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "miso-from-html" = callPackage @@ -165792,6 +174045,7 @@ self: { ]; description = "A Haskell git implimentation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "miss-porcelain" = callPackage @@ -165810,6 +174064,7 @@ self: { ]; description = "Useability extras built on top of miss"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "missing-foreign" = callPackage @@ -165835,6 +174090,7 @@ self: { ]; description = "Haskell interface to Python"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "mit-3qvpPyAi6mH" = callPackage @@ -165862,6 +174118,8 @@ self: { ]; description = "A git wrapper with a streamlined UX"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "miv" = callPackage @@ -165899,6 +174157,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Mixing effects of one arrow into another one"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mixed-strategies" = callPackage @@ -165915,6 +174175,7 @@ self: { ]; description = "Find optimal mixed strategies for two-player games"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "mixed-types-num" = callPackage @@ -165975,6 +174236,8 @@ self: { testToolDepends = [ hspec-discover markdown-unlit ]; description = "Mixpanel client"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mkbndl" = callPackage @@ -165989,6 +174252,7 @@ self: { executableHaskellDepends = [ base directory filepath haskell98 ]; description = "Makes an OS X .app bundle from a binary."; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "mkcabal" = callPackage @@ -166007,6 +174271,7 @@ self: { ]; description = "Generate cabal files for a Haskell project"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "ml-w" = callPackage @@ -166021,6 +174286,8 @@ self: { executableHaskellDepends = [ base mtl parsec pretty ]; description = "Minimal ML language to to demonstrate the W type infererence algorithm"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mlist" = callPackage @@ -166032,6 +174299,7 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "Monadic List alternative to lazy I/O"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mltool" = callPackage @@ -166066,6 +174334,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "The library that can be used for optimization of multiple (Ord a) => a -> b transformations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mmap" = callPackage @@ -166108,6 +174378,8 @@ self: { benchmarkHaskellDepends = [ base criterion text weigh ]; description = "Strict markdown processor for writers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mmark_0_0_7_3" = callPackage @@ -166138,6 +174410,7 @@ self: { description = "Strict markdown processor for writers"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mmark-cli" = callPackage @@ -166161,6 +174434,7 @@ self: { ]; description = "Command line interface to the MMark markdown processor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mmark-ext" = callPackage @@ -166181,6 +174455,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Commonly useful extensions for the MMark markdown processor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mmorph_1_1_3" = callPackage @@ -166422,6 +174697,8 @@ self: { ]; description = "Macromolecular Transmission Format implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mmtl" = callPackage @@ -166433,6 +174710,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Modular Monad transformer library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mmtl-base" = callPackage @@ -166446,6 +174725,7 @@ self: { libraryHaskellDepends = [ base mmtl ]; description = "MonadBase type-class for mmtl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mnist-idx" = callPackage @@ -166475,6 +174755,7 @@ self: { ]; description = "Language-agnostic analyzer for positional morphosyntactic tags"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mock-httpd" = callPackage @@ -166622,6 +174903,8 @@ self: { ]; description = "A parser for the modelica language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "modern-uri" = callPackage @@ -166671,6 +174954,7 @@ self: { ]; description = "Modify fasta (and CLIP) files in several optional ways"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "modsplit" = callPackage @@ -166691,6 +174975,7 @@ self: { ]; description = "Haskell source splitter driven by special comments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "modular" = callPackage @@ -166731,6 +175016,8 @@ self: { ]; description = "A new Prelude featuring first class modules"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "modular-prelude-classy" = callPackage @@ -166742,6 +175029,7 @@ self: { libraryHaskellDepends = [ base classy-prelude modular-prelude ]; description = "Reifying ClassyPrelude a la ModularPrelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "modularity" = callPackage @@ -166757,6 +175045,7 @@ self: { ]; description = "Find the modularity of a network"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "module-management" = callPackage @@ -166787,6 +175076,8 @@ self: { ]; description = "Clean up module imports, split and merge modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "modulespection" = callPackage @@ -166803,6 +175094,8 @@ self: { ]; description = "Template Haskell for introspecting a module's declarations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "modulo" = callPackage @@ -166822,6 +175115,7 @@ self: { ]; description = "Modular C code generator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "moe" = callPackage @@ -166837,6 +175131,8 @@ self: { ]; description = "html with style"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "moesocks" = callPackage @@ -166859,6 +175155,8 @@ self: { ]; description = "A functional firewall killer"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mohws" = callPackage @@ -166882,6 +175180,8 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Modular Haskell Web Server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mole" = callPackage @@ -166912,6 +175212,7 @@ self: { ]; description = "A glorified string replacement tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "mollie-api-haskell" = callPackage @@ -166937,6 +175238,7 @@ self: { ]; description = "Mollie API client for Haskell http://www.mollie.com"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "monad-abort-fd" = callPackage @@ -166964,6 +175266,8 @@ self: { libraryHaskellDepends = [ base containers ghc-prim mtl ]; description = "Monadically convert object to unique integers and back"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-atom-simple" = callPackage @@ -166975,6 +175279,8 @@ self: { libraryHaskellDepends = [ base containers ghc-prim mtl ]; description = "Monadically map objects to unique ints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-batcher" = callPackage @@ -167018,6 +175324,8 @@ self: { ]; description = "A library for probabilistic programming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-bool" = callPackage @@ -167041,6 +175349,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Monadic abstraction for computations that can be branched and run independently"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-choice" = callPackage @@ -167233,6 +175543,7 @@ self: { ]; description = "Exstensible monadic exceptions"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "monad-extras" = callPackage @@ -167275,6 +175586,8 @@ self: { libraryHaskellDepends = [ base monad-control ]; description = "Type class for monads which support a fork operation"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-gen" = callPackage @@ -167323,6 +175636,8 @@ self: { ]; description = "A class of monads which can do http requests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-interleave" = callPackage @@ -167334,6 +175649,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Monads with an unsaveInterleaveIO-like operation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-introspect" = callPackage @@ -167395,6 +175712,8 @@ self: { ]; description = "Specific levels of monad transformers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-lgbt" = callPackage @@ -167413,6 +175732,8 @@ self: { ]; description = "Monad transformers for combining local and global state"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-log" = callPackage @@ -167432,6 +175753,8 @@ self: { ]; description = "A simple and fast logging monad"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-logger" = callPackage @@ -167578,6 +175901,8 @@ self: { ]; description = "a monad to calculate linear recursive sequence"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-markov" = callPackage @@ -167629,6 +175954,8 @@ self: { libraryHaskellDepends = [ base mersenne-random-pure64 ]; description = "An efficient random generator monad, based on the Mersenne Twister"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-metrics" = callPackage @@ -167684,6 +176011,8 @@ self: { testHaskellDepends = [ base hspec mtl ]; description = "A monad transformer for mocking mtl-style typeclasses"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-open" = callPackage @@ -167695,6 +176024,8 @@ self: { libraryHaskellDepends = [ base exceptions mtl transformers ]; description = "Open recursion for when you need it"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-ox" = callPackage @@ -167776,6 +176107,8 @@ self: { ]; description = "Parallel execution of monadic computations with a progress bar"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-param" = callPackage @@ -167787,6 +176120,8 @@ self: { libraryHaskellDepends = [ base mtl stm ]; description = "Parameterized monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-peel" = callPackage @@ -167827,6 +176162,8 @@ self: { ]; description = "An mtl-style typeclass and transformer for persistent"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-primitive" = callPackage @@ -167860,6 +176197,8 @@ self: { libraryHaskellDepends = [ base ghc-prim mtl ]; description = "Fast monads and monad transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-recorder" = callPackage @@ -167876,6 +176215,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Record and replay the results of monadic actions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-resumption" = callPackage @@ -167924,6 +176265,7 @@ self: { ]; description = "Utility library for monads, particularly those involving state"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "monad-statevar" = callPackage @@ -167936,6 +176278,8 @@ self: { testHaskellDepends = [ base stm ]; description = "Concise, overloaded accessors for IORef, STRef, TVar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-ste" = callPackage @@ -167952,6 +176296,8 @@ self: { testHaskellDepends = [ base hspec HUnit ]; description = "ST monad with efficient explicit errors"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-stlike-io" = callPackage @@ -167966,6 +176312,8 @@ self: { ]; description = "ST-like monad capturing variables to regions and supporting IO"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-stlike-stm" = callPackage @@ -167977,6 +176325,7 @@ self: { libraryHaskellDepends = [ base monad-stlike-io stm ]; description = "ST-like monad capturing variables to regions and supporting STM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "monad-stm" = callPackage @@ -168011,6 +176360,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "A monad transformer that turns event processing into co-routine programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-time" = callPackage @@ -168040,6 +176391,8 @@ self: { testHaskellDepends = [ base containers hlint hspec transformers ]; description = "Monad transformer for recording timing events"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-tx" = callPackage @@ -168051,6 +176404,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A transactional state monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-unify" = callPackage @@ -168064,6 +176419,8 @@ self: { libraryHaskellDepends = [ base mtl unordered-containers ]; description = "Generic first-order unification"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-unlift" = callPackage @@ -168138,6 +176495,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Wrap functions such as catch around different monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monadIO" = callPackage @@ -168173,6 +176532,8 @@ self: { libraryHaskellDepends = [ base monadLib ]; description = "Arrow-like monad composition for monadLib"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monadacme" = callPackage @@ -168184,6 +176545,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "The Acme and AcmeT monads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monadbi" = callPackage @@ -168253,6 +176616,8 @@ self: { testHaskellDepends = [ base ]; description = "Recursion Schemes for Monadic version"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monadiccp" = callPackage @@ -168270,6 +176635,8 @@ self: { testHaskellDepends = [ base ]; description = "Constraint Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monadiccp-gecode" = callPackage @@ -168288,6 +176655,7 @@ self: { testHaskellDepends = [ base ]; description = "Constraint Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {gecodeint = null; gecodekernel = null; gecodesearch = null; gecodeset = null; gecodesupport = null;}; @@ -168339,6 +176707,8 @@ self: { ]; description = "A preprocessor for generating monadic call traces"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monadlog" = callPackage @@ -168358,6 +176728,8 @@ self: { ]; description = "A simple and fast logging monad"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monadoid" = callPackage @@ -168384,6 +176756,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell98 partial maps and filters over MonadPlus"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monads-fd" = callPackage @@ -168395,6 +176769,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Monad classes, using functional dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monads-tf" = callPackage @@ -168435,6 +176811,7 @@ self: { testHaskellDepends = [ base doctest ]; description = "Monadic interface for TokyoTyrant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mondo" = callPackage @@ -168458,6 +176835,8 @@ self: { ]; description = "Haskell bindings for the Mondo API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monetdb-mapi" = callPackage @@ -168469,6 +176848,7 @@ self: { libraryHaskellDepends = [ base bindings-monetdb-mapi ]; description = "Mid-level bindings for the MonetDB API (mapi)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "money" = callPackage @@ -168481,6 +176861,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Money"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mongoDB" = callPackage @@ -168513,6 +176895,7 @@ self: { ]; description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "mongodb-queue" = callPackage @@ -168533,6 +176916,7 @@ self: { ]; description = "message queue using MongoDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "mongrel2-handler" = callPackage @@ -168550,6 +176934,7 @@ self: { ]; description = "Mongrel2 Handler Library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "monitor" = callPackage @@ -168563,6 +176948,8 @@ self: { executableHaskellDepends = [ base filepath hinotify process ]; description = "Do things when files change"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monky" = callPackage @@ -168587,6 +176974,7 @@ self: { ]; description = "A system state collecting library and application"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "mono-foldable" = callPackage @@ -168598,6 +176986,8 @@ self: { libraryHaskellDepends = [ base bytestring text vector ]; description = "Folds for monomorphic containers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mono-traversable" = callPackage @@ -168678,6 +177068,8 @@ self: { libraryHaskellDepends = [ base containers lens mtl ]; description = "Monoid type classes, designed in modular way, distinguish Monoid from Mempty and Semigroup. This design allows mempty operation don't bring Semigroups related constraints until (<>) is used."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monoid-absorbing" = callPackage @@ -168689,6 +177081,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "A library for (left, right) zero monoids and backtracking with cut"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monoid-extras" = callPackage @@ -168716,6 +177110,8 @@ self: { libraryHaskellDepends = [ base bytestring containers ]; description = "a practical monoid implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monoid-record" = callPackage @@ -168828,6 +177224,8 @@ self: { ]; description = "Extra classes/functions about monoids"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monoids" = callPackage @@ -168843,6 +177241,8 @@ self: { ]; description = "Deprecated: Use 'reducers'"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monomorphic" = callPackage @@ -168870,6 +177270,8 @@ self: { ]; description = "Well-typed paths"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "montage" = callPackage @@ -168935,6 +177337,7 @@ self: { ]; description = "A monad and transformer for Monte Carlo calculations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "months" = callPackage @@ -168953,6 +177356,8 @@ self: { ]; description = "MonthName"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monus" = callPackage @@ -168969,6 +177374,8 @@ self: { ]; description = "a 'Monus' is a commutative monoid that allows a notion of substraction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monzo" = callPackage @@ -168992,6 +177399,8 @@ self: { ]; description = "Haskell bindings for the Monzo API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "moo" = callPackage @@ -169013,6 +177422,7 @@ self: { ]; description = "Genetic algorithm library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "moonshine" = callPackage @@ -169072,6 +177482,8 @@ self: { ]; description = "A tool for supervised learning of morphology"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "morfeusz" = callPackage @@ -169089,6 +177501,8 @@ self: { librarySystemDepends = [ morfeusz ]; description = "Bindings to the morphological analyser Morfeusz"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {morfeusz = null;}; "morley" = callPackage @@ -169133,6 +177547,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "Developer tools for the Michelson Language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "morley-prelude" = callPackage @@ -169215,6 +177630,7 @@ self: { ]; description = "A multi-lingual, typed, workflow language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "morph" = callPackage @@ -169307,6 +177723,8 @@ self: { ]; description = "Morpheus GraphQL CLI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "morpheus-graphql-client" = callPackage @@ -169400,6 +177818,8 @@ self: { libraryHaskellDepends = [ morphisms ]; description = "Functors, theirs compositions and transformations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "morphisms-functors-inventory" = callPackage @@ -169411,6 +177831,7 @@ self: { libraryHaskellDepends = [ morphisms morphisms-functors ]; description = "Inventory is state and store"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "morphisms-objects" = callPackage @@ -169422,6 +177843,8 @@ self: { libraryHaskellDepends = [ morphisms ]; description = "Algebraic structures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "morte" = callPackage @@ -169455,6 +177878,8 @@ self: { benchmarkHaskellDepends = [ base criterion system-filepath text ]; description = "A bare-bones calculus of constructions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mosaico-lib" = callPackage @@ -169473,6 +177898,7 @@ self: { ]; description = "Generación interactiva de mosaicos"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mosquitto-hs" = callPackage @@ -169541,6 +177967,8 @@ self: { ]; description = "PostgreSQL-based migrations registry for moto"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "motor" = callPackage @@ -169581,6 +178009,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Generate state diagrams from Motor FSM typeclasses"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "motor-reflection" = callPackage @@ -169598,6 +178027,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Reflect on Motor FSM typeclasses to obtain runtime representations"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mount" = callPackage @@ -169609,6 +178040,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Mounts and umounts filesystems"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mountpoints" = callPackage @@ -169643,6 +178076,8 @@ self: { ]; description = "Plays videos using GStreamer and GTK+"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "moving-averages" = callPackage @@ -169679,6 +178114,7 @@ self: { ]; description = "Music player for linux"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "mp3decoder" = callPackage @@ -169710,6 +178146,7 @@ self: { ]; description = "MPD/PowerMate executable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mpg123-bindings" = callPackage @@ -169832,6 +178269,8 @@ self: { ]; description = "Multi-dimensional parametric pretty-printer with color"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mprelude" = callPackage @@ -169850,6 +178289,7 @@ self: { ]; description = "A minimalish prelude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mpretty" = callPackage @@ -169866,6 +178306,7 @@ self: { ]; description = "a monadic, extensible pretty printing library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mpris" = callPackage @@ -169877,6 +178318,8 @@ self: { libraryHaskellDepends = [ base containers dbus mtl ]; description = "Interface for MPRIS"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mprover" = callPackage @@ -169894,6 +178337,7 @@ self: { ]; description = "Simple equational reasoning for a Haskell-ish language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mps" = callPackage @@ -169913,6 +178357,7 @@ self: { ]; description = "simply oo"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mptcp-pm" = callPackage @@ -169937,6 +178382,7 @@ self: { executableToolDepends = [ c2hs ]; description = "A work in progress Multipath TCP path manager"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "mpvguihs" = callPackage @@ -169955,6 +178401,8 @@ self: { ]; description = "A minimalist mpv GUI written in I/O heavy Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mqtt" = callPackage @@ -169983,6 +178431,8 @@ self: { ]; description = "An MQTT protocol implementation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mqtt-hs" = callPackage @@ -169999,6 +178449,8 @@ self: { ]; description = "A MQTT client library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mr-env" = callPackage @@ -170024,6 +178476,8 @@ self: { executableHaskellDepends = [ array base containers mtl ]; description = "Decompiles Glulx files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mrm" = callPackage @@ -170035,6 +178489,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Modular Refiable Matching, first-class matches"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ms" = callPackage @@ -170055,6 +178511,8 @@ self: { ]; description = "metric spaces"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ms-tds" = callPackage @@ -170100,6 +178558,8 @@ self: { ]; description = "A Haskell implementation of MessagePack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "msgpack-aeson" = callPackage @@ -170118,6 +178578,7 @@ self: { testHaskellDepends = [ aeson base msgpack tasty tasty-hunit ]; description = "Aeson adapter for MessagePack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "msgpack-binary" = callPackage @@ -170144,6 +178605,8 @@ self: { ]; description = "A Haskell implementation of MessagePack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "msgpack-idl" = callPackage @@ -170165,6 +178628,7 @@ self: { testHaskellDepends = [ base hspec ]; description = "An IDL Compiler for MessagePack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "msgpack-rpc" = callPackage @@ -170185,6 +178649,7 @@ self: { testHaskellDepends = [ async base mtl network tasty tasty-hunit ]; description = "A MessagePack-RPC Implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "msgpack-rpc-conduit" = callPackage @@ -170206,6 +178671,7 @@ self: { testHaskellDepends = [ async base bytestring hspec mtl network ]; description = "A MessagePack-RPC Implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "msgpack-types" = callPackage @@ -170243,6 +178709,8 @@ self: { ]; description = "Object-Oriented Programming in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "msi-kb-backlit" = callPackage @@ -170256,6 +178724,8 @@ self: { executableHaskellDepends = [ base bytestring hid split ]; description = "A command line tool to change backlit colors of your MSI keyboards"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mssql-simple" = callPackage @@ -170330,6 +178800,7 @@ self: { ]; description = "Library to communicate with Mt.Gox"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mtl_2_2_2" = callPackage @@ -170353,6 +178824,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Very strict CPS'd transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mtl-compat" = callPackage @@ -170380,6 +178853,8 @@ self: { ]; description = "Instances for the mtl classes for all monad transformers"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mtl-extras" = callPackage @@ -170391,6 +178866,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Higher order versions of MTL classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mtl-prelude" = callPackage @@ -170413,6 +178890,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Monad Transformer Library with Type Families"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mtl-unleashed" = callPackage @@ -170466,6 +178945,8 @@ self: { libraryHaskellDepends = [ base mtl QuickCheck ]; description = "Monad transformer library with type indexes, providing 'free' copies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mtp" = callPackage @@ -170478,6 +178959,8 @@ self: { librarySystemDepends = [ mtp ]; description = "Bindings to libmtp"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {mtp = null;}; "mtree" = callPackage @@ -170577,6 +179060,7 @@ self: { ]; description = "gRPC clients from Mu definitions"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "mu-grpc-common" = callPackage @@ -170622,6 +179106,7 @@ self: { ]; description = "gRPC servers for Mu definitions"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "mu-kafka" = callPackage @@ -170796,6 +179281,7 @@ self: { ]; description = "Tracing support for Mu"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "mucipher" = callPackage @@ -170831,6 +179317,8 @@ self: { ]; description = "Multi-version deployer for web applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mudbath" = callPackage @@ -170868,6 +179356,8 @@ self: { ]; description = "A simple document-oriented database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mueval" = callPackage @@ -170921,6 +179411,8 @@ self: { testToolDepends = [ alex happy ]; description = "An intermediate language designed to perform advanced code analysis"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multext-east-msd" = callPackage @@ -170932,6 +179424,8 @@ self: { libraryHaskellDepends = [ base ]; description = "MULTEXT-East morphosyntactic descriptors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multi-cabal" = callPackage @@ -170953,6 +179447,7 @@ self: { ]; description = "A tool supporting multi cabal project builds"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "multi-containers" = callPackage @@ -170978,6 +179473,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Typeclasses augmented with a phantom type parameter"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multi-trie" = callPackage @@ -171010,6 +179507,8 @@ self: { ]; description = "A network address format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multiarg" = callPackage @@ -171028,6 +179527,8 @@ self: { ]; description = "Command lines for options that take multiple arguments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multibase" = callPackage @@ -171094,6 +179595,7 @@ self: { ]; description = "Bidirectional Two-level Transformation of XML Schemas"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "multihash" = callPackage @@ -171117,6 +179619,8 @@ self: { ]; description = "Multihash library and CLI executable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multihash-cryptonite" = callPackage @@ -171186,6 +179690,8 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq weigh ]; description = "Comprehensive and efficient (multi)linear algebra implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multilinear-io" = callPackage @@ -171209,6 +179715,7 @@ self: { ]; description = "Conduit-based input/output capability for multilinear package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "multimap" = callPackage @@ -171263,6 +179770,8 @@ self: { ]; description = "Folding data with multiple named passes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multipath" = callPackage @@ -171274,6 +179783,8 @@ self: { libraryHaskellDepends = [ base parsec utf8-string ]; description = "Parser and builder for unix-path-like objects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multiplate" = callPackage @@ -171300,6 +179811,8 @@ self: { libraryHaskellDepends = [ base multiplate transformers ]; description = "Shorter, more generic functions for Multiplate"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multiplicity" = callPackage @@ -171316,6 +179829,7 @@ self: { ]; description = "Wrapper program for duplicity, adding config files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "multipool" = callPackage @@ -171380,6 +179894,8 @@ self: { ]; description = "Read and write appropriately from both master and replicated postgresql instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multipool-postgresql-simple" = callPackage @@ -171423,6 +179939,8 @@ self: { testHaskellDepends = [ base ]; description = "Generic programming for families of recursive datatypes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multirec-alt-deriver" = callPackage @@ -171438,6 +179956,7 @@ self: { ]; description = "Alternative multirec instances deriver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "multirec-binary" = callPackage @@ -171449,6 +179968,7 @@ self: { libraryHaskellDepends = [ base binary multirec ]; description = "Generic Data.Binary instances using MultiRec."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "multiset" = callPackage @@ -171490,6 +180010,7 @@ self: { libraryHaskellDepends = [ base haskell98 stm ]; description = "Multi-set rewrite rules with guards and a parallel execution scheme"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "multistate" = callPackage @@ -171538,6 +180059,8 @@ self: { ]; description = "Multivariant assignments generation language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multivector" = callPackage @@ -171578,6 +180101,8 @@ self: { ]; description = "Static blog generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "murder" = callPackage @@ -171594,6 +180119,7 @@ self: { ]; description = "MUtually Recursive Definitions Explicitly Represented"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "murmur" = callPackage @@ -171619,6 +180145,8 @@ self: { testHaskellDepends = [ base ]; description = "Simple CUI Twitter Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "murmur-hash" = callPackage @@ -171650,6 +180178,8 @@ self: { ]; description = "Pure Haskell implementation of the MurmurHash3 x86_32 algorithm"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "murmurhash3" = callPackage @@ -171661,6 +180191,7 @@ self: { libraryHaskellDepends = [ haskell2010 ]; description = "32-bit non-cryptographic hashing"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "mushu" = callPackage @@ -171687,6 +180218,8 @@ self: { testHaskellDepends = [ base classy-prelude ]; description = "Minimalist MPD client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "music-articulation" = callPackage @@ -171751,6 +180284,7 @@ self: { ]; description = "Diagrams-based visualization of musical data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "music-parts" = callPackage @@ -171773,6 +180307,7 @@ self: { ]; description = "Musical instruments, parts and playing techniques"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "music-pitch" = callPackage @@ -171790,6 +180325,7 @@ self: { ]; description = "Musical pitch representation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "music-pitch-literal" = callPackage @@ -171830,6 +180366,7 @@ self: { testHaskellDepends = [ base process tasty tasty-golden ]; description = "Some useful preludes for the Music Suite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "music-score" = callPackage @@ -171853,6 +180390,7 @@ self: { ]; description = "Musical score and part representation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "music-sibelius" = callPackage @@ -171872,6 +180410,7 @@ self: { ]; description = "Interaction with Sibelius"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "music-suite" = callPackage @@ -171891,6 +180430,7 @@ self: { doHaddock = false; description = "A set of libraries for composition, analysis and manipulation of music"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "music-util" = callPackage @@ -171908,6 +180448,8 @@ self: { ]; description = "Utility for developing the Music Suite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "musicScroll" = callPackage @@ -171932,6 +180474,8 @@ self: { executablePkgconfigDepends = [ gtk3 ]; description = "Supply your tunes info without leaving your music player"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtk3;}; "musicbrainz-email" = callPackage @@ -172000,6 +180544,8 @@ self: { ]; description = "MusicXML format encoded as Haskell type and functions of reading and writting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "musicxml2" = callPackage @@ -172017,6 +180563,7 @@ self: { ]; description = "A representation of the MusicXML format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mustache" = callPackage @@ -172070,6 +180617,8 @@ self: { ]; description = "Straight implementation of mustache templates"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mustache2hs" = callPackage @@ -172144,6 +180693,7 @@ self: { ]; description = "iteratees based upon mutable buffers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mutable-lens" = callPackage @@ -172180,6 +180730,7 @@ self: { ]; description = "Watches your screensaver and (un)mutes music when you (un)lock the screen"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "mvar-lock" = callPackage @@ -172191,6 +180742,8 @@ self: { libraryHaskellDepends = [ base safe-exceptions ]; description = "A trivial lock based on MVar"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mvc" = callPackage @@ -172207,6 +180760,8 @@ self: { ]; description = "Model-view-controller"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mvc-updates" = callPackage @@ -172218,6 +180773,7 @@ self: { libraryHaskellDepends = [ async base foldl mvc ]; description = "Concurrent and combinable updates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mvclient" = callPackage @@ -172236,6 +180792,7 @@ self: { ]; description = "Client library for metaverse systems like Second Life"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mwc-probability" = callPackage @@ -172369,6 +180926,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit vector ]; description = "MXNet interface in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) mxnet;}; "mxnet-dataiter" = callPackage @@ -172386,6 +180945,7 @@ self: { testHaskellDepends = [ base hspec mxnet streaming ]; description = "mxnet dataiters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mxnet-examples" = callPackage @@ -172399,6 +180959,7 @@ self: { executableHaskellDepends = [ base mxnet ]; description = "Examples for MXNet in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "mxnet-nn" = callPackage @@ -172424,6 +180985,7 @@ self: { ]; description = "Train a neural network with MXNet in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mxnet-nnvm" = callPackage @@ -172437,6 +180999,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "NNVM interface in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) mxnet;}; "my-package-testing" = callPackage @@ -172461,6 +181025,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "my-test-docs" = callPackage @@ -172485,6 +181051,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "spam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "myTestlll" = callPackage @@ -172509,6 +181077,7 @@ self: { ]; description = "None"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "myanimelist-export" = callPackage @@ -172532,6 +181101,8 @@ self: { ]; description = "Export from MyAnimeList"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mybitcoin-sci" = callPackage @@ -172568,6 +181139,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Haskell binding to the Myo armband"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mysnapsession" = callPackage @@ -172584,6 +181157,8 @@ self: { ]; description = "Sessions and continuations for Snap web apps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mysnapsession-example" = callPackage @@ -172603,6 +181178,7 @@ self: { ]; description = "Example projects using mysnapsession"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mysql" = callPackage @@ -172635,6 +181211,8 @@ self: { ]; description = "An extensible mysql effect using extensible-effects and mysql-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mysql-haskell" = callPackage @@ -172689,6 +181267,7 @@ self: { ]; description = "TLS support for mysql-haskell package using openssl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mysql-simple" = callPackage @@ -172722,6 +181301,8 @@ self: { ]; description = "Quasi-quoter for use with mysql-simple"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mysql-simple-typed" = callPackage @@ -172737,6 +181318,7 @@ self: { ]; description = "Typed extension to mysql simple"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mystem" = callPackage @@ -172755,6 +181337,8 @@ self: { executableHaskellDepends = [ base text ]; description = "Bindings for Mystem morphological analyzer executabe"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mywatch" = callPackage @@ -172779,6 +181363,7 @@ self: { ]; description = "Web application to view and kill MySQL queries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "myxine-client" = callPackage @@ -172801,6 +181386,8 @@ self: { testHaskellDepends = [ bytestring text ]; description = "A Haskell client for the Myxine GUI server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mzv" = callPackage @@ -172812,6 +181399,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Implementation of the \"Monads, Zippers and Views\" (Schrijvers and Oliveira, ICFP'11)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "n-ary-functor" = callPackage @@ -172855,6 +181444,8 @@ self: { libraryHaskellDepends = [ base singletons vector ]; description = "Homogeneous tuples of arbitrary length"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "n2o" = callPackage @@ -172899,6 +181490,8 @@ self: { ]; description = "N2O Protocols Starter Pack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "n2o-web" = callPackage @@ -172917,6 +181510,7 @@ self: { ]; description = "N2O adapter for WebSockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nagios-check" = callPackage @@ -172986,6 +181580,8 @@ self: { ]; description = "Monitor ekg metrics via Nagios"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nakadi-client" = callPackage @@ -173024,6 +181620,7 @@ self: { ]; description = "Client library for the Nakadi Event Broker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "namecoin-update" = callPackage @@ -173078,6 +181675,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A named lock that is created on demand"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "named-records" = callPackage @@ -173130,6 +181729,8 @@ self: { ]; description = "server support for named-servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "named-sop" = callPackage @@ -173142,6 +181743,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Dependently-typed sums and products, tagged by field name"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "namelist" = callPackage @@ -173160,6 +181763,8 @@ self: { ]; description = "fortran90 namelist parser/pretty printer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "names" = callPackage @@ -173234,6 +181839,8 @@ self: { librarySystemDepends = [ openssl ]; description = "Bindings to OpenSSL HMAC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openssl;}; "nano-md5" = callPackage @@ -173248,6 +181855,8 @@ self: { librarySystemDepends = [ openssl ]; description = "Efficient, ByteString bindings to OpenSSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openssl;}; "nanoAgda" = callPackage @@ -173278,6 +181887,8 @@ self: { librarySystemDepends = [ ncurses ]; description = "Simple Curses binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ncurses;}; "nanomsg" = callPackage @@ -173290,6 +181901,8 @@ self: { librarySystemDepends = [ nanomsg ]; description = "nanomsg - scalability protocols library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) nanomsg;}; "nanomsg-haskell" = callPackage @@ -173314,6 +181927,8 @@ self: { ]; description = "Bindings to the nanomsg library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) nanomsg;}; "nanoparsec" = callPackage @@ -173325,6 +181940,8 @@ self: { libraryHaskellDepends = [ base bytestring ListLike ]; description = "An implementation of attoparsec-like parser around list-like"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nanospec" = callPackage @@ -173358,6 +181975,8 @@ self: { testHaskellDepends = [ base containers hspec inline-c QuickCheck ]; description = "Haskell bindings for nanovg"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {GLEW = null; inherit (pkgs) glew; inherit (pkgs) libGL; inherit (pkgs) libGLU;}; @@ -173376,6 +181995,7 @@ self: { ]; description = "Simple interface to rendering with NanoVG"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nanq" = callPackage @@ -173395,6 +182015,8 @@ self: { ]; description = "Performs 漢字検定 (Japan Kanji Aptitude Test) level analysis on given Kanji"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "naperian" = callPackage @@ -173412,6 +182034,8 @@ self: { ]; description = "Efficient representable functors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "naqsha" = callPackage @@ -173430,6 +182054,8 @@ self: { doHaddock = false; description = "A library for working with anything map related"; license = "(Apache-2.0 OR BSD-3-Clause)"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "narc" = callPackage @@ -173441,6 +182067,8 @@ self: { libraryHaskellDepends = [ base HDBC HUnit mtl QuickCheck random ]; description = "Query SQL databases using Nested Relational Calculus embedded in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nat" = callPackage @@ -173464,6 +182092,8 @@ self: { testHaskellDepends = [ base doctest hedgehog QuickCheck ]; description = "Variable-sized numbers from type-level nats"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nationstates" = callPackage @@ -173480,6 +182110,8 @@ self: { ]; description = "NationStates API client"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "native" = callPackage @@ -173539,6 +182171,8 @@ self: { benchmarkHaskellDepends = [ base criterion time ]; description = "Another Haskell client for NATS (https://nats.io)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nats-queue" = callPackage @@ -173559,6 +182193,7 @@ self: { ]; description = "Haskell API for NATS messaging system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "natural" = callPackage @@ -173577,6 +182212,8 @@ self: { ]; description = "Natural number"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "natural-arithmetic" = callPackage @@ -173617,6 +182254,7 @@ self: { ]; description = "Natural numbers tagged with a type-level representation of the number"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "natural-numbers" = callPackage @@ -173694,6 +182332,8 @@ self: { ]; description = "Interface to Naver Translate"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nbt" = callPackage @@ -173713,6 +182353,8 @@ self: { ]; description = "A parser/serializer for Minecraft's Named Binary Tag (NBT) data format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nc-indicators" = callPackage @@ -173775,6 +182417,8 @@ self: { executableHaskellDepends = [ base filepath parsec ]; description = "A Fast Retargetable Template Engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neat-interpolation" = callPackage @@ -173809,6 +182453,8 @@ self: { ]; description = "ASCII-fied arrow notation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neet" = callPackage @@ -173825,6 +182471,8 @@ self: { ]; description = "A NEAT library for Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nehe-tuts" = callPackage @@ -173844,6 +182492,8 @@ self: { ]; description = "Port of the NeHe OpenGL tutorials to Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neil" = callPackage @@ -173873,6 +182523,8 @@ self: { libraryHaskellDepends = [ base failure transformers ]; description = "Provide versions of Either with good monad and applicative instances. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neko-lib" = callPackage @@ -173893,6 +182545,8 @@ self: { ]; description = "Neko VM code generation and disassembly library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neko-obfs" = callPackage @@ -173946,6 +182600,7 @@ self: { ]; description = "A collection of Nemesis tasks to bootstrap a Haskell project with a focus on continuous integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "neptune-backend" = callPackage @@ -173979,6 +182634,8 @@ self: { ]; description = "Neptune Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nerf" = callPackage @@ -174005,6 +182662,7 @@ self: { ]; description = "Nerf, a named entity recognition tool based on linear-chain CRFs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nero" = callPackage @@ -174023,6 +182681,8 @@ self: { ]; description = "Lens-based HTTP toolkit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nero-wai" = callPackage @@ -174038,6 +182698,7 @@ self: { ]; description = "WAI adapter for Nero server applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nero-warp" = callPackage @@ -174049,6 +182710,7 @@ self: { libraryHaskellDepends = [ base nero nero-wai warp ]; description = "Run Nero server applications with Warp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nest" = callPackage @@ -174064,6 +182726,8 @@ self: { ]; testHaskellDepends = [ base bytestring containers hedgehog text ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nested-routes" = callPackage @@ -174093,6 +182757,7 @@ self: { ]; description = "Declarative, compositional Wai responses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nested-sequence" = callPackage @@ -174109,6 +182774,8 @@ self: { ]; description = "List-like data structures with O(log(n)) random access"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nested-sets" = callPackage @@ -174137,6 +182804,8 @@ self: { ]; description = "A library for nested maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "net-concurrent" = callPackage @@ -174248,6 +182917,8 @@ self: { ]; description = "A graph database middleware to maintain a time-varying graph"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "net-spider-cli" = callPackage @@ -174268,6 +182939,7 @@ self: { ]; description = "CLI option parsers for NetSpider objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "net-spider-pangraph" = callPackage @@ -174286,6 +182958,7 @@ self: { ]; description = "Conversion between net-spider and pangraph"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "net-spider-rpl" = callPackage @@ -174307,6 +182980,7 @@ self: { ]; description = "NetSpider data model and utility for RPL networks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "net-spider-rpl-cli" = callPackage @@ -174333,6 +183007,7 @@ self: { ]; description = "CLI executable of NetSpider.RPL."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "netclock" = callPackage @@ -174346,6 +183021,8 @@ self: { libraryHaskellDepends = [ base bytestring hosc network ]; description = "Netclock protocol"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "netcode-io" = callPackage @@ -174391,6 +183068,7 @@ self: { ]; description = "The NetCore compiler and runtime system for OpenFlow networks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "netease-fm" = callPackage @@ -174419,6 +183097,8 @@ self: { ]; description = "NetEase Cloud Music FM client in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "netlib-carray" = callPackage @@ -174478,6 +183158,7 @@ self: { executableHaskellDepends = [ base HTF random ]; description = "Enumerator tools for text-based network protocols"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "netlink" = callPackage @@ -174574,6 +183255,8 @@ self: { ]; description = "Contract normaliser and simulator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "netspec" = callPackage @@ -174590,6 +183273,8 @@ self: { ]; description = "Simplify static Networking tasks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "netstring-enumerator" = callPackage @@ -174603,6 +183288,7 @@ self: { ]; description = "Enumerator-based netstring parsing"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "nettle" = callPackage @@ -174644,6 +183330,7 @@ self: { ]; description = "FRP for controlling networks of OpenFlow switches"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nettle-netkit" = callPackage @@ -174659,6 +183346,7 @@ self: { ]; description = "DSL for describing OpenFlow networks, and a compiler generating NetKit labs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nettle-openflow" = callPackage @@ -174675,6 +183363,7 @@ self: { ]; description = "OpenFlow protocol messages, binary formats, and servers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "netwire" = callPackage @@ -174734,6 +183423,8 @@ self: { ]; description = "JavaScript instance of netwire-input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "netwire-vinylglfw-examples" = callPackage @@ -174756,6 +183447,8 @@ self: { ]; description = "Netwire/GLFW/VinylGL input handling demo"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network_2_6_3_1" = callPackage @@ -174826,6 +183519,8 @@ self: { ]; description = "IP data structures and textual representation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-anonymous-i2p" = callPackage @@ -174848,6 +183543,7 @@ self: { ]; description = "Haskell API for I2P anonymous networking"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "network-anonymous-tor" = callPackage @@ -174877,6 +183573,7 @@ self: { ]; description = "Haskell API for Tor anonymous networking"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "network-api-support" = callPackage @@ -174894,6 +183591,8 @@ self: { ]; description = "Toolkit for building http client libraries over Network.Http.Conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-arbitrary" = callPackage @@ -174938,6 +183637,8 @@ self: { doCheck = false; description = "Utility functions for running a parser against a socket"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-bitcoin" = callPackage @@ -174960,6 +183661,8 @@ self: { ]; description = "An interface to bitcoind"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-bsd" = callPackage @@ -174994,6 +183697,8 @@ self: { ]; description = "Linux NetworkNameSpace Builder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-byte-order" = callPackage @@ -175021,6 +183726,8 @@ self: { libraryHaskellDepends = [ base bytestring network unix ]; description = "Fast, memory-efficient, low-level networking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-carbon" = callPackage @@ -175081,6 +183788,7 @@ self: { ]; description = "A wrapper around a generic stream-like connection"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-data" = callPackage @@ -175131,6 +183839,8 @@ self: { ]; description = "Domain Name System data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-enumerator" = callPackage @@ -175146,6 +183856,7 @@ self: { ]; description = "Enumerators for network sockets"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "network-fancy" = callPackage @@ -175168,6 +183879,7 @@ self: { libraryHaskellDepends = [ base bytestring hans parsec ]; description = "HaNS to Network shims for easier HaNS integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-house" = callPackage @@ -175179,6 +183891,8 @@ self: { libraryHaskellDepends = [ array base containers mtl ]; description = "data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-info" = callPackage @@ -175203,6 +183917,7 @@ self: { libraryHaskellDepends = [ base bytestring ioctl network ]; description = "Haskell bindings for the ifreq structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-ip" = callPackage @@ -175284,6 +183999,7 @@ self: { ]; description = "WebSocket backend for MessagePack RPC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-metrics" = callPackage @@ -175319,6 +184035,7 @@ self: { ]; description = "A ByteString based library for writing HTTP(S) servers and clients"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-msg" = callPackage @@ -175353,6 +184070,8 @@ self: { testHaskellDepends = [ async base bytestring hspec mtl network ]; description = "A MessagePack-RPC Implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-multicast" = callPackage @@ -175380,6 +184099,7 @@ self: { ]; description = "Haskell bindings for low-level packet sockets (AF_PACKET)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-packet-linux" = callPackage @@ -175397,6 +184117,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Types for working with Linux packet sockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-pgi" = callPackage @@ -175429,6 +184151,7 @@ self: { ]; description = "Client library for the XMPP protocol"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "network-rpca" = callPackage @@ -175446,6 +184169,7 @@ self: { ]; description = "A cross-platform RPC library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-run" = callPackage @@ -175471,6 +184195,8 @@ self: { executableHaskellDepends = [ base network unix ]; description = "A light abstraction over sockets & co. for servers"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-service" = callPackage @@ -175486,6 +184212,8 @@ self: { ]; description = "Provide a service at the data type level"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-simple" = callPackage @@ -175517,6 +184245,8 @@ self: { ]; description = "network-simple for resolved addresses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-simple-tls" = callPackage @@ -175567,6 +184297,8 @@ self: { ]; description = "Simple interface to TLS secured WebSockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-socket-options" = callPackage @@ -175578,6 +184310,8 @@ self: { libraryHaskellDepends = [ base network ]; description = "Type-safe, portable alternative to getSocketOption/setSocketOption"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-stream" = callPackage @@ -175594,6 +184328,7 @@ self: { ]; description = "ByteString and Text streams for networking"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "network-topic-models" = callPackage @@ -175615,6 +184350,7 @@ self: { ]; description = "A few network topic model implementations for bayes-stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "network-transport" = callPackage @@ -175655,6 +184391,8 @@ self: { ]; description = "AMQP-based transport layer for distributed-process (aka Cloud Haskell)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-transport-composed" = callPackage @@ -175686,6 +184424,8 @@ self: { ]; description = "In-memory instantiation of Network.Transport"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-transport-tcp" = callPackage @@ -175812,6 +184552,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "FromJSON and ToJSON Instances for Network.URI"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-uri-lenses" = callPackage @@ -175851,6 +184593,8 @@ self: { ]; description = "VoiceText Web API wrapper"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-wai-router" = callPackage @@ -175862,6 +184606,8 @@ self: { libraryHaskellDepends = [ base wai ]; description = "A routing library for wai"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-websocket" = callPackage @@ -175875,6 +184621,7 @@ self: { libraryHaskellDepends = [ base haskell98 network webserver ]; description = "WebSocket library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "networked-game" = callPackage @@ -175892,6 +184639,8 @@ self: { ]; description = "Networked-game support library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neural" = callPackage @@ -175924,6 +184673,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Neural Networks in native Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neural-network-base" = callPackage @@ -175954,6 +184705,8 @@ self: { ]; description = "Yet Another High Performance and Extendable Neural Network in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "neural-network-hmatrix" = callPackage @@ -175971,6 +184724,8 @@ self: { librarySystemDepends = [ blas ]; description = "Yet Another High Performance and Extendable Neural Network in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) blas;}; "neuron" = callPackage @@ -176072,6 +184827,8 @@ self: { ]; description = "Library implementing the NewHope cryptographic key-exchange protocol"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "newports" = callPackage @@ -176085,6 +184842,8 @@ self: { executableHaskellDepends = [ base directory old-time ]; description = "List ports newer than N days on a FreeBSD system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "newsletter" = callPackage @@ -176113,6 +184872,8 @@ self: { ]; description = "A basic newsletter implimentation, using various backends"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "newsletter-mailgun" = callPackage @@ -176128,6 +184889,7 @@ self: { ]; description = "A mailgun backend for the newsletter package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "newsynth" = callPackage @@ -176165,6 +184927,8 @@ self: { executableHaskellDepends = [ base cmdargs containers mtl ]; description = "A trivially simple app to create things from simple templates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "newtype" = callPackage @@ -176194,6 +184958,8 @@ self: { ]; description = "Instance derivers for newtype wrappers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "newtype-generics" = callPackage @@ -176226,6 +184992,8 @@ self: { ]; description = "A template haskell deriver to create Control.Newtype instances."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "newtype-zoo" = callPackage @@ -176265,6 +185033,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "A concurrency primitive for a slow consumer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nextstep-plist" = callPackage @@ -176276,6 +185046,8 @@ self: { libraryHaskellDepends = [ base parsec pretty QuickCheck ]; description = "NextStep style plist parser and printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nf" = callPackage @@ -176302,6 +185074,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "libnfc bindings"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {nfc = null;}; "ngram" = callPackage @@ -176341,6 +185115,7 @@ self: { executableHaskellDepends = [ base parseargs ]; description = "Ngrams loader based on http://www.ngrams.info format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ngx-export" = callPackage @@ -176394,6 +185169,7 @@ self: { ]; description = "More extra tools for Nginx haskell module"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "niagra" = callPackage @@ -176410,6 +185186,8 @@ self: { testHaskellDepends = [ base HUnit QuickCheck ]; description = "High performance CSS EDSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nibblestring" = callPackage @@ -176430,6 +185208,8 @@ self: { ]; description = "Packed, strict nibble arrays with a list interface (ByteString for nibbles)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nice-html" = callPackage @@ -176453,6 +185233,8 @@ self: { ]; description = "A fast and nice HTML templating library with distinct compilation/rendering phases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nicify" = callPackage @@ -176499,6 +185281,8 @@ self: { executableHaskellDepends = [ base ]; description = "Nico Nico Douga (ニコニコ動画) Comment Translator"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nikepub" = callPackage @@ -176519,6 +185303,7 @@ self: { ]; description = "Command line utility publishes Nike+ runs on blogs and Twitter"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "nimber" = callPackage @@ -176568,6 +185353,7 @@ self: { ]; description = "IDL compiler and RPC/distributed object framework for microservices"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "nist-beacon" = callPackage @@ -176592,6 +185378,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Haskell bindings for Nitro"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "niv" = callPackage @@ -176647,6 +185435,8 @@ self: { executableHaskellDepends = [ base ]; description = "Convenient utility for distributed Nix builds"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nix-deploy" = callPackage @@ -176665,6 +185455,8 @@ self: { ]; description = "Deploy Nix-built software to a NixOS machine"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nix-derivation" = callPackage @@ -176723,6 +185515,8 @@ self: { testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; description = "Evaluate Haskell expressions using Nix to get packages"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nix-freeze-tree" = callPackage @@ -176752,6 +185546,8 @@ self: { doHaddock = false; description = "Convert a tree of files into fixed-output derivations"; license = lib.licenses.agpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nix-narinfo" = callPackage @@ -176936,6 +185732,8 @@ self: { ]; description = "Generate nix expressions from npm packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nixos-types" = callPackage @@ -176971,6 +185769,8 @@ self: { ]; description = "Tool for semi-automatic updating of nixpkgs repository"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nkjp" = callPackage @@ -176989,6 +185789,8 @@ self: { ]; description = "Manipulating the National Corpus of Polish (NKJP)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nlopt-haskell" = callPackage @@ -177013,6 +185815,8 @@ self: { libraryHaskellDepends = [ base containers strict ]; description = "Scoring functions commonly used for evaluation in NLP and IR"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nlp-scores-scripts" = callPackage @@ -177028,6 +185832,7 @@ self: { ]; description = "NLP scoring command-line programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nm" = callPackage @@ -177044,6 +185849,8 @@ self: { executableHaskellDepends = [ base ]; description = "Network Manager, binding to libnm-glib"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {g = null; inherit (pkgs) glib; libnm-glib = null; nm-glib = null;}; @@ -177100,6 +185907,8 @@ self: { ]; description = "Library to connect to an NNTP Server"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "no-buffering-workaround" = callPackage @@ -177123,6 +185932,8 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Role annotations without -XRoleAnnotations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "no-value" = callPackage @@ -177156,6 +185967,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Math in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nofib-analyse" = callPackage @@ -177169,6 +185982,8 @@ self: { executableHaskellDepends = [ array base containers regex-compat ]; description = "Parse and compare nofib runs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nofib-analyze" = callPackage @@ -177182,6 +185997,8 @@ self: { executableHaskellDepends = [ array base containers regex-compat ]; description = "Parse and compare nofib runs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "noise" = callPackage @@ -177205,6 +186022,8 @@ self: { ]; description = "A friendly language for graphic design"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "noli" = callPackage @@ -177245,6 +186064,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Name-binding & alpha-equivalence"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nominal" = callPackage @@ -177457,6 +186278,8 @@ self: { testHaskellDepends = [ base checkers QuickCheck ]; description = "The Zipper for NonEmpty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "non-negative" = callPackage @@ -177545,6 +186368,8 @@ self: { testHaskellDepends = [ base hedgehog hedgehog-classes ]; description = "nonempty structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nonempty-vector" = callPackage @@ -177757,6 +186582,8 @@ self: { ]; description = "examples for not-gloss"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "not-in-base" = callPackage @@ -177781,6 +186608,8 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Avoiding the C preprocessor via cunning use of Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nothunks" = callPackage @@ -177826,6 +186655,8 @@ self: { transformers tuple ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "notmuch" = callPackage @@ -177863,6 +186694,7 @@ self: { executableSystemDepends = [ notmuch ]; description = "Binding for notmuch MUA library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) notmuch;}; "notmuch-web" = callPackage @@ -177900,6 +186732,7 @@ self: { ]; description = "A web interface to the notmuch email indexer"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "notzero" = callPackage @@ -177953,6 +186786,8 @@ self: { ]; description = "Zeit Now haskell-side integration and introspection tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nowdoc" = callPackage @@ -177980,6 +186815,8 @@ self: { libraryHaskellDepends = [ base containers numeric-prelude primes ]; description = "NumericPrelude extras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "np-linear" = callPackage @@ -177995,6 +186832,8 @@ self: { ]; description = "Linear algebra for the numeric-prelude framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nptools" = callPackage @@ -178013,6 +186852,8 @@ self: { ]; description = "A collection of random tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nqe" = callPackage @@ -178179,6 +187020,8 @@ self: { ]; description = "Client library for NTP control messaging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ntrip-client" = callPackage @@ -178203,6 +187046,8 @@ self: { ]; description = "NTRIP client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ntype" = callPackage @@ -178243,6 +187088,8 @@ self: { ]; description = "HTML5 Canvas Graphics Library - forked Blank Canvas"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nullary" = callPackage @@ -178254,6 +187101,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A package for working with nullary type classes"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nullpipe" = callPackage @@ -178266,6 +187115,8 @@ self: { testHaskellDepends = [ base hspec pipes ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "num-non-negative" = callPackage @@ -178333,6 +187184,8 @@ self: { libraryHaskellDepends = [ base call-stack semigroups ]; description = "A sequence of semigroups, for composing stuff in multiple spatial directions"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numbering" = callPackage @@ -178381,6 +187234,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Convert numbers to number words"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numerals-base" = callPackage @@ -178402,6 +187257,8 @@ self: { ]; description = "Convert numbers to number words"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numeric-domains" = callPackage @@ -178463,6 +187320,7 @@ self: { ]; description = "Ode solvers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "numeric-prelude" = callPackage @@ -178503,6 +187361,8 @@ self: { doCheck = false; description = "Quasi-quoters for numbers of different bases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numeric-quest" = callPackage @@ -178529,6 +187389,8 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck ]; description = "A framework for numeric ranges"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numeric-tools" = callPackage @@ -178562,6 +187424,7 @@ self: { ]; description = "core package for Numerical Haskell project"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "numericpeano" = callPackage @@ -178621,6 +187484,8 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Multi-dimensional array interface for numhask"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numhask-free" = callPackage @@ -178637,6 +187502,8 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "numerical free algebras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numhask-hedgehog" = callPackage @@ -178653,6 +187520,7 @@ self: { testHaskellDepends = [ base hedgehog numhask numhask-prelude ]; description = "Laws and tests for numhask"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "numhask-histogram" = callPackage @@ -178669,6 +187537,7 @@ self: { testHaskellDepends = [ base doctest ]; description = "See readme.md"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "numhask-prelude" = callPackage @@ -178681,6 +187550,8 @@ self: { testHaskellDepends = [ doctest ]; description = "A numeric prelude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numhask-range" = callPackage @@ -178701,6 +187572,7 @@ self: { ]; description = "Numbers that are range representations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "numhask-space" = callPackage @@ -178719,6 +187591,8 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Numerical spaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numhask-test" = callPackage @@ -178735,6 +187609,7 @@ self: { testHaskellDepends = [ base numhask-prelude QuickCheck tasty ]; description = "Laws and tests for numhask"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nums" = callPackage @@ -178952,6 +187827,8 @@ self: { ]; description = "Client for the Nylas API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nymphaea" = callPackage @@ -178970,6 +187847,7 @@ self: { ]; description = "An interactive GUI for manipulating L-systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "nyx-game" = callPackage @@ -178996,6 +187874,8 @@ self: { ]; description = "A bullet-hell game made with SDL2"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "o-clock" = callPackage @@ -179043,6 +187923,8 @@ self: { ]; description = "Client to the OANDA REST API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oasis-xrd" = callPackage @@ -179065,6 +187947,8 @@ self: { ]; description = "Extensible Resource Descriptor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oauth10a" = callPackage @@ -179109,6 +187993,8 @@ self: { ]; description = "OAuth2 jwt-bearer client flow as per rfc7523"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oauthenticated" = callPackage @@ -179134,6 +188020,8 @@ self: { ]; description = "Simple OAuth for http-client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "obd" = callPackage @@ -179158,6 +188046,7 @@ self: { testHaskellDepends = [ base ]; description = "Communicate to OBD interfaces over ELM327"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "obdd" = callPackage @@ -179174,6 +188063,7 @@ self: { testHaskellDepends = [ array base containers text ]; description = "Ordered Reduced Binary Decision Diagrams"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "oberon0" = callPackage @@ -179193,6 +188083,7 @@ self: { doHaddock = false; description = "Oberon0 Compiler"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "obj" = callPackage @@ -179212,6 +188103,7 @@ self: { ]; description = "Reads and writes obj models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "objectid" = callPackage @@ -179232,6 +188124,7 @@ self: { ]; description = "Rather unique identifier for things that need to be stored"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "objective" = callPackage @@ -179250,6 +188143,8 @@ self: { ]; description = "Composable objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oblivious-transfer" = callPackage @@ -179273,6 +188168,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "An implementation of the Oblivious Transfer protocol in Haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "observable" = callPackage @@ -179322,6 +188219,8 @@ self: { ]; description = "Convert Haskell types in OCaml types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ocap-io" = callPackage @@ -179352,6 +188251,7 @@ self: { ]; description = "Owned channels in the Ownership Monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ochintin-daicho" = callPackage @@ -179392,6 +188292,7 @@ self: { ]; description = "Parse Rocket League replays"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "octohat" = callPackage @@ -179422,6 +188323,7 @@ self: { ]; description = "A tested, minimal wrapper around GitHub's API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "octopus" = callPackage @@ -179442,6 +188344,7 @@ self: { ]; description = "Lisp with more dynamism, more power, more simplicity"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "oculus" = callPackage @@ -179461,6 +188364,7 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libGL; inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXinerama; ovr = null; inherit (pkgs) systemd;}; @@ -179491,6 +188395,8 @@ self: { benchmarkHaskellDepends = [ async base text weigh ]; description = "Haskell binding to the ODBC API, aimed at SQL Server driver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) unixODBC;}; "odd-jobs" = callPackage @@ -179542,6 +188448,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "A full-featured PostgreSQL-backed job queue (with an admin UI)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "oden-go-packages" = callPackage @@ -179557,6 +188464,8 @@ self: { ]; description = "Provides Go package metadata"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "odpic-raw" = callPackage @@ -179613,6 +188522,8 @@ self: { ]; description = "Interface for Online Encyclopedia of Integer Sequences (OEIS)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "off-simple" = callPackage @@ -179624,6 +188535,7 @@ self: { libraryHaskellDepends = [ base parsec3 vector ]; description = "A parser for simplified-syntax OFF files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ofx" = callPackage @@ -179654,6 +188566,8 @@ self: { ]; description = "A lightweight markup language for story writers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ohloh-hs" = callPackage @@ -179677,6 +188591,7 @@ self: { ]; description = "Interface to the Ohloh API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "oi" = callPackage @@ -179693,6 +188608,8 @@ self: { executableHaskellDepends = [ base directory filepath parallel ]; description = "Library for purely functional lazy interactions with the outer world"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oidc-client" = callPackage @@ -179718,6 +188635,8 @@ self: { ]; description = "OpenID Connect 1.0 library for RP"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ois-input-manager" = callPackage @@ -179730,6 +188649,7 @@ self: { librarySystemDepends = [ OIS ]; description = "wrapper for OIS input manager for use with hogre"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {OIS = null;}; "old-locale" = callPackage @@ -179793,6 +188713,7 @@ self: { ]; description = "An OpenLayers JavaScript Wrapper and Webframework with snaplet-fay"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "om-actor" = callPackage @@ -179804,6 +188725,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Actor pattern utilities"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "om-doh" = callPackage @@ -179820,6 +188743,8 @@ self: { ]; description = "om-doh"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "om-elm" = callPackage @@ -179837,6 +188762,8 @@ self: { ]; description = "Haskell utilities for building embedded Elm programs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "om-fail" = callPackage @@ -179851,6 +188778,8 @@ self: { ]; description = "Monad transformer providing MonadFail"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "om-http-logging" = callPackage @@ -179866,6 +188795,8 @@ self: { ]; description = "om-http-logging"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "omaketex" = callPackage @@ -179883,6 +188814,8 @@ self: { ]; description = "A simple tool to generate OMakefile for latex files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ombra" = callPackage @@ -179902,6 +188835,8 @@ self: { ]; description = "Render engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "omega" = callPackage @@ -179920,6 +188855,8 @@ self: { ]; description = "A purely functional programming language and a proof system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "omnicodec" = callPackage @@ -179965,6 +188902,8 @@ self: { ]; description = "A pretty-printer wrapper to faciliate ease of formatting during development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "on-a-horse" = callPackage @@ -179983,6 +188922,8 @@ self: { ]; description = "\"Haskell on a Horse\" - A combinatorial web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "on-demand-ssh-tunnel" = callPackage @@ -180003,6 +188944,8 @@ self: { ]; description = "Program that sends traffic through SSH tunnels on-demand"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "onama" = callPackage @@ -180014,6 +188957,8 @@ self: { libraryHaskellDepends = [ base containers parsec tagsoup ]; description = "HTML-parsing primitives for Parsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "once" = callPackage @@ -180134,6 +189079,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A never-empty list type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "online" = callPackage @@ -180154,6 +189101,7 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "See readme.md"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "online-csv" = callPackage @@ -180172,6 +189120,7 @@ self: { testHaskellDepends = [ base doctest numhask-prelude ]; description = "See readme.md"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "only" = callPackage @@ -180196,6 +189145,8 @@ self: { libraryHaskellDepends = [ base ]; description = "partition lenses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "onu-course" = callPackage @@ -180207,6 +189158,8 @@ self: { libraryHaskellDepends = [ base smallcheck ]; description = "Code for the Haskell course taught at the Odessa National University in 2012"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oo-prototypes" = callPackage @@ -180230,6 +189183,8 @@ self: { testHaskellDepends = [ base containers doctest ]; description = "Common operators encouraging large-scale easy reading"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opaleye" = callPackage @@ -180278,6 +189233,8 @@ self: { ]; description = "Opaleye wrapped up in classy MTL attire"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opaleye-sqlite" = callPackage @@ -180302,6 +189259,8 @@ self: { ]; description = "An SQL-generating DSL targeting SQLite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opaleye-trans" = callPackage @@ -180338,6 +189297,8 @@ self: { ]; description = "Open algebraic data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "open-adt-tutorial" = callPackage @@ -180357,6 +189318,7 @@ self: { executableHaskellDepends = [ base ]; description = "Open algebraic data type examples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "open-browser" = callPackage @@ -180384,6 +189346,8 @@ self: { executableHaskellDepends = [ base basic-prelude text turtle ]; description = "Open haddock HTML documentation"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "open-pandoc" = callPackage @@ -180406,6 +189370,8 @@ self: { ]; description = "Conversion between markup formats"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "open-signals" = callPackage @@ -180418,6 +189384,8 @@ self: { testHaskellDepends = [ base ]; description = "A mechanism similar to checked exceptions that integrates with MTL and transformer stacks"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "open-symbology" = callPackage @@ -180459,6 +189427,7 @@ self: { executableHaskellDepends = [ base type-fun ]; description = "Extensible, type-safe unions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "open-witness" = callPackage @@ -180499,6 +189468,8 @@ self: { ]; description = "Unofficial OpenAI client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "openai-servant" = callPackage @@ -180542,6 +189513,8 @@ self: { ]; description = "Auto-generated openapi-petstore API Client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "openapi-typed" = callPackage @@ -180561,6 +189534,8 @@ self: { ]; description = "Types for OpenAPI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "openapi3" = callPackage @@ -180632,6 +189607,8 @@ self: { ]; description = "OpenAPI3 Haskell Client Code Generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opench-meteo" = callPackage @@ -180643,6 +189620,8 @@ self: { libraryHaskellDepends = [ aeson base data-default text time ]; description = "A Haskell implementation of the Swiss Meteo Net data API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opencog-atomspace" = callPackage @@ -180723,6 +189702,8 @@ self: { libraryPkgconfigDepends = [ opencv ]; description = "Raw Haskell bindings to OpenCV >= 2.0"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) opencv;}; "opendatatable" = callPackage @@ -180734,6 +189715,8 @@ self: { libraryHaskellDepends = [ base hxt template-haskell th-lift ]; description = "A library for working with Open Data Tables"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "openexchangerates" = callPackage @@ -180840,6 +189823,8 @@ self: { testHaskellDepends = [ base ]; description = "Functional interface for OpenGL 4.1+ and OpenGL ES 2.0+"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {EGL = null; GLESv2 = null;}; "openid" = callPackage @@ -180883,6 +189868,8 @@ self: { ]; description = "An OpenID Connect library that does all the heavy lifting for you"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "openpgp" = callPackage @@ -180990,6 +189977,8 @@ self: { ]; description = "Haskell OpenSoundControl utilities"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opensource" = callPackage @@ -181031,6 +190020,7 @@ self: { ]; description = "Fetch OpenSSH keys from a GitHub team"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "openssh-protocol" = callPackage @@ -181047,6 +190037,8 @@ self: { testHaskellDepends = [ base cereal hedgehog time ]; description = "Haskell implementation of openssh protocol primitives"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "openssl-createkey" = callPackage @@ -181140,6 +190132,8 @@ self: { base http-client http-types opentelemetry text ]; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opentelemetry-lightstep" = callPackage @@ -181246,6 +190240,8 @@ self: { ]; description = "Unicode characters"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opentheory-divides" = callPackage @@ -181411,6 +190407,8 @@ self: { ]; description = "An OpenTok SDK for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opentracing" = callPackage @@ -181463,6 +190461,7 @@ self: { ]; description = "Jaeger backend for OpenTracing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentracing-wai" = callPackage @@ -181504,6 +190503,7 @@ self: { ]; description = "Zipkin V1 backend for OpenTracing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentracing-zipkin-v2" = callPackage @@ -181538,6 +190538,8 @@ self: { ]; description = "Opentype loading and writing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "openweathermap" = callPackage @@ -181576,6 +190578,8 @@ self: { testHaskellDepends = [ base doctest filemanip hspec QuickCheck ]; description = "Simple project template from stack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "operational" = callPackage @@ -181628,6 +190632,8 @@ self: { ]; description = "Interpretation functions and simple instruction sets for operational"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oplang" = callPackage @@ -181646,6 +190652,8 @@ self: { ]; description = "Compiler for OpLang, an esoteric programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opml" = callPackage @@ -181703,6 +190711,8 @@ self: { ]; description = "Open files or URLs using associated programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "optics" = callPackage @@ -181901,6 +190911,8 @@ self: { testHaskellDepends = [ attoparsec-data rerebase ]; description = "Simple command line interface arguments parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "optima-for-hasql" = callPackage @@ -181916,6 +190928,7 @@ self: { ]; description = "Command-line arguments parsing for Hasql"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "optimal-blocks" = callPackage @@ -181940,6 +190953,7 @@ self: { ]; description = "Optimal Block boundary determination for rsync-like behaviours"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "optimization" = callPackage @@ -181955,6 +190969,8 @@ self: { ]; description = "Numerical optimization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "optimusprime" = callPackage @@ -181973,6 +190989,7 @@ self: { ]; description = "A supercompiler for f-lite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "option" = callPackage @@ -181998,6 +191015,8 @@ self: { ]; description = "Using type-classes for optional function arguments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "optional-args" = callPackage @@ -182039,6 +191058,8 @@ self: { testHaskellDepends = [ base chell options time ]; description = "Command-line option types for dates and times"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "optparse-applicative_0_15_1_0" = callPackage @@ -182090,6 +191111,8 @@ self: { testHaskellDepends = [ attoparsec-data rerebase ]; description = "Simple command line interface arguments parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "optparse-declarative" = callPackage @@ -182146,6 +191169,8 @@ self: { libraryHaskellDepends = [ base optparse-applicative ]; description = "Helper functions for optparse-applicative"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "optparse-simple" = callPackage @@ -182224,6 +191249,8 @@ self: { ]; description = "Orchestration-style co-ordination EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "orchestrate" = callPackage @@ -182247,6 +191274,8 @@ self: { ]; description = "An API client for http://orchestrate.io/."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "orchid" = callPackage @@ -182267,6 +191296,7 @@ self: { ]; description = "Haskell Wiki Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "orchid-demo" = callPackage @@ -182286,6 +191316,7 @@ self: { ]; description = "Haskell Wiki Demo"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ord-adhoc" = callPackage @@ -182313,6 +191344,7 @@ self: { ]; description = "Algorithms for the order maintenance problem with a safe interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "order-statistic-tree" = callPackage @@ -182345,6 +191377,8 @@ self: { ]; description = "L-Estimators for robust statistics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ordered" = callPackage @@ -182411,6 +191445,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Convert numbers to words in different languages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ordrea" = callPackage @@ -182425,6 +191461,8 @@ self: { testHaskellDepends = [ base directory process split ]; description = "Push-pull implementation of discrete-time FRP"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oref" = callPackage @@ -182439,6 +191477,8 @@ self: { testHaskellDepends = [ base containers either mtl transformers ]; description = "Owned references in the Ownership Monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "org-mode" = callPackage @@ -182456,6 +191496,8 @@ self: { testHaskellDepends = [ base megaparsec tasty tasty-hunit text ]; description = "Parser for Emacs org-mode files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "org-mode-lucid" = callPackage @@ -182470,6 +191512,7 @@ self: { ]; description = "Lucid integration for org-mode"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "org2anki" = callPackage @@ -182496,6 +191539,8 @@ self: { executableHaskellDepends = [ attoparsec base text ]; description = "Organize scala imports"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "orgmode" = callPackage @@ -182515,6 +191560,8 @@ self: { ]; description = "Org Mode library for haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "orgmode-parse" = callPackage @@ -182589,6 +191636,8 @@ self: { ]; description = "An un-SYB framework for transforming heterogenous data through folds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "orion-hs" = callPackage @@ -182629,6 +191678,8 @@ self: { testHaskellDepends = [ base hspec jwt mtl time ]; description = "Token-based authentication and authorization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ormolu" = callPackage @@ -182767,6 +191818,8 @@ self: { ]; description = "A library to handle messages in the OSC protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "oscpacking" = callPackage @@ -182778,6 +191831,8 @@ self: { libraryHaskellDepends = [ base colour gloss random ]; description = "Implements an osculatory packing (kissing circles) algorithm and display"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "osdkeys" = callPackage @@ -182813,6 +191868,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "An insertion-order-preserving set"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "osm-conduit" = callPackage @@ -182832,6 +191889,8 @@ self: { ]; description = "Parse and operate on OSM data in efficient way"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "osm-download" = callPackage @@ -182853,6 +191912,7 @@ self: { ]; description = "Download Open Street Map tiles"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "oso2pdf" = callPackage @@ -182871,6 +191931,8 @@ self: { ]; description = "Better conversion of Oxford Scholarship Online material to PDF"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "osx-ar" = callPackage @@ -182883,6 +191945,8 @@ self: { libraryHaskellDepends = [ base binary bytestring containers ]; description = "Parser for OS X static archive format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ot" = callPackage @@ -182903,6 +191967,8 @@ self: { ]; description = "Real-time collaborative editing with Operational Transformation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "otp-authenticator" = callPackage @@ -182928,6 +191994,7 @@ self: { ]; description = "OTP Authenticator (a la google) command line client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ottparse-pretty" = callPackage @@ -182945,6 +192012,8 @@ self: { ]; description = "Pretty-printer for Ott parse trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "outsort" = callPackage @@ -183024,6 +192093,8 @@ self: { doHaddock = false; description = "Overloaded pragmas as a plugin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "overloaded-records" = callPackage @@ -183045,6 +192116,8 @@ self: { ]; description = "Overloaded Records based on current GHC proposal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "overture" = callPackage @@ -183058,6 +192131,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "An alternative to some of the Prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pack" = callPackage @@ -183073,6 +192148,8 @@ self: { ]; description = "Bidirectional fast ByteString packer/unpacker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "package-description-remote" = callPackage @@ -183087,6 +192164,8 @@ self: { testHaskellDepends = [ base ]; description = "Fetches a 'GenericPackageDescription' from Hackage"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "package-o-tron" = callPackage @@ -183105,6 +192184,8 @@ self: { ]; description = "Utilities for working with cabal packages and your package database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "package-vt" = callPackage @@ -183120,6 +192201,8 @@ self: { ]; description = "Haskell Package Versioning Tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "packcheck" = callPackage @@ -183173,6 +192256,8 @@ self: { ]; benchmarkHaskellDepends = [ base gauge ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "packed-dawg" = callPackage @@ -183200,6 +192285,8 @@ self: { ]; description = "Generation and traversal of highly compressed directed acyclic word graphs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "packed-multikey-map" = callPackage @@ -183218,6 +192305,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ]; description = "Efficient “spreadsheet table” like maps with multiple marginals"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "packedstring" = callPackage @@ -183231,6 +192320,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "(Deprecated) Packed Strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "packer" = callPackage @@ -183265,6 +192356,8 @@ self: { ]; description = "MessagePack Serialization an Deserialization for Packer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "packman" = callPackage @@ -183284,6 +192377,8 @@ self: { ]; description = "Serialization library for GHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "packunused" = callPackage @@ -183304,6 +192399,8 @@ self: { ]; description = "Tool for detecting redundant Cabal package dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pacman-memcache" = callPackage @@ -183317,6 +192414,8 @@ self: { executableHaskellDepends = [ base deepseq directory-tree ]; description = "Read whole Pacman database which pushes it into the memory cache"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pact-time" = callPackage @@ -183350,6 +192449,7 @@ self: { ]; description = "Controlling padKONTROL native mode"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "paddle" = callPackage @@ -183395,6 +192495,8 @@ self: { ]; description = "PADS data description language for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pagarme" = callPackage @@ -183413,6 +192515,8 @@ self: { executableHaskellDepends = [ base text wreq ]; description = "Pagarme API wrapper"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pager" = callPackage @@ -183503,6 +192607,8 @@ self: { ]; description = "Receive hooks from pagure and do things with them"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "paint" = callPackage @@ -183544,6 +192650,7 @@ self: { ]; description = "Bilinear pairings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "palette" = callPackage @@ -183559,6 +192666,8 @@ self: { ]; description = "Utilities for choosing and creating color schemes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "palindromes" = callPackage @@ -183607,6 +192716,7 @@ self: { benchmarkHaskellDepends = [ base byteslice gauge primitive ]; description = "Parse syslog traffic from PAN-OS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "panda" = callPackage @@ -183627,6 +192737,7 @@ self: { ]; description = "A simple static blog engine"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "pandoc" = callPackage @@ -183720,6 +192831,8 @@ self: { doCheck = false; description = "Supports using pandoc with citeproc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-citeproc-preamble" = callPackage @@ -183845,6 +192958,8 @@ self: { ]; description = "A Pandoc filter to use graphviz"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-filter-indent" = callPackage @@ -183875,6 +192990,8 @@ self: { ]; description = "Pandoc filter formatting Haskell code fragments using GHC lexer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-highlighting-extensions" = callPackage @@ -183911,6 +193028,8 @@ self: { doHaddock = false; description = "Include other Markdown files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-include-code" = callPackage @@ -183954,6 +193073,7 @@ self: { ]; description = "Japanese-specific markup filters for pandoc"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "pandoc-lens" = callPackage @@ -183965,6 +193085,8 @@ self: { libraryHaskellDepends = [ base containers lens pandoc-types text ]; description = "Lenses for Pandoc documents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-link-context" = callPackage @@ -184003,6 +193125,8 @@ self: { ]; description = "Pandoc-filter to evaluate `code` section in markdown and auto-embed output"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-placetable" = callPackage @@ -184024,6 +193148,8 @@ self: { ]; description = "Pandoc filter to include CSV files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-plantuml-diagrams" = callPackage @@ -184111,6 +193237,8 @@ self: { ]; description = "A Pandoc filter to include figures generated from Python code blocks"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-sidenote" = callPackage @@ -184189,6 +193317,8 @@ self: { executableHaskellDepends = [ base pandoc ]; description = "Literate Haskell support for GitHub's Markdown flavor"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-utils" = callPackage @@ -184206,6 +193336,8 @@ self: { ]; description = "Utility functions to work with Pandoc in Haskell applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-vimhl" = callPackage @@ -184253,6 +193385,8 @@ self: { ]; description = "A super-pang clone"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pango" = callPackage @@ -184289,6 +193423,8 @@ self: { testHaskellDepends = [ base bytestring containers HUnit ]; description = "A set of parsers for graph languages and conversions to graph libaries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "panhandle" = callPackage @@ -184344,6 +193480,8 @@ self: { ]; description = "Pandoc filter to execute code blocks"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pansite" = callPackage @@ -184372,6 +193510,8 @@ self: { testHaskellDepends = [ base doctest Glob hspec QuickCheck ]; description = "Pansite: a simple web site management tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pantry" = callPackage @@ -184467,6 +193607,8 @@ self: { ]; description = "Content addressable Haskell package management"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa" = callPackage @@ -184490,6 +193632,7 @@ self: { ]; description = "Reasonable default import"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "papa-base" = callPackage @@ -184503,6 +193646,7 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "papa-base-export" = callPackage @@ -184514,6 +193658,8 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-base-implement" = callPackage @@ -184525,6 +193671,7 @@ self: { libraryHaskellDepends = [ base papa-base-export semigroups ]; description = "Useful base functions reimplemented"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "papa-bifunctors" = callPackage @@ -184584,6 +193731,7 @@ self: { ]; description = "Reasonable default import"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "papa-implement" = callPackage @@ -184605,6 +193753,7 @@ self: { ]; description = "Reasonable default import"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "papa-include" = callPackage @@ -184621,6 +193770,8 @@ self: { ]; description = "Third party libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-lens" = callPackage @@ -184672,6 +193823,8 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-prelude-core" = callPackage @@ -184688,6 +193841,8 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-prelude-lens" = callPackage @@ -184704,6 +193859,8 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-prelude-semigroupoids" = callPackage @@ -184720,6 +193877,8 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-prelude-semigroups" = callPackage @@ -184736,6 +193895,8 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-semigroupoids" = callPackage @@ -184751,6 +193912,7 @@ self: { ]; description = "Prelude with only useful functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "papa-semigroupoids-export" = callPackage @@ -184773,6 +193935,8 @@ self: { libraryHaskellDepends = [ base semigroupoids semigroups ]; description = "useful `semigroupoids` functions reimplemented"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papa-x" = callPackage @@ -184819,6 +193983,8 @@ self: { executableHaskellDepends = [ base bytestring containers ]; description = "A passphrase generator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "papillon" = callPackage @@ -184839,6 +194005,8 @@ self: { ]; description = "packrat parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pappy" = callPackage @@ -184852,6 +194020,8 @@ self: { executableHaskellDepends = [ base ]; description = "Packrat parsing; linear-time parsers for grammars in TDPL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "paprika" = callPackage @@ -184874,6 +194044,7 @@ self: { ]; description = "The Haskell library and examples for the kids programming robot paprika"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "par-dual" = callPackage @@ -184890,6 +194061,8 @@ self: { ]; description = "ParDual class for Parallel <-> Sequential"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "par-traverse" = callPackage @@ -184939,6 +194112,8 @@ self: { executableToolDepends = [ alex ]; description = "Paragon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parallel" = callPackage @@ -184984,6 +194159,8 @@ self: { transformers vector vector-algorithms ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parallel-tree-search" = callPackage @@ -185083,6 +194260,8 @@ self: { testHaskellDepends = [ base ]; description = "http proxy server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parco" = callPackage @@ -185094,6 +194273,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Generalised parser combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parco-attoparsec" = callPackage @@ -185105,6 +194286,7 @@ self: { libraryHaskellDepends = [ attoparsec base mtl parco ]; description = "Generalised parser combinators - Attoparsec interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "parco-parsec" = callPackage @@ -185116,6 +194298,7 @@ self: { libraryHaskellDepends = [ base mtl parco parsec ]; description = "Generalised parser combinators - Parsec interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "parcom-lib" = callPackage @@ -185131,6 +194314,8 @@ self: { ]; description = "A simple parser-combinator library, a bit like Parsec but without the frills"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parconc-examples" = callPackage @@ -185159,6 +194344,7 @@ self: { executableToolDepends = [ alex happy ]; description = "Examples to accompany the book \"Parallel and Concurrent Programming in Haskell\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pareto" = callPackage @@ -185170,6 +194356,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for cause-effect relationships"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "paripari" = callPackage @@ -185252,6 +194440,7 @@ self: { ]; description = "Streaming Parquet reader"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "parse-dimacs" = callPackage @@ -185299,6 +194488,7 @@ self: { testHaskellDepends = [ cmdargs ]; description = "generate command line arguments from a --help output"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "parseargs" = callPackage @@ -185314,6 +194504,8 @@ self: { testHaskellDepends = [ base process ]; description = "Parse command-line arguments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsec_3_1_14_0" = callPackage @@ -185370,6 +194562,8 @@ self: { ]; description = "Parsec API encoded as a deeply-embedded DSL, for debugging and analysis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsec-numbers" = callPackage @@ -185413,6 +194607,8 @@ self: { testHaskellDepends = [ base directory doctest filepath ]; description = "Parsing instances for Parsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsec-permutation" = callPackage @@ -185439,6 +194635,8 @@ self: { executableHaskellDepends = [ base containers mtl parsec pretty ]; description = "Pratt Parser combinator for Parsec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsec-tagsoup" = callPackage @@ -185494,6 +194692,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Monadic parser combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsec3" = callPackage @@ -185505,6 +194705,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl text ]; description = "Monadic parser combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsec3-numbers" = callPackage @@ -185539,6 +194741,8 @@ self: { testHaskellDepends = [ base hspec parsec ]; description = "Adds and Eq instance for Parsec's ParseError if needed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsek" = callPackage @@ -185560,6 +194764,8 @@ self: { sha256 = "16sg32qs1kq184wk6d83z20b9firh1kjmysqwd2aqaiyq37zjyyb"; libraryHaskellDepends = [ base mtl parsec ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parser-combinators" = callPackage @@ -185605,6 +194811,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Test suite of parser-combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parser-combinators-tests_1_3_0" = callPackage @@ -185626,6 +194834,7 @@ self: { description = "Test suite of parser-combinators"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parser-helper" = callPackage @@ -185641,6 +194850,8 @@ self: { ]; description = "Prints Haskell parse trees in JSON"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parser241" = callPackage @@ -185655,6 +194866,8 @@ self: { testHaskellDepends = [ base containers hspec mtl ]; description = "An interface to create production rules using augmented grammars"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsergen" = callPackage @@ -185676,6 +194889,8 @@ self: { ]; description = "TH parser generator for splitting bytestring into fixed-width fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsers" = callPackage @@ -185716,6 +194931,8 @@ self: { ]; description = "`parsers` instances for Megaparsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsestar" = callPackage @@ -185739,6 +194956,7 @@ self: { ]; description = "NMR-STAR file format parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "parsimony" = callPackage @@ -185750,6 +194968,8 @@ self: { libraryHaskellDepends = [ base bytestring text ]; description = "Monadic parser combinators derived from Parsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsix" = callPackage @@ -185786,6 +195006,8 @@ self: { ]; description = "A fast, minimal parser"; license = "(BSD-2-Clause OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "partage" = callPackage @@ -185804,6 +195026,8 @@ self: { testHaskellDepends = [ base containers HUnit tasty tasty-hunit ]; description = "Parsing factorized"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "partial" = callPackage @@ -185852,6 +195076,7 @@ self: { ]; description = "Haskell 98 Partial Lenses"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "partial-order" = callPackage @@ -185880,6 +195105,8 @@ self: { libraryHaskellDepends = [ base template-haskell transformers ]; description = "Template haskell utilities for constructing records with default values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "partial-semigroup" = callPackage @@ -185949,6 +195176,8 @@ self: { ]; description = "Inspect, create, and alter MBRs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "passage" = callPackage @@ -185967,6 +195196,8 @@ self: { ]; description = "Parallel code generation for hierarchical Bayesian modeling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "passman" = callPackage @@ -185994,6 +195225,8 @@ self: { ]; description = "a simple password manager"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "passman-cli" = callPackage @@ -186118,6 +195351,8 @@ self: { libraryHaskellDepends = [ base containers MonadRandom random ]; description = "Password generation/validation library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pasta" = callPackage @@ -186134,6 +195369,8 @@ self: { testHaskellDepends = [ base hspec microlens protolude ]; description = "PostgreSQL Abstract Syntax Tree Assember"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pastis" = callPackage @@ -186145,6 +195382,8 @@ self: { libraryHaskellDepends = [ base HTTP network ]; description = "Interface to the past.is URL shortening service"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pasty" = callPackage @@ -186158,6 +195397,8 @@ self: { executableHaskellDepends = [ base bytestring mtl ]; description = "A simple command line pasting utility"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "patat" = callPackage @@ -186187,6 +195428,8 @@ self: { ]; description = "Terminal-based presentations using Pandoc"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "patch" = callPackage @@ -186263,6 +195506,8 @@ self: { ]; description = "Patches (diffs) on vectors: composable, mergeable, and invertible"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "path" = callPackage @@ -186461,6 +195706,8 @@ self: { ]; description = "A toy pathfinding library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pathological-bytestrings" = callPackage @@ -186562,6 +195809,8 @@ self: { executableHaskellDepends = [ base HandsomeSoup hxt ]; description = "A webpage scraper for Patreon which dumps a list of patrons to a text file"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pattern-arrows" = callPackage @@ -186625,6 +195874,7 @@ self: { ]; description = "Common patterns in message-oriented applications"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "pava" = callPackage @@ -186674,6 +195924,8 @@ self: { ]; description = "Client for a limited part of PayPal's Adaptive Payments API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "paypal-api" = callPackage @@ -186690,6 +195942,8 @@ self: { ]; description = "PayPal API, currently supporting \"ButtonManager\""; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "paypal-rest-client" = callPackage @@ -186706,6 +195960,8 @@ self: { ]; description = "A client to connect to PayPal's REST API (v1)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pb" = callPackage @@ -186721,6 +195977,8 @@ self: { ]; description = "pastebin command line application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pb-next" = callPackage @@ -186740,6 +195998,8 @@ self: { testHaskellDepends = [ base parsec tasty tasty-hunit ]; description = "Utility CLI for working with protobuf files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pbc4hs" = callPackage @@ -186751,6 +196011,8 @@ self: { libraryHaskellDepends = [ base hslua string-qq ]; description = "pbc for HsLua"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pbkdf" = callPackage @@ -186807,6 +196069,7 @@ self: { ]; description = "Convert a pcap into an enumerator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pcapng" = callPackage @@ -186836,6 +196099,7 @@ self: { text unliftio-core validity ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pcd-loader" = callPackage @@ -186860,6 +196124,8 @@ self: { ]; description = "PCD file loader"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pcf" = callPackage @@ -186877,6 +196143,7 @@ self: { ]; description = "A one file compiler for PCF"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pcf-font" = callPackage @@ -186891,6 +196158,8 @@ self: { ]; description = "PCF font parsing and rendering library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pcf-font-embed" = callPackage @@ -186906,6 +196175,7 @@ self: { ]; description = "Template Haskell for embedding text rendered using PCF fonts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pcg-random" = callPackage @@ -186992,6 +196262,8 @@ self: { libraryHaskellDepends = [ base bytestring pcre-light ]; description = "pcre-light extra functionality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pcre-utils" = callPackage @@ -187056,6 +196328,7 @@ self: { ]; description = "Tool to generate PDF from haskintex templates and YAML input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pdf-slave-server" = callPackage @@ -187106,6 +196379,8 @@ self: { ]; description = "Template format definition for pdf-slave tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pdf-toolbox-content" = callPackage @@ -187193,6 +196468,8 @@ self: { ]; description = "Simple pdf viewer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pdf2line" = callPackage @@ -187242,6 +196519,8 @@ self: { ]; description = "Name a PDF file using information from the pdfinfo command"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pdfsplit" = callPackage @@ -187257,6 +196536,8 @@ self: { ]; description = "split two-column PDFs, so there is one column per page"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pdftotext" = callPackage @@ -187278,6 +196559,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Extracts text from PDF using poppler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {poppler-cpp = null;}; "pdynload" = callPackage @@ -187294,6 +196577,8 @@ self: { ]; description = "pdynload is polymorphic dynamic linking library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "peakachu" = callPackage @@ -187309,6 +196594,7 @@ self: { ]; description = "Experiemental library for composable interactive programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "peano" = callPackage @@ -187358,6 +196644,7 @@ self: { ]; description = "pec embedded compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pecoff" = callPackage @@ -187370,6 +196657,8 @@ self: { libraryHaskellDepends = [ base binary bytestring containers ]; description = "Parser for PE/COFF format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pedersen-commitment" = callPackage @@ -187390,6 +196679,8 @@ self: { ]; description = "An implementation of Pedersen commitment schemes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pedestrian-dag" = callPackage @@ -187403,6 +196694,8 @@ self: { libraryHaskellDepends = [ array base binary containers ]; description = "A pedestrian implementation of directed acyclic graphs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "peg" = callPackage @@ -187420,6 +196713,8 @@ self: { ]; description = "a lazy non-deterministic concatenative programming language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "peggy" = callPackage @@ -187438,6 +196733,8 @@ self: { ]; description = "The Parser Generator for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pell" = callPackage @@ -187455,6 +196752,7 @@ self: { ]; description = "Package to solve the Generalized Pell Equation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pem" = callPackage @@ -187496,6 +196794,8 @@ self: { ]; description = "Static site generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "penn-treebank" = callPackage @@ -187527,6 +196827,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Parser combinators for trees in the Penn Treebank format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "penny" = callPackage @@ -187555,6 +196857,7 @@ self: { ]; description = "Extensible double-entry accounting system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "penny-bin" = callPackage @@ -187573,6 +196876,7 @@ self: { ]; description = "Deprecated - use penny package instead"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "penny-lib" = callPackage @@ -187594,6 +196898,7 @@ self: { ]; description = "Deprecated - use penny package instead"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "penrose" = callPackage @@ -187629,6 +196934,7 @@ self: { ]; description = "Create beautiful diagrams just by typing mathematical notation in plain text"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "peparser" = callPackage @@ -187640,6 +196946,7 @@ self: { libraryHaskellDepends = [ base binary bytestring haskell98 ]; description = "A parser for PE object files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "percent-encoder" = callPackage @@ -187659,6 +196966,8 @@ self: { ]; description = "Percent encode/decode ByteStrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "percent-format" = callPackage @@ -187682,6 +196991,8 @@ self: { libraryHaskellDepends = [ base ]; description = "The perceptron learning algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "perceptual-hash" = callPackage @@ -187755,6 +197066,8 @@ self: { ]; description = "Database migration support for use in other libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "perf" = callPackage @@ -187771,6 +197084,8 @@ self: { testHaskellDepends = [ base deepseq doctest rdtsc ]; description = "Low-level run time measurement"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "perf-analysis" = callPackage @@ -187793,6 +197108,7 @@ self: { ]; description = "analysis example using perf"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "perfect-hash-generator" = callPackage @@ -187871,6 +197187,7 @@ self: { ]; description = "A perfect hashing library for mapping bytestrings to values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "perhaps" = callPackage @@ -187888,6 +197205,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Perhaps, a monad"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "period" = callPackage @@ -187924,6 +197243,8 @@ self: { testHaskellDepends = [ base cereal hedis hspec text time ]; description = "A reliable at-least-once periodic job scheduler backed by redis"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "periodic-client" = callPackage @@ -187941,6 +197262,7 @@ self: { ]; description = "Periodic task system haskell client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "periodic-client-exe" = callPackage @@ -187965,6 +197287,7 @@ self: { ]; description = "Periodic task system haskell client executables"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "periodic-common" = callPackage @@ -187981,6 +197304,8 @@ self: { ]; description = "Periodic task system common"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "periodic-polynomials" = callPackage @@ -188021,6 +197346,7 @@ self: { ]; description = "Periodic task system haskell server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "perm" = callPackage @@ -188037,6 +197363,7 @@ self: { ]; description = "permutation Applicative and Monad with many mtl instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "permutation" = callPackage @@ -188051,6 +197378,8 @@ self: { libraryHaskellDepends = [ base ghc-prim QuickCheck ]; description = "A library for permutations and combinations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "permutations" = callPackage @@ -188074,6 +197403,8 @@ self: { ]; description = "Permutations of finite sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "permute" = callPackage @@ -188085,6 +197416,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Generalised permutation parser combinator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persist" = callPackage @@ -188136,6 +197469,8 @@ self: { ]; description = "Transforms persist's quasi-quoted syntax into ER format"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistable-record" = callPackage @@ -188274,6 +197609,7 @@ self: { ]; description = "Parses a Persist Model file and produces Audit Models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "persistent-cereal" = callPackage @@ -188285,6 +197621,8 @@ self: { libraryHaskellDepends = [ base cereal persistent text ]; description = "Helper functions for writing Persistent instances"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-database-url" = callPackage @@ -188304,6 +197642,8 @@ self: { ]; description = "Parse DATABASE_URL into configuration types for Persistent"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-discover" = callPackage @@ -188331,6 +197671,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Persistent module discover utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-documentation" = callPackage @@ -188362,6 +197704,8 @@ self: { libraryHaskellDepends = [ array base diffarray ]; description = "Persistent equivalence relations (aka union-find)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-generic" = callPackage @@ -188389,6 +197733,7 @@ self: { ]; description = "Declare Persistent entities using SQL SELECT query syntax"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "persistent-instances-iproute" = callPackage @@ -188432,6 +197777,7 @@ self: { ]; description = "A thread-safe (STM) persistency interface for finite map types"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "persistent-migration" = callPackage @@ -188456,6 +197802,8 @@ self: { ]; description = "Manual migrations for the persistent library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-mongoDB" = callPackage @@ -188483,6 +197831,7 @@ self: { ]; description = "Backend for the persistent library using mongoDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "persistent-mtl" = callPackage @@ -188595,6 +197944,8 @@ self: { ]; description = "A pure haskell backend for the persistent library using MySQL database server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-odbc" = callPackage @@ -188615,6 +197966,8 @@ self: { ]; description = "Backend for the persistent library using ODBC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-pagination" = callPackage @@ -188728,6 +198081,8 @@ self: { ]; description = "Template-Haskell helpers for integrating protobufs with persistent"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-qq" = callPackage @@ -188783,6 +198138,8 @@ self: { libraryHaskellDepends = [ base time yesod ]; description = "A library for rate limiting activities with a persistent backend"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-redis" = callPackage @@ -188805,6 +198162,8 @@ self: { ]; description = "Backend for persistent library using Redis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-refs" = callPackage @@ -188841,6 +198200,8 @@ self: { ]; description = "relational-record on persisten backends"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-spatial" = callPackage @@ -188992,6 +198353,8 @@ self: { ]; description = "Generate classy lens field accessors for persistent models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-test" = callPackage @@ -189136,6 +198499,8 @@ self: { ]; description = "Backend for persistent library using Zookeeper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persona" = callPackage @@ -189152,6 +198517,8 @@ self: { ]; description = "Persona (BrowserID) library"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persona-idp" = callPackage @@ -189173,6 +198540,7 @@ self: { ]; description = "Persona (BrowserID) Identity Provider"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "pesca" = callPackage @@ -189187,6 +198555,8 @@ self: { executableHaskellDepends = [ base process ]; description = "Proof Editor for Sequent Calculus"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "peyotls" = callPackage @@ -189213,6 +198583,7 @@ self: { ]; description = "Pretty Easy YOshikuni-made TLS library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "peyotls-codec" = callPackage @@ -189230,6 +198601,7 @@ self: { ]; description = "Codec parts of Pretty Easy YOshikuni-made TLS library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pez" = callPackage @@ -189246,6 +198618,8 @@ self: { ]; description = "A Pretty Extraordinary Zipper library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pg-extras" = callPackage @@ -189262,6 +198636,8 @@ self: { testHaskellDepends = [ base HUnit text ]; description = "PostgreSQL database performance insights"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pg-harness" = callPackage @@ -189281,6 +198657,8 @@ self: { ]; description = "REST service and library for creating/consuming temporary PostgreSQL databases"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pg-harness-client" = callPackage @@ -189311,6 +198689,8 @@ self: { ]; description = "REST service for creating temporary PostgreSQL databases"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pg-recorder" = callPackage @@ -189336,6 +198716,8 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pg-store" = callPackage @@ -189359,6 +198741,8 @@ self: { ]; description = "Simple storage interface to PostgreSQL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pg-transact" = callPackage @@ -189380,6 +198764,7 @@ self: { ]; description = "A postgresql-simple transaction monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pgdl" = callPackage @@ -189405,6 +198790,8 @@ self: { ]; description = "browse directory listing webpages and download files from them"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pgf2" = callPackage @@ -189417,6 +198804,8 @@ self: { librarySystemDepends = [ gu pgf ]; description = "Bindings to the C version of the PGF runtime"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gu = null; inherit (pkgs) pgf;}; "pgm" = callPackage @@ -189464,6 +198853,7 @@ self: { ]; description = "A mid-level PostgreSQL client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pgstream" = callPackage @@ -189488,6 +198878,8 @@ self: { ]; description = "Streaming Postgres bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phantom-state" = callPackage @@ -189514,6 +198906,8 @@ self: { ]; description = "Freezing, thawing, and copy elision"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phaser" = callPackage @@ -189528,6 +198922,8 @@ self: { ]; description = "Incremental multiple pass parser library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phash" = callPackage @@ -189585,6 +198981,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Deprecated - ghci debug viewer with simple editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phoityne-vscode" = callPackage @@ -189635,6 +199033,8 @@ self: { testHaskellDepends = [ base bytestring ]; description = "Haskell bindings to the libphonenumber library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {phonenumber = null; inherit (pkgs) protobuf;}; "phone-push" = callPackage @@ -189652,6 +199052,8 @@ self: { ]; description = "Push notifications for Android and iOS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phonetic-code" = callPackage @@ -189740,6 +199142,7 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-examples functionality"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "phonetic-languages-filters-array" = callPackage @@ -189845,6 +199248,8 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-properties package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phonetic-languages-rhythmicity" = callPackage @@ -190014,6 +199419,7 @@ self: { ]; description = "Simplified and somewhat optimized version of the phonetic-languages-examples"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "phonetic-languages-simplified-properties-array" = callPackage @@ -190049,6 +199455,8 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-properties package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phonetic-languages-simplified-properties-lists-double" = callPackage @@ -190067,6 +199475,8 @@ self: { ]; description = "A generalization of the uniqueness-periods-vector-properties package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phonetic-languages-ukrainian" = callPackage @@ -190115,6 +199525,7 @@ self: { ]; description = "Functional user interfaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "photoname" = callPackage @@ -190136,6 +199547,7 @@ self: { ]; description = "Rename photo image files based on EXIF shoot date"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "phraskell" = callPackage @@ -190149,6 +199561,8 @@ self: { executableHaskellDepends = [ base mtl SDL transformers ]; description = "A fractal viewer"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "phybin" = callPackage @@ -190181,6 +199595,8 @@ self: { ]; description = "Utility for clustering phylogenetic trees in Newick format based on Robinson-Foulds distance"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "physics" = callPackage @@ -190212,6 +199628,8 @@ self: { ]; description = "Applied pi-calculus interpreter"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pi-forall" = callPackage @@ -190235,6 +199653,8 @@ self: { ]; description = "Demo implementation of typechecker for dependently-typed language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pi-hoole" = callPackage @@ -190260,6 +199680,8 @@ self: { testHaskellDepends = [ base ]; description = "Lightweight access control solution for the pijul vcs"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pi-lcd" = callPackage @@ -190301,6 +199723,8 @@ self: { ]; description = "Set up port forwarding with the Private Internet Access VPN service"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pianola" = callPackage @@ -190323,6 +199747,7 @@ self: { ]; description = "Remotely controlling Java Swing applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "picedit" = callPackage @@ -190337,6 +199762,8 @@ self: { executableHaskellDepends = [ base cli hmatrix ]; description = "simple image manipulation functions"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pickle" = callPackage @@ -190348,6 +199775,8 @@ self: { libraryHaskellDepends = [ base containers network stm text ]; description = "Instant StatsD in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "picologic" = callPackage @@ -190370,6 +199799,8 @@ self: { ]; description = "Utilities for symbolic predicate logic expressions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "picoparsec" = callPackage @@ -190402,6 +199833,8 @@ self: { ]; description = "Fast combinator parsing for bytestrings and text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "picosat" = callPackage @@ -190427,6 +199860,8 @@ self: { executableHaskellDepends = [ base matrix transformers xml ]; description = "Converts a svg image to tikz code"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pid1" = callPackage @@ -190474,6 +199909,7 @@ self: { ]; description = "Yet another Haskell build system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pier-core" = callPackage @@ -190493,6 +199929,8 @@ self: { ]; description = "A library for writing forwards-declared build systems in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "piet" = callPackage @@ -190506,6 +199944,8 @@ self: { libraryHaskellDepends = [ array base containers Imlib mtl ]; description = "A Piet interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pig" = callPackage @@ -190522,6 +199962,8 @@ self: { ]; description = "dice game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "piki" = callPackage @@ -190605,6 +200047,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "An alternative implementation of Thrift for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pinch-gen" = callPackage @@ -190642,6 +200086,8 @@ self: { ]; description = "Write grammars, not parsers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pine" = callPackage @@ -190683,6 +200129,7 @@ self: { ]; description = "icmp echo requests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ping-parser-attoparsec" = callPackage @@ -190774,6 +200221,7 @@ self: { testHaskellDepends = [ base doctest protolude ]; description = "A gateway for various cloud notification services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipe-enumerator" = callPackage @@ -190785,6 +200233,7 @@ self: { libraryHaskellDepends = [ base enumerator pipes transformers ]; description = "A bidirectional bridge between pipes and iteratees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipeclip" = callPackage @@ -190916,6 +200365,8 @@ self: { ]; description = "A higher-level interface to using concurrency with pipes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-attoparsec" = callPackage @@ -190955,6 +200406,7 @@ self: { ]; description = "Streaming parsing in the pipes-core framework with Attoparsec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-bgzf" = callPackage @@ -190970,6 +200422,8 @@ self: { ]; description = "Blocked GZip"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-binary" = callPackage @@ -191023,6 +200477,7 @@ self: { ]; description = "Brotli (RFC7932) compressors and decompressors for the Pipes package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-bytestring" = callPackage @@ -191078,6 +200533,7 @@ self: { testHaskellDepends = [ base hlint ]; description = "Pipes for Noise-secured network connections"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-category" = callPackage @@ -191153,6 +200609,8 @@ self: { ]; description = "Encode and decode binary streams using the pipes and cereal libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-cereal-plus" = callPackage @@ -191168,6 +200626,7 @@ self: { ]; description = "A streaming serialization library on top of \"pipes\" and \"cereal-plus\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-cliff" = callPackage @@ -191214,6 +200673,7 @@ self: { libraryHaskellDepends = [ base conduit mtl pipes-core ]; description = "Conduit adapters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-core" = callPackage @@ -191229,6 +200689,8 @@ self: { ]; description = "Compositional pipelines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-courier" = callPackage @@ -191240,6 +200702,7 @@ self: { libraryHaskellDepends = [ base courier pipes ]; description = "Pipes utilities for interfacing with the courier message-passing framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-csv" = callPackage @@ -191272,6 +200735,8 @@ self: { libraryHaskellDepends = [ base errors pipes ]; description = "Integration between pipes and errors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-extra" = callPackage @@ -191299,6 +200764,7 @@ self: { ]; description = "Various basic utilities for Pipes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-extras" = callPackage @@ -191359,6 +200825,7 @@ self: { ]; description = "Fast traversal of directory trees using pipes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-fluid" = callPackage @@ -191431,6 +200898,7 @@ self: { ]; description = "Illumina NGS data processing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-interleave" = callPackage @@ -191444,6 +200912,8 @@ self: { libraryHaskellDepends = [ base containers heaps pipes ]; description = "Interleave and merge streams of elements"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-io" = callPackage @@ -191458,6 +200928,8 @@ self: { testHaskellDepends = [ base hspec pipes ]; description = "Stateful IO streams based on pipes"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-kafka" = callPackage @@ -191498,6 +200970,7 @@ self: { ]; description = "Streaming processing of CSV files preceded by key-value pairs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-lines" = callPackage @@ -191565,6 +201038,7 @@ self: { testHaskellDepends = [ base monad-control mongoDB pipes text ]; description = "Stream results from MongoDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-network" = callPackage @@ -191640,6 +201114,7 @@ self: { ]; description = "P2P network nodes with pipes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-p2p-examples" = callPackage @@ -191658,6 +201133,7 @@ self: { ]; description = "Examples using pipes-p2p"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pipes-parse" = callPackage @@ -191708,6 +201184,8 @@ self: { testHaskellDepends = [ base ]; description = "Alternate Prelude for the pipes ecosystem"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-pulse-simple" = callPackage @@ -191747,6 +201225,8 @@ self: { executableHaskellDepends = [ base pipes time ]; description = "A few pipes to control the timing of yields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-s3" = callPackage @@ -191769,6 +201249,8 @@ self: { ]; description = "A simple interface for streaming data to and from Amazon S3"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-safe" = callPackage @@ -191805,6 +201287,8 @@ self: { ]; description = "Create proper Pipes from System.Process"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-sqlite-simple" = callPackage @@ -191818,6 +201302,8 @@ self: { ]; description = "Functions that smash Pipes and sqlite-simple together"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-text" = callPackage @@ -191858,6 +201344,8 @@ self: { ]; description = "Interfacing pipes with foldl folds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-vector" = callPackage @@ -191873,6 +201361,8 @@ self: { ]; description = "Various proxies for streaming data into vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-wai" = callPackage @@ -191923,6 +201413,8 @@ self: { ]; description = "Pipes integration for ZeroMQ messaging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-zlib" = callPackage @@ -191962,6 +201454,7 @@ self: { ]; description = "A dependently typed core language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pit" = callPackage @@ -191984,6 +201477,8 @@ self: { ]; description = "Account management tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pitchtrack" = callPackage @@ -192004,6 +201499,7 @@ self: { ]; description = "Pitch tracking library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pivotal-tracker" = callPackage @@ -192027,6 +201523,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "A library and a CLI tool for accessing Pivotal Tracker API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pixel-printer" = callPackage @@ -192044,6 +201542,8 @@ self: { testHaskellDepends = [ base ]; description = "A program for turning pixel art into 3D prints"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pixela" = callPackage @@ -192088,6 +201588,8 @@ self: { ]; description = "A library and application for generating pixelated avatars"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pixiv" = callPackage @@ -192174,6 +201676,8 @@ self: { ]; description = "PKCS#10 library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pkcs7" = callPackage @@ -192186,6 +201690,8 @@ self: { testHaskellDepends = [ base bytestring Cabal HUnit QuickCheck ]; description = "PKCS #7 padding in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pkggraph" = callPackage @@ -192199,6 +201705,8 @@ self: { executableHaskellDepends = [ base Cabal split ]; description = "Package dependency graph for installed packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pkgtreediff" = callPackage @@ -192219,6 +201727,7 @@ self: { ]; description = "Package tree diff tool"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "pktree" = callPackage @@ -192298,6 +201807,8 @@ self: { libraryHaskellDepends = [ base bytestring mtl time unix ]; description = "plaimi's prelude"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plan-applicative" = callPackage @@ -192318,6 +201829,8 @@ self: { ]; description = "Applicative/Arrow for resource estimation and progress tracking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plan-b" = callPackage @@ -192336,6 +201849,8 @@ self: { testHaskellDepends = [ base hspec path path-io ]; description = "Failure-tolerant file and directory editing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "planar-graph" = callPackage @@ -192352,6 +201867,8 @@ self: { ]; description = "A representation of planar graphs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "planb-token-introspection" = callPackage @@ -192375,6 +201892,8 @@ self: { ]; description = "Token Introspection for PlanB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "planet-mitchell" = callPackage @@ -192429,6 +201948,7 @@ self: { ]; description = "Planet Mitchell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "planet-mitchell-test" = callPackage @@ -192445,6 +201965,8 @@ self: { ]; description = "Planet Mitchell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plankton" = callPackage @@ -192456,6 +201978,8 @@ self: { libraryHaskellDepends = [ adjunctions base protolude ]; description = "The core of a numeric prelude, taken from numhask"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plat" = callPackage @@ -192469,6 +201993,8 @@ self: { ]; description = "Simple templating library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "platinum-parsing" = callPackage @@ -192492,6 +202018,8 @@ self: { testHaskellDepends = [ base containers fgl hspec vector ]; description = "General Framework for compiler development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "playlists" = callPackage @@ -192563,6 +202091,8 @@ self: { libraryHaskellDepends = [ base base64-bytestring bytestring hxt ]; description = "Generate and parse Mac OS X property list format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plist-buddy" = callPackage @@ -192586,6 +202116,8 @@ self: { ]; description = "Remote monad for editing plists"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plivo" = callPackage @@ -192619,6 +202151,7 @@ self: { executableHaskellDepends = [ base optparse-applicative socketed ]; description = "plot data from stdin through socketed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "plot" = callPackage @@ -192645,6 +202178,8 @@ self: { libraryHaskellDepends = [ base glib gtk hmatrix mtl plot process ]; description = "GTK plots and interaction with GHCi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plot-gtk-ui" = callPackage @@ -192661,6 +202196,8 @@ self: { ]; description = "A quick way to use Mathematica like Manipulation abilities"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plot-gtk3" = callPackage @@ -192674,6 +202211,8 @@ self: { ]; description = "GTK3 plots and interaction with GHCi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plot-lab" = callPackage @@ -192690,6 +202229,8 @@ self: { ]; description = "A plotting tool with Mathematica like Manipulation abilities"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plot-light" = callPackage @@ -192856,6 +202397,8 @@ self: { testHaskellDepends = [ base directory process ]; description = "Automatic recompilation and reloading of haskell modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plugins-multistage" = callPackage @@ -192874,6 +202417,8 @@ self: { ]; description = "Dynamic linking for embedded DSLs with staged compilation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plumbers" = callPackage @@ -192885,6 +202430,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Pointless plumbing combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plur" = callPackage @@ -192897,6 +202444,8 @@ self: { testHaskellDepends = [ base hedgehog hedgehog-classes ]; description = "Plurality monad: Zero, one, or at least two"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "plural" = callPackage @@ -192909,6 +202458,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Pluralize"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ply-loader" = callPackage @@ -192947,6 +202498,8 @@ self: { testHaskellDepends = [ base hspec mtl text unordered-containers ]; description = "A front-end framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "png-file" = callPackage @@ -192962,6 +202515,7 @@ self: { ]; description = "read/write png file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pngload" = callPackage @@ -192978,6 +202532,7 @@ self: { ]; description = "Pure Haskell loader for PNG images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pngload-fixed" = callPackage @@ -192990,6 +202545,8 @@ self: { libraryHaskellDepends = [ array base bytestring mtl parsec zlib ]; description = "Pure Haskell loader for PNG images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pnm" = callPackage @@ -193016,6 +202573,8 @@ self: { ]; description = "Bindings for the Pocket API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pocket-dns" = callPackage @@ -193050,6 +202609,7 @@ self: { ]; description = "Multi-backend (zookeeper and sqlite) DNS Server using persistent-library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "point-octree" = callPackage @@ -193068,6 +202628,7 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Point octree, with bounding boxes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pointed" = callPackage @@ -193097,6 +202658,8 @@ self: { libraryHaskellDepends = [ base mtl semigroups transformers ]; description = "Alternative done right"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pointedlist" = callPackage @@ -193155,6 +202718,8 @@ self: { doHaddock = false; description = "Tool for refactoring expressions into pointfree form"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pointful" = callPackage @@ -193173,6 +202738,8 @@ self: { executableHaskellDepends = [ base ]; description = "Pointful refactoring tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pointless-fun" = callPackage @@ -193195,6 +202762,8 @@ self: { libraryHaskellDepends = [ base GHood process syb ]; description = "Pointless Haskell library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pointless-lenses" = callPackage @@ -193210,6 +202779,7 @@ self: { ]; description = "Pointless Lenses library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pointless-rewrite" = callPackage @@ -193225,6 +202795,7 @@ self: { ]; description = "Pointless Rewrite library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "poke" = callPackage @@ -193256,6 +202827,7 @@ self: { ]; description = "Discord verification bot"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "pokemon-go-protobuf-types" = callPackage @@ -193272,6 +202844,8 @@ self: { ]; description = "Haskell types for the Pokemon Go protobuf protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "poker-eval" = callPackage @@ -193284,6 +202858,8 @@ self: { librarySystemDepends = [ poker-eval ]; description = "Binding to libpoker-eval"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {poker-eval = null;}; "pokitdok" = callPackage @@ -193301,6 +202877,8 @@ self: { ]; description = "PokitDok Platform API Client for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polar" = callPackage @@ -193324,6 +202902,8 @@ self: { testHaskellDepends = [ base containers HUnit MissingH mtl parsec ]; description = "Fork of ConfigFile for Polar Game Engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polar-shader" = callPackage @@ -193336,6 +202916,8 @@ self: { testHaskellDepends = [ base containers hspec ]; description = "High-level shader compiler framework"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polh-lexicon" = callPackage @@ -193354,6 +202936,7 @@ self: { ]; description = "A library for manipulating the historical dictionary of Polish (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "policeman" = callPackage @@ -193447,6 +203030,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "Poly-kinded continuations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "poly-control" = callPackage @@ -193458,6 +203043,8 @@ self: { libraryHaskellDepends = [ base lens ]; description = "This package provides abstraction for polymorphic controls, like PolyMonads or PolyApplicatives"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "poly-rec" = callPackage @@ -193498,6 +203085,7 @@ self: { ]; description = "Wrap together data and it's constraints"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polydata-core" = callPackage @@ -193509,6 +203097,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Core data definitions for the \"polydata\" package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polymap" = callPackage @@ -193566,6 +203156,8 @@ self: { ]; description = "Polynomials"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polynomials-bernstein" = callPackage @@ -193644,6 +203236,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Experimental, RandomFu effect and interpreters for polysemy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-chronos" = callPackage @@ -193703,6 +203296,7 @@ self: { ]; description = "Extra Input and Output functions for polysemy.."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-fs" = callPackage @@ -193733,6 +203327,7 @@ self: { ]; description = "Run a KVStore as a filesystem in polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-http" = callPackage @@ -193778,6 +203373,7 @@ self: { ]; description = "Run a KVStore as a single json file in polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-log" = callPackage @@ -193823,6 +203419,7 @@ self: { ]; description = "polysemy-log interpreter for co-log"; license = "BSD-2-Clause-Patent"; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-log-di" = callPackage @@ -193859,6 +203456,7 @@ self: { ]; description = "Domain modelling algebra for polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-methodology-composite" = callPackage @@ -193875,6 +203473,7 @@ self: { ]; description = "Functions for using polysemy-methodology with composite"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-mocks" = callPackage @@ -193901,6 +203500,7 @@ self: { libraryHaskellDepends = [ base optics polysemy polysemy-zoo ]; description = "Optics for Polysemy"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-path" = callPackage @@ -193916,6 +203516,7 @@ self: { ]; description = "Polysemy versions of Path functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-plugin" = callPackage @@ -194028,6 +203629,7 @@ self: { libraryHaskellDepends = [ base polysemy polysemy-extra vinyl ]; description = "Functions for mapping vinyl records in polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-webserver" = callPackage @@ -194073,6 +203675,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Experimental, user-contributed effects and interpreters for polysemy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polyseq" = callPackage @@ -194093,6 +203697,7 @@ self: { executableHaskellDepends = [ cgi free-theorems utf8-string xhtml ]; description = "Taming Selective Strictness"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "polysoup" = callPackage @@ -194117,6 +203722,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Typeable for polymorphic types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polytypeable-utils" = callPackage @@ -194128,6 +203735,7 @@ self: { libraryHaskellDepends = [ base haskell98 polytypeable ]; description = "Utilities for polytypeable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "polyvariadic" = callPackage @@ -194183,6 +203791,7 @@ self: { ]; description = "pomodoro timer"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "pomohoro" = callPackage @@ -194206,6 +203815,8 @@ self: { testHaskellDepends = [ base hspec protolude ]; description = "Initial project template from stack"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ponder" = callPackage @@ -194217,6 +203828,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "PEG parser combinator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pong-server" = callPackage @@ -194234,6 +203847,8 @@ self: { testHaskellDepends = [ base hspec network QuickCheck ]; description = "A simple embedded pingable server that runs in the background"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pontarius-mediaserver" = callPackage @@ -194360,6 +203975,8 @@ self: { libraryHaskellDepends = [ base monad-control transformers ]; description = "Thread-safe resource pools. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pool-conduit" = callPackage @@ -194377,6 +203994,8 @@ self: { ]; description = "Resource pool allocations via ResourceT. (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pooled-io" = callPackage @@ -194407,6 +204026,8 @@ self: { libraryHaskellDepends = [ base mtl network ]; description = "POP3 Client Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "popenhs" = callPackage @@ -194419,6 +204040,7 @@ self: { libraryHaskellDepends = [ base directory haskell98 unix ]; description = "popenhs is a popen-like library for Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "popkey" = callPackage @@ -194440,6 +204062,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Static key-value storage backed by poppy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "poppler" = callPackage @@ -194460,6 +204084,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the Poppler"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gdk-pixbuf; inherit (pkgs) gtk2; inherit (pkgs) pango; inherit (pkgs) poppler_gi;}; @@ -194514,6 +204140,7 @@ self: { ]; description = "Express portable, composable and reusable data tasks and pipelines"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "porcupine-http" = callPackage @@ -194542,6 +204169,7 @@ self: { ]; description = "A location accessor for porcupine to connect to HTTP sources/sinks"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "porcupine-s3" = callPackage @@ -194572,6 +204200,7 @@ self: { ]; description = "A location accessor for porcupine to connect to AWS S3 sources/sinks"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "porpoise" = callPackage @@ -194643,6 +204272,8 @@ self: { testHaskellDepends = [ base containers hspec mtl QuickCheck text ]; description = "DSL for configuring Gentoo portage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "portaudio" = callPackage @@ -194673,6 +204304,8 @@ self: { ]; description = "FreeBSD ports index search and analysis tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "porter" = callPackage @@ -194695,6 +204328,7 @@ self: { libraryHaskellDepends = [ base haskell98 unix ]; description = "The Haskell Ports Library"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "ports-tools" = callPackage @@ -194729,6 +204363,7 @@ self: { ]; description = "Simple extensible library to run SQL file against PostgreSQL database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "poseidon-postgis" = callPackage @@ -194749,6 +204384,7 @@ self: { ]; description = "Extension of Poseidon library for Postgis (Spatial and Geographic objects for PostgreSQL)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "positive" = callPackage @@ -194777,6 +204413,8 @@ self: { testHaskellDepends = [ base ]; description = "Experiment"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "posix-acl" = callPackage @@ -194794,6 +204432,8 @@ self: { librarySystemDepends = [ acl ]; description = "Support for Posix ACL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) acl;}; "posix-api" = callPackage @@ -194817,6 +204457,8 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) systemd;}; "posix-error-codes" = callPackage @@ -194894,6 +204536,8 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "POSIX Realtime functionality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "posix-socket" = callPackage @@ -194934,6 +204578,8 @@ self: { libraryHaskellDepends = [ base unix ]; description = "Low-level wrapping of POSIX waitpid(2)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "posplyu" = callPackage @@ -194995,6 +204641,8 @@ self: { libraryHaskellDepends = [ aeson base bytestring HTTP ]; description = "A library that gets postcode information from the uk-postcodes.com"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgres-embedded" = callPackage @@ -195013,6 +204661,8 @@ self: { ]; description = "Library for easily running embedded PostgreSQL server for tests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgres-options" = callPackage @@ -195040,6 +204690,8 @@ self: { libraryHaskellDepends = [ base bytestring postgresql-simple text ]; description = "Create a temporary database that is deleted after performing some operation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgres-websockets" = callPackage @@ -195072,6 +204724,8 @@ self: { ]; description = "Middleware to map LISTEN/NOTIFY messages to Websockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-binary" = callPackage @@ -195248,6 +204902,8 @@ self: { ]; description = "Utilities for streaming PostgreSQL LargeObjects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-named" = callPackage @@ -195265,6 +204921,8 @@ self: { testHaskellDepends = [ base generics-sop hspec postgresql-simple ]; description = "Generic deserialization of PostgreSQL rows based on column names"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-orm" = callPackage @@ -195383,6 +205041,7 @@ self: { ]; description = "Sql interpolating quasiquote plus some kind of primitive ORM using it"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "postgresql-schema" = callPackage @@ -195454,6 +205113,8 @@ self: { ]; description = "FFI-like bindings for PostgreSQL stored functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-simple-interpolate" = callPackage @@ -195513,6 +205174,8 @@ self: { ]; description = "Implementation of named parameters for `postgresql-simple` library"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-simple-opts" = callPackage @@ -195561,6 +205224,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "A PostgreSQL backed queue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "postgresql-simple-sop" = callPackage @@ -195572,6 +205236,8 @@ self: { libraryHaskellDepends = [ base generics-sop postgresql-simple ]; description = "Generic functions for postgresql-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-simple-typed" = callPackage @@ -195588,6 +205254,7 @@ self: { ]; description = "Typed extension for PostgreSQL simple"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "postgresql-simple-url" = callPackage @@ -195608,6 +205275,8 @@ self: { ]; description = "Parse postgres:// url into ConnectInfo"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-syntax" = callPackage @@ -195686,6 +205355,7 @@ self: { ]; description = "postgresql-tx interfacing for use with postgresql-query"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "postgresql-tx-simple" = callPackage @@ -195717,6 +205387,7 @@ self: { ]; description = "postgresql-tx interfacing for use with squeal-postgresql"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "postgresql-tx-squeal-compat-simple" = callPackage @@ -195730,6 +205401,7 @@ self: { ]; description = "Connection interop from postgresql-simple connections to postgresql-libpq connections"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "postgresql-typed" = callPackage @@ -195774,6 +205446,8 @@ self: { ]; description = "postgresql-typed operations lifted to any instance of MonadBase or MonadBaseControl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgrest" = callPackage @@ -195857,6 +205531,8 @@ self: { ]; description = "PostgREST extension to map LISTEN/NOTIFY messages to Websockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postie" = callPackage @@ -195875,6 +205551,8 @@ self: { ]; description = "SMTP server library to receive emails from within Haskell programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postmark" = callPackage @@ -195893,6 +205571,7 @@ self: { ]; description = "Library for postmarkapp.com HTTP Api"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "postmark-streams" = callPackage @@ -195909,6 +205588,8 @@ self: { ]; description = "Send email via Postmark using io-streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postmaster" = callPackage @@ -195929,6 +205610,8 @@ self: { ]; description = "Postmaster ESMTP Server"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "potato-tool" = callPackage @@ -195942,6 +205625,8 @@ self: { executableHaskellDepends = [ base binary bytestring split ]; description = "Command line Dreamcast VMU filesystem toolset"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "potoki" = callPackage @@ -195953,6 +205638,7 @@ self: { libraryHaskellDepends = [ potoki-core ]; description = "Simple streaming in IO"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "potoki-cereal" = callPackage @@ -195975,6 +205661,7 @@ self: { ]; description = "Streaming serialization"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "potoki-conduit" = callPackage @@ -195997,6 +205684,7 @@ self: { ]; description = "Integration of \"potoki\" and \"conduit\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "potoki-core" = callPackage @@ -196024,6 +205712,8 @@ self: { benchmarkHaskellDepends = [ criterion rerebase ]; description = "Low-level components of \"potoki\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "potoki-hasql" = callPackage @@ -196039,6 +205729,7 @@ self: { ]; description = "Integration of \"potoki\" and \"hasql\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "potoki-zlib" = callPackage @@ -196052,6 +205743,7 @@ self: { ]; description = "Streaming ZLib decompression"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "potrace" = callPackage @@ -196095,6 +205787,8 @@ self: { executableHaskellDepends = [ base ]; description = "bindings for Griffin PowerMate USB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "powerpc" = callPackage @@ -196106,6 +205800,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Tools for PowerPC programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "powerqueue" = callPackage @@ -196163,6 +205859,8 @@ self: { benchmarkSystemDepends = [ leveldb snappy ]; description = "A high performance in memory and LevelDB backend for powerqueue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) leveldb; inherit (pkgs) snappy;}; "powerqueue-sqs" = callPackage @@ -196176,6 +205874,7 @@ self: { ]; description = "A Amazon SQS backend for powerqueue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ppm" = callPackage @@ -196198,6 +205897,8 @@ self: { libraryHaskellDepends = [ base boxes ]; description = "A library for pretty printing Records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pptable" = callPackage @@ -196232,6 +205933,8 @@ self: { libraryHaskellDepends = [ base QuickCheck random stm ]; description = "Parallel batch driver for QuickCheck"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pqueue" = callPackage @@ -196259,6 +205962,7 @@ self: { ]; description = "Fully encapsulated monad transformers with queuelike functionality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "practice-room" = callPackage @@ -196277,6 +205981,7 @@ self: { ]; description = "Practice Room"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "praglude" = callPackage @@ -196297,6 +206002,8 @@ self: { ]; description = "A pragmatic Prelude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pragmatic-show" = callPackage @@ -196352,6 +206059,8 @@ self: { ]; description = "Yet another prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "precis" = callPackage @@ -196387,6 +206096,8 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "Prelude replacement"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pred-set" = callPackage @@ -196398,6 +206109,7 @@ self: { libraryHaskellDepends = [ base hashable hashtables HSet ]; description = "Simple cached predicates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pred-trie" = callPackage @@ -196426,6 +206138,7 @@ self: { ]; description = "Predicative tries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "predicate-class" = callPackage @@ -196437,6 +206150,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Helper class for passing context along a predicate value"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "predicate-transformers" = callPackage @@ -196474,6 +206189,8 @@ self: { ]; description = "Predicates, Refinement types and Dsl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "predicates" = callPackage @@ -196517,6 +206234,8 @@ self: { ]; description = "Evaluate and display trees of predicates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prednote-test" = callPackage @@ -196539,6 +206258,7 @@ self: { ]; description = "Tests and QuickCheck generators to accompany prednote"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "prefetch" = callPackage @@ -196602,6 +206322,8 @@ self: { ]; description = "A library for building a prefork-style server quickly"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pregame" = callPackage @@ -196621,6 +206343,8 @@ self: { ]; description = "Prelude for applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "preliminaries" = callPackage @@ -196642,6 +206366,8 @@ self: { ]; description = "A larger alternative to the Prelude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prelude-compat" = callPackage @@ -196686,6 +206412,8 @@ self: { libraryHaskellDepends = [ base comonad logict transformers ]; description = "Another kind of alternate Prelude file"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prelude-plus" = callPackage @@ -196699,6 +206427,8 @@ self: { libraryHaskellDepends = [ base utf8-string ]; description = "Prelude for rest of us"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prelude-prime" = callPackage @@ -196762,6 +206492,8 @@ self: { ]; description = "Preprocess Haskell Repositories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "preprocessor" = callPackage @@ -196782,6 +206514,8 @@ self: { ]; description = "Remove cpp annotations to get the source ready for static analysis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "preprocessor-tools" = callPackage @@ -196831,6 +206565,8 @@ self: { benchmarkToolDepends = [ alex happy ]; description = "safe PostgreSQL queries using Quasiquoters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "presburger" = callPackage @@ -196845,6 +206581,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "A decision procedure for quantifier-free linear arithmetic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "present" = callPackage @@ -196856,6 +206594,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Make presentations for data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "press" = callPackage @@ -196867,6 +206607,8 @@ self: { libraryHaskellDepends = [ base containers json mtl parsec ]; description = "Text template library targeted at the web / HTML generation"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "presto-hdbc" = callPackage @@ -196886,6 +206628,7 @@ self: { ]; description = "An HDBC connector for Presto"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "prettify" = callPackage @@ -197009,6 +206752,8 @@ self: { ]; description = "Functionality for beautifying GHCi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pretty-hex" = callPackage @@ -197042,6 +206787,8 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "A implementation of multi-column layout w/ Text.PrettyPrint"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pretty-relative-time" = callPackage @@ -197332,6 +207079,8 @@ self: { libraryHaskellDepends = [ base prettyprinter vty ]; description = "prettyprinter backend for vty"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "preview" = callPackage @@ -197347,6 +207096,7 @@ self: { ]; description = "The method of previewing data (instead of wholly show-ing it)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "prim" = callPackage @@ -197371,6 +207121,8 @@ self: { libraryHaskellDepends = [ base ghc-prim primitive semigroups ]; description = "Primitive byte array with type variable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prim-instances" = callPackage @@ -197383,6 +207135,8 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "Prim typeclass instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prim-ref" = callPackage @@ -197394,6 +207148,8 @@ self: { libraryHaskellDepends = [ base ghc-prim primitive semigroups ]; description = "Primitive byte array with type variable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prim-spoon" = callPackage @@ -197496,6 +207252,8 @@ self: { benchmarkHaskellDepends = [ base criterion primes ]; description = "Type-safe prime numbers"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primesieve" = callPackage @@ -197555,6 +207313,8 @@ self: { testHaskellDepends = [ base primitive primitive-unlifted ]; description = "Wrappers for primops around atomic operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-checked" = callPackage @@ -197566,6 +207326,8 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "primitive functions with bounds-checking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-containers" = callPackage @@ -197602,6 +207364,8 @@ self: { libraryHaskellDepends = [ primitive ]; description = "convenience class for PrimMonad m/PrimState m"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-extras" = callPackage @@ -197636,6 +207400,8 @@ self: { testHaskellDepends = [ base primitive QuickCheck ]; description = "using the `Prim` interface for the FFI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-indexed" = callPackage @@ -197647,6 +207413,8 @@ self: { libraryHaskellDepends = [ base primitive ]; testHaskellDepends = [ base doctest QuickCheck ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-maybe" = callPackage @@ -197664,6 +207432,8 @@ self: { ]; description = "Arrays of Maybes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-offset" = callPackage @@ -197689,6 +207459,8 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq random vector ]; description = "SIMD data types and functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-sort" = callPackage @@ -197721,6 +207493,8 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "primitive operations on StableNames"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-unaligned" = callPackage @@ -197787,6 +207561,7 @@ self: { ]; description = "ImageBoard on Happstack and HSP"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "primula-bot" = callPackage @@ -197805,6 +207580,7 @@ self: { ]; description = "Jabber-bot for primula-board ImageBoard"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "pringletons" = callPackage @@ -197821,6 +207597,8 @@ self: { ]; description = "Classes and data structures complementing the singletons library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "print-console-colors" = callPackage @@ -197846,6 +207624,8 @@ self: { libraryHaskellDepends = [ base split ]; description = "Debug print formatting library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "print-info" = callPackage @@ -197873,6 +207653,8 @@ self: { ]; description = "Pretty printing with indentation, mixfix operators, and automatic line breaks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "printf-mauke" = callPackage @@ -197914,6 +207696,8 @@ self: { ]; description = "The Artist Formerly Known as Prints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "printxosd" = callPackage @@ -197938,6 +207722,8 @@ self: { libraryHaskellDepends = [ base containers queue reord stateref ]; description = "Simple implementation of a priority queue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "priority-sync" = callPackage @@ -198040,6 +207826,8 @@ self: { ]; description = "Easy and reasonably efficient probabilistic programming and random generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proc" = callPackage @@ -198058,6 +207846,7 @@ self: { ]; description = "Parse process information for Linux"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "proc-net" = callPackage @@ -198110,6 +207899,8 @@ self: { ]; description = "Conduits for processes (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "process-extras" = callPackage @@ -198145,6 +207936,7 @@ self: { ]; description = "IterIO Process Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "process-leksah" = callPackage @@ -198156,6 +207948,8 @@ self: { libraryHaskellDepends = [ base directory filepath unix ]; description = "Process libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "process-listlike" = callPackage @@ -198172,6 +207966,8 @@ self: { ]; description = "Process extras"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "process-progress" = callPackage @@ -198188,6 +207984,7 @@ self: { ]; description = "Run a process and do reportsing on its progress"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "process-qq" = callPackage @@ -198204,6 +208001,7 @@ self: { ]; description = "Quasi-Quoters for exec process"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "process-sequential" = callPackage @@ -198246,6 +208044,7 @@ self: { ]; description = "Streaming interface to system processes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "processing" = callPackage @@ -198264,6 +208063,8 @@ self: { ]; description = "Web graphic applications with processing.js."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "processing-for-haskell" = callPackage @@ -198291,6 +208092,8 @@ self: { libraryHaskellDepends = [ base binary bytestring process ]; description = "C bindings for the gnu-extension functions process_vm_readv and process_vm_writev"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "processor-creative-kit" = callPackage @@ -198329,6 +208132,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell values that cannot be evaluated immediately"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "procstat" = callPackage @@ -198340,6 +208145,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring ]; description = "get information on processes in Linux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proctest" = callPackage @@ -198375,6 +208182,7 @@ self: { ]; description = "Simple streaming datatype"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "product" = callPackage @@ -198431,6 +208239,8 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Generate flamegraphs from ghc RTS .prof files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prof2dot" = callPackage @@ -198446,6 +208256,7 @@ self: { ]; description = "Convert GHC profiles into GraphViz's dot format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "prof2pretty" = callPackage @@ -198464,6 +208275,8 @@ self: { ]; description = "generate pretty source from time/allocation profiles"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "profiterole" = callPackage @@ -198552,6 +208365,8 @@ self: { ]; description = "Monadic bidirectional programming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "profunctor-optics" = callPackage @@ -198621,6 +208436,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "Simple progress tracking & projection library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "progress-meter" = callPackage @@ -198632,6 +208449,8 @@ self: { libraryHaskellDepends = [ ansi-terminal async base stm ]; description = "Live diagnostics for concurrent activity"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "progress-reporting" = callPackage @@ -198645,6 +208464,8 @@ self: { libraryHaskellDepends = [ base deepseq mtl time ]; description = "Functionality for reporting function progress"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "progressbar" = callPackage @@ -198658,6 +208479,7 @@ self: { libraryHaskellDepends = [ base io-reactive ]; description = "Progressbar API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "progression" = callPackage @@ -198674,6 +208496,8 @@ self: { ]; description = "Automates the recording and graphing of criterion benchmarks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "progressive" = callPackage @@ -198692,6 +208516,8 @@ self: { ]; description = "Multilabel classification model which learns sequentially (online)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proj4-hs-bindings" = callPackage @@ -198704,6 +208530,8 @@ self: { librarySystemDepends = [ proj ]; description = "Haskell bindings for the Proj4 C dynamic library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) proj;}; "project-m36" = callPackage @@ -198774,6 +208602,7 @@ self: { ]; description = "Relational Algebra Engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "project-template" = callPackage @@ -198814,6 +208643,8 @@ self: { ]; description = "Go to README.md"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "projection" = callPackage @@ -198888,6 +208719,8 @@ self: { ]; description = "A command line tool to visualize query resolution in Prolog"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prolog-graph-lib" = callPackage @@ -198924,6 +208757,7 @@ self: { ]; description = "Better, more general Prelude exporting common utilities"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "prolude" = callPackage @@ -198945,6 +208779,7 @@ self: { ]; description = "ITProTV's custom prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "prometheus" = callPackage @@ -199015,6 +208850,7 @@ self: { benchmarkHaskellDepends = [ base criterion text ]; description = "Instrument applications with metrics and publish/push to Prometheus"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "prometheus-metrics-ghc" = callPackage @@ -199078,6 +208914,8 @@ self: { libraryHaskellDepends = [ async base ]; description = "A monadic interface for async"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "promises" = callPackage @@ -199120,6 +208958,8 @@ self: { ]; description = "A library for interfacing with the CMU Pronouncing Dictionary"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proof-combinators" = callPackage @@ -199131,6 +208971,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Proof Combinators used in Liquid Haskell for Theorem Proving"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "propane" = callPackage @@ -199146,6 +208988,7 @@ self: { ]; description = "Functional synthesis of images and animations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "propeller" = callPackage @@ -199190,6 +209033,8 @@ self: { libraryHaskellDepends = [ base ]; description = "check quickCheck properties in real time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "property" = callPackage @@ -199220,6 +209065,8 @@ self: { ]; description = "Apple property list parser"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proplang" = callPackage @@ -199231,6 +209078,7 @@ self: { libraryHaskellDepends = [ base glade glib gtk ]; description = "A library for functional GUI development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "props" = callPackage @@ -199270,6 +209118,8 @@ self: { ]; description = "A simple language for writing documents"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prosidyc" = callPackage @@ -199286,6 +209136,7 @@ self: { ]; description = "A DSL for processing Prosidy documents"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "prospect" = callPackage @@ -199321,6 +209172,8 @@ self: { ]; description = "Bindings to the Prosper marketplace API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proteaaudio" = callPackage @@ -199339,6 +209192,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Simple audio library for Windows, Linux, OSX"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {libpulse = null; libpulse-simple = null; inherit (pkgs) libpulseaudio;}; @@ -199356,6 +209211,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Simple audio library for SDL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) SDL2;}; "proteome" = callPackage @@ -199431,6 +209288,8 @@ self: { ]; description = "Arbitrary instances for proto-lens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proto-lens-combinators" = callPackage @@ -199452,6 +209311,8 @@ self: { ]; description = "Utilities functions to proto-lens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proto-lens-descriptors" = callPackage @@ -199468,6 +209329,7 @@ self: { ]; description = "Protocol buffers for describing the definitions of messages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "proto-lens-jsonpb" = callPackage @@ -199497,6 +209359,8 @@ self: { ]; description = "Adapting proto-lens to optparse-applicative ReadMs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proto-lens-protobuf-types" = callPackage @@ -199608,6 +209472,7 @@ self: { ]; description = "A low level library for writing out data in the Protocol Buffers wire format"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "proto3-wire" = callPackage @@ -199675,6 +209540,7 @@ self: { ]; description = "Protocol Buffers via C++"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "protobuf-simple" = callPackage @@ -199711,6 +209577,8 @@ self: { libraryHaskellDepends = [ base freer-indexed singletons ]; description = "Model distributed system as type-level multi-party protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "protocol-buffers" = callPackage @@ -199760,6 +209628,7 @@ self: { ]; description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "protocol-buffers-fork" = callPackage @@ -199776,6 +209645,8 @@ self: { ]; description = "Parse Google Protocol Buffer specifications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "protocol-radius" = callPackage @@ -199842,6 +209713,8 @@ self: { ]; description = "Protolude with lifted-base and lifted-async"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proton" = callPackage @@ -199859,6 +209732,7 @@ self: { transformers ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "proton-haskell" = callPackage @@ -199877,6 +209751,8 @@ self: { ]; description = "Simple XML templating library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prototype" = callPackage @@ -199888,6 +209764,8 @@ self: { libraryHaskellDepends = [ base monads-tf ]; description = "prototype-based programming on Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prove-everywhere-server" = callPackage @@ -199908,6 +209786,8 @@ self: { ]; description = "The server for ProveEverywhere"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "provenience" = callPackage @@ -199926,6 +209806,8 @@ self: { ]; description = "Computations that automatically track data dependencies"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proxied" = callPackage @@ -199959,6 +209841,8 @@ self: { libraryHaskellDepends = [ base tagged ]; description = "A library for kind-polymorphic manipulation and inspection of Proxy values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proxy-mapping" = callPackage @@ -199970,6 +209854,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Mapping of Proxy Types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prune-juice" = callPackage @@ -200029,6 +209915,7 @@ self: { ]; description = "Language support for the PureScript programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pseudo-boolean" = callPackage @@ -200066,6 +209953,8 @@ self: { libraryHaskellDepends = [ base semigroups ]; description = "A tagged rose-tree with short circuited unique leaves"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pseudomacros" = callPackage @@ -200203,6 +210092,8 @@ self: { benchmarkHaskellDepends = [ gauge rerebase ]; description = "Pointer poking action construction and composition toolkit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ptrdiff" = callPackage @@ -200283,6 +210174,8 @@ self: { testHaskellDepends = [ base cereal HUnit publicsuffixlist ]; description = "Create the publicsuffixlist package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "publish" = callPackage @@ -200309,6 +210202,8 @@ self: { ]; description = "Publishing tools for papers, books, and presentations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pubnub" = callPackage @@ -200341,6 +210236,8 @@ self: { ]; description = "PubNub Haskell SDK"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pubsub" = callPackage @@ -200359,6 +210256,8 @@ self: { executableHaskellDepends = [ fastcgi ]; description = "A library for Google/SixApart pubsub hub interaction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "puffytools" = callPackage @@ -200388,6 +210287,7 @@ self: { ]; description = "A CLI assistant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pugixml" = callPackage @@ -200404,6 +210304,8 @@ self: { testHaskellDepends = [ base bytestring tasty tasty-hunit ]; description = "pugixml binding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pugs-DrIFT" = callPackage @@ -200427,6 +210329,8 @@ self: { ]; description = "DrIFT with pugs-specific rules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pugs-HsSyck" = callPackage @@ -200459,6 +210363,7 @@ self: { ]; description = "Portable Haskell/POSIX layer for Pugs"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "pugs-hsregex" = callPackage @@ -200470,6 +210375,7 @@ self: { libraryHaskellDepends = [ array base haskell98 ]; description = "Haskell PCRE binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pulse" = callPackage @@ -200526,6 +210432,7 @@ self: { ]; description = "Multilingual unsupervised sentence tokenization with Punkt"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "punycode" = callPackage @@ -200560,6 +210467,7 @@ self: { ]; description = "A program that displays the puppet resources associated to a node given .pp files."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "pure-cdb" = callPackage @@ -200578,6 +210486,7 @@ self: { ]; description = "Another pure-haskell CDB (Constant Database) implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pure-fft" = callPackage @@ -200602,6 +210511,8 @@ self: { libraryHaskellDepends = [ base containers mtl safe ]; description = "Pure IO monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pure-priority-queue" = callPackage @@ -200613,6 +210524,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A pure priority queue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pure-priority-queue-tests" = callPackage @@ -200631,6 +210544,7 @@ self: { ]; description = "Tests for the pure-priority-queue package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pure-shuffle" = callPackage @@ -200671,6 +210585,8 @@ self: { benchmarkHaskellDepends = [ base base-compat bytestring time ]; description = "A Haskell-only implementation of zlib / DEFLATE"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pureMD5" = callPackage @@ -200814,6 +210730,7 @@ self: { doCheck = false; description = "PureScript Programming Language Compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "purescript-ast" = callPackage @@ -200892,6 +210809,8 @@ self: { testToolDepends = [ happy ]; description = "PureScript Programming Language Concrete Syntax Tree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "purescript-iso" = callPackage @@ -200921,6 +210840,7 @@ self: { ]; description = "Isomorphic trivial data type definitions over JSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "purescript-tsd-gen" = callPackage @@ -200943,6 +210863,7 @@ self: { ]; description = "TypeScript Declaration File (.d.ts) generator for PureScript"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pursuit-client" = callPackage @@ -200978,6 +210899,8 @@ self: { ]; description = "Push notifications for Android and iOS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "push-notify" = callPackage @@ -201001,6 +210924,7 @@ self: { ]; description = "A server-side library for sending push notifications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "push-notify-apn" = callPackage @@ -201026,6 +210950,7 @@ self: { testHaskellDepends = [ aeson base hspec ]; description = "Send push notifications to mobile iOS devices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "push-notify-ccs" = callPackage @@ -201045,6 +210970,7 @@ self: { ]; description = "A server-side library for sending/receiving push notifications through CCS (Google Cloud Messaging)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "push-notify-general" = callPackage @@ -201063,6 +210989,7 @@ self: { ]; description = "A general library for sending/receiving push notif. through dif. services."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pushbullet" = callPackage @@ -201111,6 +211038,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "A Pusher.com client written in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pusher-http-haskell" = callPackage @@ -201151,6 +211080,8 @@ self: { ]; description = "Implementation of the Pusher WebSocket protocol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pushme" = callPackage @@ -201176,6 +211107,8 @@ self: { ]; description = "Tool to synchronize directories with rsync, zfs or git-annex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pushover" = callPackage @@ -201212,6 +211145,8 @@ self: { ]; description = "Put-based lens library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "puzzle-draw" = callPackage @@ -201243,6 +211178,7 @@ self: { ]; description = "Creating graphics for pencil puzzles"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "puzzle-draw-cmdline" = callPackage @@ -201261,6 +211197,7 @@ self: { ]; description = "Creating graphics for pencil puzzles, command line tools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "pvar" = callPackage @@ -201298,6 +211235,7 @@ self: { executableSystemDepends = [ libdevil ]; description = "A photo viewer daemon application with remote controlling abilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libdevil;}; "pvss" = callPackage @@ -201402,6 +211340,8 @@ self: { libraryPkgconfigDepends = [ python ]; description = "Call python inline from haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {python = null;}; "pyfi" = callPackage @@ -201418,6 +211358,8 @@ self: { libraryPkgconfigDepends = [ python ]; description = "Call python inline from haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {python = null;}; "python-pickle" = callPackage @@ -201441,6 +211383,8 @@ self: { ]; description = "Serialization/deserialization using Python Pickle format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "q4c12-twofinger" = callPackage @@ -201459,6 +211403,8 @@ self: { ]; description = "Efficient alternating finger trees"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qc-oi-testgenerator" = callPackage @@ -201472,6 +211418,8 @@ self: { ]; description = "Compile time generation of operation invariance tests for QuickCheck"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qchas" = callPackage @@ -201500,6 +211448,8 @@ self: { librarySystemDepends = [ qd ]; description = "double-double and quad-double number type via libqd"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {qd = null;}; "qd-vec" = callPackage @@ -201511,6 +211461,7 @@ self: { libraryHaskellDepends = [ base qd Vec ]; description = "'Vec' instances for 'qd' types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "qed" = callPackage @@ -201529,6 +211480,8 @@ self: { testHaskellDepends = [ base transformers ]; description = "Simple prover"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qhs" = callPackage @@ -201552,6 +211505,7 @@ self: { ]; description = "Command line tool qhs, SQL queries on CSV and TSV files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "qhull-simple" = callPackage @@ -201564,6 +211518,8 @@ self: { librarySystemDepends = [ qhull ]; description = "Simple bindings to Qhull, a library for computing convex hulls"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) qhull;}; "qif" = callPackage @@ -201583,6 +211539,8 @@ self: { ]; description = "A simple QIF file format parser / printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qlinear" = callPackage @@ -201603,6 +211561,8 @@ self: { ]; description = "Typesafe library for linear algebra"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qm-interpolated-string" = callPackage @@ -201650,6 +211610,8 @@ self: { ]; description = "Decrypt files encrypted by QNAP's Hybrid Backup Sync"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qq-literals" = callPackage @@ -201701,6 +211663,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Library to generate images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) qrencode;}; "qr-repa" = callPackage @@ -201720,6 +211684,7 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Library to generate QR codes from bytestrings and objects and scale image files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "qrcode" = callPackage @@ -201775,6 +211740,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "quantity semaphores"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qt" = callPackage @@ -201949,6 +211916,8 @@ self: { executableHaskellDepends = [ base ]; description = "Quant finance library in pure Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quantification" = callPackage @@ -201965,6 +211934,8 @@ self: { ]; description = "Rage against the quantification"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quantities" = callPackage @@ -201996,6 +211967,8 @@ self: { libraryHaskellDepends = [ base MonadRandom mtl QuickCheck random ]; description = "An embedding of quantum computation as a Haskell arrow"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quantum-random" = callPackage @@ -202018,6 +211991,7 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Retrieve, store and manage real quantum random data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "quarantimer" = callPackage @@ -202039,6 +212013,8 @@ self: { ]; description = "Coronavirus quarantine timer web app for your things"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "qudb" = callPackage @@ -202057,6 +212033,8 @@ self: { executableToolDepends = [ alex happy ]; description = "Quite Useless DB"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quenya-verb" = callPackage @@ -202079,6 +212057,8 @@ self: { executableHaskellDepends = [ base ]; description = "Quenya verb conjugator"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "queryparser" = callPackage @@ -202098,6 +212078,7 @@ self: { benchmarkHaskellDepends = [ base criterion text ]; description = "Analysis and parsing library for SQL queries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "queryparser-demo" = callPackage @@ -202114,6 +212095,7 @@ self: { ]; description = "Demo package containing queryparser examples"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "queryparser-hive" = callPackage @@ -202133,6 +212115,7 @@ self: { ]; description = "Parsing for Hive SQL queries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "queryparser-presto" = callPackage @@ -202152,6 +212135,7 @@ self: { ]; description = "Parsing for Presto SQL queries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "queryparser-vertica" = callPackage @@ -202171,6 +212155,7 @@ self: { ]; description = "Parsing for Vertica SQL queries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "querystring-pickle" = callPackage @@ -202204,6 +212189,7 @@ self: { ]; description = "A package for prompting values from the command-line"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "queue" = callPackage @@ -202226,6 +212212,7 @@ self: { libraryHaskellDepends = [ array base containers mtl stateful-mtl ]; description = "A library of queuelike data structures, both functional and stateful"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quick-generator" = callPackage @@ -202256,6 +212243,8 @@ self: { ]; description = "Slimmed down json schema language and validator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickbench" = callPackage @@ -202276,6 +212265,7 @@ self: { testHaskellDepends = [ base ]; description = "quick & easy benchmarking of command-line programs"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "quickbooks" = callPackage @@ -202294,6 +212284,8 @@ self: { ]; description = "QuickBooks API binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-arbitrary-adt" = callPackage @@ -202465,6 +212457,7 @@ self: { ]; description = "Automating QuickCheck for polymorphic and overlaoded properties"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quickcheck-properties" = callPackage @@ -202487,6 +212480,8 @@ self: { libraryHaskellDepends = [ base mtl QuickCheck ]; description = "Combinators for Quickcheck Property construction and diagnostics"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-property-monad" = callPackage @@ -202498,6 +212493,8 @@ self: { libraryHaskellDepends = [ base either QuickCheck transformers ]; description = "A monad for generating QuickCheck properties without Arbitrary instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-regex" = callPackage @@ -202513,6 +212510,7 @@ self: { ]; description = "Generate regex-constrained strings for QuickCheck"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "quickcheck-relaxng" = callPackage @@ -202528,6 +212526,7 @@ self: { ]; description = "Generate RelaxNG-constrained XML documents for QuickCheck"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "quickcheck-rematch" = callPackage @@ -202540,6 +212539,8 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck rematch ]; description = "QuickCheck support for rematch"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-report" = callPackage @@ -202555,6 +212556,8 @@ self: { ]; description = "Customizable reports for quickcheck properties"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-script" = callPackage @@ -202629,6 +212632,7 @@ self: { ]; description = "Test monadic programs using state machine based models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quickcheck-state-machine-distributed" = callPackage @@ -202652,6 +212656,7 @@ self: { ]; description = "Test monadic programs using state machine based models"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "quickcheck-string-random" = callPackage @@ -202713,6 +212718,8 @@ self: { libraryHaskellDepends = [ base QuickCheck transformers webdriver ]; description = "Utilities for using WebDriver with QuickCheck"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-with-counterexamples" = callPackage @@ -202747,6 +212754,8 @@ self: { ]; description = "Wrapper for the QuickJS Javascript Engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quicklz" = callPackage @@ -202779,6 +212788,8 @@ self: { testHaskellDepends = [ base directory filepath QuickCheck ]; description = "Generate Main module with QuickCheck tests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickselect" = callPackage @@ -202804,6 +212815,8 @@ self: { libraryHaskellDepends = [ base vector vector-algorithms ]; description = "Very fast and memory-compact query-only set and map structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickson" = callPackage @@ -202833,6 +212846,8 @@ self: { ]; description = "Equational laws for free!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickterm" = callPackage @@ -202866,6 +212881,7 @@ self: { ]; description = "A reflective batch tester for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quickwebapp" = callPackage @@ -202884,6 +212900,8 @@ self: { ]; description = "A quick webapp generator for any file processing tool"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quiet" = callPackage @@ -202912,6 +212930,7 @@ self: { doHaddock = false; description = "Meta-package for Quipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-algorithms" = callPackage @@ -202935,6 +212954,7 @@ self: { executableHaskellDepends = [ base ]; description = "A set of algorithms implemented in Quipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-all" = callPackage @@ -202950,6 +212970,7 @@ self: { doHaddock = false; description = "Meta-package for Quipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-cabal" = callPackage @@ -202961,6 +212982,7 @@ self: { libraryHaskellDepends = [ base Cabal process quipper-language ]; description = "Some functions to aid in the creation of Cabal packages for Quipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-core" = callPackage @@ -202976,6 +212998,8 @@ self: { ]; description = "An embedded, scalable functional programming language for quantum computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quipper-demos" = callPackage @@ -202996,6 +213020,7 @@ self: { doHaddock = false; description = "Miscellaneous code snippets that illustrate various Quipper features"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-language" = callPackage @@ -203016,6 +213041,7 @@ self: { executableHaskellDepends = [ base process ]; description = "Quipper, an embedded functional programming language for quantum computation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-libraries" = callPackage @@ -203038,6 +213064,7 @@ self: { ]; description = "The standard libraries for Quipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-rendering" = callPackage @@ -203054,6 +213081,7 @@ self: { ]; description = "An embedded, scalable functional programming language for quantum computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-tools" = callPackage @@ -203075,6 +213103,7 @@ self: { doHaddock = false; description = "Miscellaneous stand-alone tools for Quipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quipper-utils" = callPackage @@ -203091,6 +213120,8 @@ self: { ]; description = "Utility libraries for Quipper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quiver" = callPackage @@ -203102,6 +213133,8 @@ self: { libraryHaskellDepends = [ base mmorph transformers ]; description = "Quiver finite stream processing library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quiver-binary" = callPackage @@ -203118,6 +213151,7 @@ self: { testHaskellDepends = [ base hspec QuickCheck quiver transformers ]; description = "Binary serialisation support for Quivers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-bytestring" = callPackage @@ -203129,6 +213163,7 @@ self: { libraryHaskellDepends = [ base bytestring quiver ]; description = "Quiver combinators for bytestring streaming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-cell" = callPackage @@ -203140,6 +213175,7 @@ self: { libraryHaskellDepends = [ base data-cell quiver ]; description = "Quiver combinators for cellular data processing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-csv" = callPackage @@ -203155,6 +213191,7 @@ self: { ]; description = "Quiver combinators for cellular CSV data processing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-enumerator" = callPackage @@ -203166,6 +213203,7 @@ self: { libraryHaskellDepends = [ base enumerator quiver ]; description = "Bridge between Quiver and Iteratee paradigms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-groups" = callPackage @@ -203178,6 +213216,7 @@ self: { testHaskellDepends = [ base hspec QuickCheck quiver ]; description = "Group and chunk values within a Quiver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-http" = callPackage @@ -203195,6 +213234,7 @@ self: { ]; description = "Adapter to stream over HTTP(s) with quiver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-instances" = callPackage @@ -203210,6 +213250,7 @@ self: { ]; description = "Extra instances for Quiver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-interleave" = callPackage @@ -203222,6 +213263,7 @@ self: { testHaskellDepends = [ base hspec QuickCheck quiver ]; description = "Interleave values from multiple Quivers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "quiver-sort" = callPackage @@ -203245,6 +213287,7 @@ self: { ]; description = "Sort the values in a quiver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "quokka" = callPackage @@ -203263,6 +213306,8 @@ self: { ]; description = "Test helpers which help generate data for projects that use postgresql"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quoridor-hs" = callPackage @@ -203287,6 +213332,8 @@ self: { testHaskellDepends = [ base HUnit mtl ]; description = "A Quoridor implementation in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quote-quot" = callPackage @@ -203322,6 +213369,7 @@ self: { ]; description = "Command line binary for working with the Qux language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "r-glpk-phonetic-languages-ukrainian-durations" = callPackage @@ -203425,6 +213473,8 @@ self: { libraryHaskellDepends = [ array base containers data-reify ]; description = "Reverse Automatic Differentiation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "radian" = callPackage @@ -203439,6 +213489,8 @@ self: { testHaskellDepends = [ base HUnit lens ]; description = "Isomorphisms for measurements that use radians"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "radium" = callPackage @@ -203455,6 +213507,8 @@ self: { ]; description = "Chemistry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "radium-formula-parser" = callPackage @@ -203470,6 +213524,8 @@ self: { ]; description = "Chemistry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "radius" = callPackage @@ -203498,6 +213554,8 @@ self: { executableHaskellDepends = [ base filepath ]; description = "Command-line tool for emitting numbers in various bases"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "radix-tree" = callPackage @@ -203566,6 +213624,8 @@ self: { ]; description = "librados haskell bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {rados = null;}; "raft" = callPackage @@ -203584,6 +213644,8 @@ self: { ]; description = "Miscellaneous Haskell utilities for data structures and data manipulation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rail-compiler-editor" = callPackage @@ -203606,6 +213668,7 @@ self: { testHaskellDepends = [ base containers HUnit process ]; description = "Compiler and editor for the esolang rail"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rails-session" = callPackage @@ -203629,6 +213692,7 @@ self: { ]; description = "Decrypt Ruby on Rails sessions in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rainbow" = callPackage @@ -203659,6 +213723,7 @@ self: { ]; description = "Tests and QuickCheck generators to accompany rainbow"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rainbox" = callPackage @@ -203719,6 +213784,7 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "distributed-process node"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "rakhana" = callPackage @@ -203735,6 +213801,8 @@ self: { ]; description = "Stream based PDF library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rakuten" = callPackage @@ -203759,6 +213827,8 @@ self: { ]; description = "The Rakuten API in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ral" = callPackage @@ -203828,6 +213898,7 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "'$' in reverse"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "raml" = callPackage @@ -203843,6 +213914,8 @@ self: { ]; description = "RESTful API Modeling Language (RAML) library for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rampart" = callPackage @@ -203881,6 +213954,8 @@ self: { libraryHaskellDepends = [ array base IntervalMap mtl random ]; description = "Random variable library, with Functor, Applicative and Monad instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "randfile" = callPackage @@ -203899,6 +213974,8 @@ self: { ]; description = "Program for picking a random file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rando" = callPackage @@ -203913,6 +213990,8 @@ self: { ]; description = "Easy-to-use randomness for livecoding"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "random" = callPackage @@ -203986,6 +214065,8 @@ self: { libraryHaskellDepends = [ array base containers ]; description = "Random-access lists in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "random-bytestring" = callPackage @@ -204027,6 +214108,8 @@ self: { libraryHaskellDepends = [ base random template-haskell ]; description = "A Template Haskell helper for deriving Random instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "random-eff" = callPackage @@ -204038,6 +214121,8 @@ self: { libraryHaskellDepends = [ base extensible-effects random ]; description = "A simple random generator library for extensible-effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "random-effin" = callPackage @@ -204049,6 +214134,7 @@ self: { libraryHaskellDepends = [ base effin random ]; description = "A simple random generator library for effin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "random-extras" = callPackage @@ -204127,6 +214213,7 @@ self: { ]; description = "Random variate generation from hypergeometric distributions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "random-names" = callPackage @@ -204195,6 +214282,8 @@ self: { libraryHaskellDepends = [ base binary bytestring random ]; description = "An infinite stream of random data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "random-string" = callPackage @@ -204339,6 +214428,8 @@ self: { ]; description = "Memory efficient sets with ranges of elements"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "range-space" = callPackage @@ -204359,6 +214450,7 @@ self: { ]; description = "A Range type with vector-space instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ranged-list" = callPackage @@ -204383,6 +214475,8 @@ self: { libraryHaskellDepends = [ base containers primitive vector ]; description = "Linear range-min algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ranges" = callPackage @@ -204464,6 +214558,8 @@ self: { ]; description = "Rapid prototyping with GHCi: hot reloading of running components and reload-surviving values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rapid-term" = callPackage @@ -204479,6 +214575,8 @@ self: { ]; description = "External terminal support for rapid"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rasa" = callPackage @@ -204503,6 +214601,7 @@ self: { ]; description = "A modular text editor"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-example-config" = callPackage @@ -204522,6 +214621,7 @@ self: { ]; description = "Example user config for Rasa"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-bufs" = callPackage @@ -204536,6 +214636,7 @@ self: { ]; description = "Rasa Ext for useful buffer utilities"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-cmd" = callPackage @@ -204550,6 +214651,7 @@ self: { ]; description = "Rasa Ext for running commands"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-cursors" = callPackage @@ -204565,6 +214667,7 @@ self: { ]; description = "Rasa Ext adding cursor(s)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-files" = callPackage @@ -204581,6 +214684,7 @@ self: { ]; description = "Rasa Ext for filesystem actions"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-logger" = callPackage @@ -204592,6 +214696,7 @@ self: { libraryHaskellDepends = [ base lens mtl rasa ]; description = "Rasa Ext for logging state/actions"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-slate" = callPackage @@ -204608,6 +214713,7 @@ self: { ]; description = "Rasa extension for rendering to terminal with vty"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-status-bar" = callPackage @@ -204619,6 +214725,7 @@ self: { libraryHaskellDepends = [ base data-default lens rasa yi-rope ]; description = "Rasa Ext for populating status-bar"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-style" = callPackage @@ -204630,6 +214737,7 @@ self: { libraryHaskellDepends = [ base data-default lens rasa ]; description = "Rasa Ext managing rendering styles"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-views" = callPackage @@ -204646,6 +214754,7 @@ self: { ]; description = "Rasa Ext managing rendering views"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rasa-ext-vim" = callPackage @@ -204664,6 +214773,7 @@ self: { testHaskellDepends = [ base hspec ]; description = "Rasa Ext for vim bindings"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rascal" = callPackage @@ -204692,6 +214802,8 @@ self: { ]; description = "A command-line client for Reddit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rasterific-svg" = callPackage @@ -204809,6 +214921,7 @@ self: { benchmarkHaskellDepends = [ base-noprelude gauge relude ]; description = "Client for rating.chgk.info API and CSV tables (documentation in Russian)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rating-systems" = callPackage @@ -204847,6 +214960,8 @@ self: { ]; description = "finite or repeating lists"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rattle" = callPackage @@ -204880,6 +214995,8 @@ self: { ]; description = "Forward build system, with caching and speculation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rattletrap" = callPackage @@ -204900,6 +215017,8 @@ self: { testHaskellDepends = [ base bytestring filepath HUnit ]; description = "Parse and generate Rocket League replays"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "raven-haskell" = callPackage @@ -204935,6 +215054,8 @@ self: { ]; description = "Sentry http interface for Scotty web server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "raw-feldspar" = callPackage @@ -204958,6 +215079,7 @@ self: { ]; description = "Resource-Aware Feldspar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "raw-strings-qq" = callPackage @@ -204999,6 +215121,7 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Anonymous extensible records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rawstring-qm" = callPackage @@ -205027,6 +215150,8 @@ self: { ]; description = "Random Access Zippers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "razom-text-util" = callPackage @@ -205045,6 +215170,7 @@ self: { testHaskellDepends = [ base QuickCheck regex-applicative smaoin ]; description = "Common text/parsing tools for Razom language packages"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "rbpcp-api" = callPackage @@ -205080,6 +215206,7 @@ self: { executableHaskellDepends = [ base bio bytestring containers ]; description = "Mask nucleotide (EST) sequences in Fasta format"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "rbst" = callPackage @@ -205102,6 +215229,8 @@ self: { benchmarkHaskellDepends = [ base gauge mwc-random ]; description = "Randomized Binary Search Trees"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rc" = callPackage @@ -205125,6 +215254,7 @@ self: { ]; description = "Reservoir Computing, fast RNNs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rclient" = callPackage @@ -205140,6 +215270,8 @@ self: { ]; description = "Haskell client for Rserve"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rcu" = callPackage @@ -205233,6 +215365,7 @@ self: { ]; description = "A Haskell wrapper for Rdio's API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rdtsc" = callPackage @@ -205286,6 +215419,8 @@ self: { ]; description = "A binding to React based on the Flux application architecture for GHCJS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "react-flux-servant" = callPackage @@ -205297,6 +215432,7 @@ self: { libraryHaskellDepends = [ aeson base react-flux servant text ]; description = "Allow react-flux stores to send requests to a servant server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "react-haskell" = callPackage @@ -205314,6 +215450,8 @@ self: { ]; description = "Haskell React bindings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "react-tutorial-haskell-server" = callPackage @@ -205331,6 +215469,8 @@ self: { ]; description = "react-tutorial web server"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reaction-logic" = callPackage @@ -205345,6 +215485,8 @@ self: { executableHaskellDepends = [ base mtl QuickCheck ]; description = "pluggable pure logic serializable reactor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reactive" = callPackage @@ -205374,6 +215516,8 @@ self: { testHaskellDepends = [ base containers HUnit old-time stm ]; description = "FRP (functional reactive programming) framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reactive-balsa" = callPackage @@ -205395,6 +215539,7 @@ self: { ]; description = "Programmatically edit MIDI events via ALSA and reactive-banana"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-banana" = callPackage @@ -205417,6 +215562,8 @@ self: { ]; description = "Library for functional reactive programming (FRP)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reactive-banana-automation" = callPackage @@ -205433,6 +215580,7 @@ self: { testHaskellDepends = [ base doctest ]; description = "home (etc) automation using reactive-banana"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-banana-bunch" = callPackage @@ -205448,6 +215596,7 @@ self: { ]; description = "Extend reactive-banana to multiple events per time point"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-banana-gi-gtk" = callPackage @@ -205464,6 +215613,7 @@ self: { testHaskellDepends = [ base ]; description = "Simple reactive programming with GTK GObject Introspection"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-banana-sdl" = callPackage @@ -205480,6 +215630,7 @@ self: { ]; description = "Reactive Banana bindings for SDL"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-banana-sdl2" = callPackage @@ -205492,6 +215643,7 @@ self: { testHaskellDepends = [ base ]; description = "Reactive Banana integration with SDL2"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-banana-threepenny" = callPackage @@ -205506,6 +215658,7 @@ self: { libraryHaskellDepends = [ base reactive-banana threepenny-gui ]; description = "Examples for the reactive-banana library, using threepenny-gui"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-banana-wx" = callPackage @@ -205523,6 +215676,7 @@ self: { ]; description = "Examples for the reactive-banana library, using wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-fieldtrip" = callPackage @@ -205539,6 +215693,7 @@ self: { ]; description = "Connect Reactive and FieldTrip"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-glut" = callPackage @@ -205554,6 +215709,7 @@ self: { ]; description = "Connects Reactive and GLUT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-haskell" = callPackage @@ -205596,6 +215752,7 @@ self: { ]; description = "Process MIDI events via reactive-banana and JACK"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-midyim" = callPackage @@ -205615,6 +215772,7 @@ self: { ]; description = "Process MIDI events via reactive-banana"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reactive-thread" = callPackage @@ -205631,6 +215789,8 @@ self: { ]; description = "Reactive programming via imperative threads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reactivity" = callPackage @@ -205665,6 +215825,7 @@ self: { ]; description = "Reactor - task parallel reactive programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "read-bounded" = callPackage @@ -205676,6 +215837,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Class for reading bounded values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "read-ctags" = callPackage @@ -205698,6 +215861,8 @@ self: { base bytestring containers directory hspec text ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "read-editor" = callPackage @@ -205735,6 +215900,8 @@ self: { testHaskellDepends = [ base containers directory filepath hspec ]; description = "Read IO library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "readability" = callPackage @@ -205755,6 +215922,8 @@ self: { ]; description = "Extracts text of main article from HTML document"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "readable" = callPackage @@ -205808,6 +215977,8 @@ self: { librarySystemDepends = [ ncurses readline ]; description = "An interface to the GNU readline library"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ncurses; inherit (pkgs) readline;}; "readline-statevar" = callPackage @@ -205819,6 +215990,7 @@ self: { libraryHaskellDepends = [ base readline StateVar ]; description = "Readline with variables (setX/getY) wrapped in state vars"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "readme-lhs" = callPackage @@ -205840,6 +216012,8 @@ self: { testHaskellDepends = [ base doctest numhask ]; description = "Literate programming support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "readpyc" = callPackage @@ -205853,6 +216027,7 @@ self: { executableHaskellDepends = [ base bliplib parseargs ]; description = "Read and pretty print Python bytecode (.pyc) files."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "readshp" = callPackage @@ -205870,6 +216045,8 @@ self: { ]; description = "Code for reading ESRI Shapefiles"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "real-day-end" = callPackage @@ -205897,6 +216074,8 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "A really simple XML parser"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reanimate" = callPackage @@ -205933,6 +216112,7 @@ self: { ]; description = "Animation library based on SVGs"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "reanimate-svg" = callPackage @@ -205958,6 +216138,8 @@ self: { ]; description = "SVG file loader and serializer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reason-export" = callPackage @@ -205990,6 +216172,8 @@ self: { libraryHaskellDepends = [ base mtl split template-haskell ]; description = "Lens implementation. It is more small but adequately."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reasonable-operational" = callPackage @@ -206098,6 +216282,8 @@ self: { ]; description = "Anonymous records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "record-aeson" = callPackage @@ -206114,6 +216300,7 @@ self: { testHaskellDepends = [ aeson base-prelude hspec record ]; description = "Instances of \"aeson\" classes for the \"record\" types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "record-dot-preprocessor" = callPackage @@ -206147,6 +216334,8 @@ self: { ]; description = "Generic encoding of records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "record-gl" = callPackage @@ -206170,6 +216359,7 @@ self: { ]; description = "Utilities for working with OpenGL's GLSL shading language and Nikita Volkov's \"Record\"s"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "record-hasfield" = callPackage @@ -206201,6 +216391,7 @@ self: { doHaddock = false; description = "Compiler preprocessor introducing a syntactic extension for anonymous records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "record-syntax" = callPackage @@ -206224,6 +216415,7 @@ self: { ]; description = "A library for parsing and processing the Haskell syntax sprinkled with anonymous records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "record-wrangler" = callPackage @@ -206249,6 +216441,8 @@ self: { libraryHaskellDepends = [ base kinds type-functions ]; description = "A flexible record system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "records-sop" = callPackage @@ -206281,6 +216475,7 @@ self: { ]; description = "Template Haskell declarations for the records package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "recover-rtti" = callPackage @@ -206395,6 +216590,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck template-haskell ]; description = "Auto-generate final encodings and their isomorphisms using Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "red-black-record" = callPackage @@ -206413,6 +216610,8 @@ self: { doHaddock = false; description = "Extensible records and variants indexed by a type-level Red-Black tree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "red-black-tree" = callPackage @@ -206466,6 +216665,7 @@ self: { ]; description = "Library for interfacing with Reddit's API"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "redesigned-carnival" = callPackage @@ -206504,6 +216704,8 @@ self: { libraryHaskellDepends = [ base bytestring network utf8-string ]; description = "A simple Redis library for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "redis-io" = callPackage @@ -206571,6 +216773,8 @@ self: { libraryHaskellDepends = [ base binary bytestring redis ]; description = "Simple redis bindings for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rediscaching-haxl" = callPackage @@ -206598,6 +216802,8 @@ self: { libraryPkgconfigDepends = [ raptor2 redland ]; description = "Redland RDF library bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {raptor2 = null; redland = null;}; "redo" = callPackage @@ -206640,6 +216846,7 @@ self: { ]; description = "Simplify a set of equations by removing redundancies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reducers" = callPackage @@ -206686,6 +216893,8 @@ self: { ]; description = "Reed-Solomon Erasure Coding in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reenact" = callPackage @@ -206699,6 +216908,8 @@ self: { ]; description = "A reimplementation of the Reactive library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reexport-crypto-random" = callPackage @@ -206720,6 +216931,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Generic Mutable Ref Abstraction Layer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ref-extras" = callPackage @@ -206758,6 +216971,8 @@ self: { libraryHaskellDepends = [ base mtl stm transformers ]; description = "A type class for monads with references compatible with the mtl2 library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ref-tf" = callPackage @@ -206801,6 +217016,8 @@ self: { ]; description = "Container with element counts"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reference" = callPackage @@ -206834,6 +217051,8 @@ self: { ]; description = "Selectors for reading and updating data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "refh" = callPackage @@ -206851,6 +217070,7 @@ self: { ]; description = "A command-line tool for pasting to https://www.refheap.com"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "refined" = callPackage @@ -206879,6 +217099,8 @@ self: { libraryHaskellDepends = [ base http-api-data refined text ]; description = "http-api-data instances for refined types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "refinery_0_3_0_0" = callPackage @@ -206941,6 +217163,8 @@ self: { ]; description = "Utilities for the reflection package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflection-without-remorse" = callPackage @@ -207007,6 +217231,7 @@ self: { ]; description = "Continuous animations support for reflex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reflex-backend-socket" = callPackage @@ -207032,6 +217257,7 @@ self: { ]; description = "Reflex bindings for TCP sockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reflex-backend-wai" = callPackage @@ -207052,6 +217278,7 @@ self: { executableHaskellDepends = [ base http-types reflex wai ]; description = "Reflex interface to `wai`"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reflex-basic-host" = callPackage @@ -207072,6 +217299,8 @@ self: { executableHaskellDepends = [ base lens reflex witherable ]; description = "A basic Reflex host for backend work"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-dom" = callPackage @@ -207242,6 +217471,8 @@ self: { ]; description = "Routing and retractable back button for reflex-dom"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-dom-svg" = callPackage @@ -207257,6 +217488,8 @@ self: { ]; description = "Reflex functions for SVG elements"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-dynamic-containers" = callPackage @@ -207279,6 +217512,8 @@ self: { ]; description = "various dynamic containers for Reflex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-external-ref" = callPackage @@ -207305,6 +217540,8 @@ self: { ]; description = "Reflex FRP interface for watching files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-gadt-api" = callPackage @@ -207329,6 +217566,8 @@ self: { ]; description = "Interact with a GADT API in your reflex-dom application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-ghci" = callPackage @@ -207356,6 +217595,7 @@ self: { ]; description = "A GHCi widget library for use in reflex applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reflex-gi-gtk" = callPackage @@ -207381,6 +217621,8 @@ self: { ]; description = "Helper functions to use reflex with gi-gtk"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-gloss" = callPackage @@ -207396,6 +217638,8 @@ self: { ]; description = "An reflex interface for gloss"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-gloss-scene" = callPackage @@ -207423,6 +217667,7 @@ self: { ]; description = "A simple scene-graph using reflex and gloss"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reflex-jsx" = callPackage @@ -207456,6 +217701,8 @@ self: { ]; description = "Reflex bindings for libtelnet"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-localize" = callPackage @@ -207519,6 +217766,8 @@ self: { ]; description = "Useful missing instances for Reflex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-process" = callPackage @@ -207544,6 +217793,7 @@ self: { ]; description = "Reflex FRP interface for running system processes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reflex-sdl2" = callPackage @@ -207563,6 +217813,8 @@ self: { executableHaskellDepends = [ base mtl reflex ]; description = "SDL2 and reflex FRP"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-test-host" = callPackage @@ -207598,6 +217850,8 @@ self: { ]; description = "Collections and switchable Monad transformers for Reflex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-vty" = callPackage @@ -207624,6 +217878,8 @@ self: { ]; description = "Reflex FRP host and widgets for VTY applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reform" = callPackage @@ -207709,6 +217965,8 @@ self: { libraryHaskellDepends = [ base parsec ]; description = "The parser and render to parsec and render the string"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "refractor" = callPackage @@ -207732,6 +217990,8 @@ self: { ]; description = "See README for more info"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "refresht" = callPackage @@ -207747,6 +218007,8 @@ self: { libraryHaskellDepends = [ base data-default exceptions lens mtl ]; description = "Environment Monad with automatic resource refreshment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "refty" = callPackage @@ -207789,6 +218051,7 @@ self: { ]; description = "Tools for maintaining a database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reg-alloc" = callPackage @@ -207802,6 +218065,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Register allocation API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reg-alloc-graph-color" = callPackage @@ -207825,6 +218090,7 @@ self: { doHaddock = false; description = "Register allocation by graph colorization"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "reg-alloc-types" = callPackage @@ -207943,6 +218209,7 @@ self: { ]; description = "Replaces/Enhances Text.Regex. Implementing regular expression matching using Brzozowski's Deriviatives"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regex-dfa" = callPackage @@ -207956,6 +218223,8 @@ self: { libraryHaskellDepends = [ base mtl parsec regex-base ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-do" = callPackage @@ -208044,6 +218313,8 @@ self: { ]; description = "Generate a random string from a PCRE"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-genex" = callPackage @@ -208076,6 +218347,8 @@ self: { libraryHaskellDepends = [ base parsec regex-base ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-pcre" = callPackage @@ -208125,6 +218398,7 @@ self: { ]; description = "Text-based PCRE API for regex-base"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regex-pderiv" = callPackage @@ -208141,6 +218415,7 @@ self: { ]; description = "Replaces/Enhances Text.Regex. Implementing regular expression matching using Antimirov's partial derivatives."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regex-posix" = callPackage @@ -208185,6 +218460,8 @@ self: { ]; description = "Unit tests for the plaform's Posix regex library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-tdfa" = callPackage @@ -208221,6 +218498,8 @@ self: { ]; description = "Parse with regular expressions on Producers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-tdfa-quasiquoter" = callPackage @@ -208232,6 +218511,8 @@ self: { libraryHaskellDepends = [ base regex-tdfa template-haskell ]; description = "Quasi-quoter for TDFA (extended POSIX) regular expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-tdfa-rc" = callPackage @@ -208249,6 +218530,8 @@ self: { ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-tdfa-text" = callPackage @@ -208262,6 +218545,8 @@ self: { libraryHaskellDepends = [ array base regex-base regex-tdfa text ]; description = "Text interface for regex-tdfa"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-tdfa-unittest" = callPackage @@ -208280,6 +218565,8 @@ self: { ]; description = "Unit tests for the regex-tdfa"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-tdfa-utf8" = callPackage @@ -208297,6 +218584,8 @@ self: { ]; description = "This combines regex-tdfa with utf8-string to allow searching over UTF8 encoded lazy bytestrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-tre" = callPackage @@ -208311,6 +218600,8 @@ self: { librarySystemDepends = [ tre ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) tre;}; "regex-type" = callPackage @@ -208322,6 +218613,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Type-level regular expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regex-with-pcre" = callPackage @@ -208369,6 +218662,7 @@ self: { libraryHaskellDepends = [ base haskell98 parsec ]; description = "A regular expression library for W3C XML Schema regular expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regexchar" = callPackage @@ -208424,6 +218718,7 @@ self: { ]; description = "Regular Expressions on Tries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regexpr" = callPackage @@ -208447,6 +218742,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Regular expressions via symbolic manipulation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regexqq" = callPackage @@ -208460,6 +218757,8 @@ self: { ]; description = "A quasiquoter for PCRE regexes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regional-pointers" = callPackage @@ -208474,6 +218773,7 @@ self: { ]; description = "Regional memory pointers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regions" = callPackage @@ -208489,6 +218789,8 @@ self: { ]; description = "Provides the region monad for safely opening and working with scarce resources"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regions-monadsfd" = callPackage @@ -208504,6 +218806,7 @@ self: { ]; description = "Monads-fd instances for the RegionT monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regions-monadstf" = callPackage @@ -208519,6 +218822,7 @@ self: { ]; description = "Monads-tf instances for the RegionT monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regions-mtl" = callPackage @@ -208530,6 +218834,7 @@ self: { libraryHaskellDepends = [ base-unicode-symbols mtl regions ]; description = "mtl instances for the RegionT monad transformer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "register-machine-typelevel" = callPackage @@ -208541,6 +218846,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A computationally universal register machine implementation at the type-level"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "registry" = callPackage @@ -208568,6 +218875,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "data structure for assembling components"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "registry-hedgehog" = callPackage @@ -208593,6 +218902,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "utilities to work with Hedgehog generators and `registry`"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "regress" = callPackage @@ -208604,6 +218914,8 @@ self: { libraryHaskellDepends = [ ad base vector ]; description = "Linear and logistic regression through automatic differentiation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regression-simple" = callPackage @@ -208615,6 +218927,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "Simple linear and quadratic regression"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regular" = callPackage @@ -208628,6 +218942,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Generic programming library for regular datatypes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "regular-extras" = callPackage @@ -208639,6 +218955,7 @@ self: { libraryHaskellDepends = [ base binary deepseq QuickCheck regular ]; description = "Additional functions for regular: arbitrary, coarbitrary, and binary get/put"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regular-web" = callPackage @@ -208654,6 +218971,7 @@ self: { ]; description = "Generic programming for the web"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "regular-xmlpickler" = callPackage @@ -208665,6 +218983,7 @@ self: { libraryHaskellDepends = [ base hxt regular text ]; description = "Generic generation of HXT XmlPickler instances using Regular"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reheat" = callPackage @@ -208679,6 +218998,7 @@ self: { testHaskellDepends = [ base directory QuickCheck text vty vty-ui ]; description = "to make notes and reduce impact on idle time on writing other programms"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "rehoo" = callPackage @@ -208696,6 +219016,8 @@ self: { ]; description = "Rebuild default.hoo from many .hoo files in the current directory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rei" = callPackage @@ -208713,6 +219035,8 @@ self: { ]; description = "Process lists easily"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reified-records" = callPackage @@ -208724,6 +219048,8 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Reify records to Maps and back again"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reify" = callPackage @@ -208739,6 +219065,8 @@ self: { executableHaskellDepends = [ base ghc ]; description = "Serialize data"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reinterpret-cast" = callPackage @@ -208765,6 +219093,8 @@ self: { libraryHaskellDepends = [ array base containers ]; description = "A relation data structure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "relapse" = callPackage @@ -208783,6 +219113,8 @@ self: { ]; description = "Sensible RLP encoding"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "relation" = callPackage @@ -208820,6 +219152,8 @@ self: { ]; description = "PostgreSQL v8.x driver for haskell-relational-record"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "relational-query" = callPackage @@ -208894,6 +219228,8 @@ self: { ]; description = "The connector of relational-record and postgresql-pure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "relational-record" = callPackage @@ -208964,6 +219300,7 @@ self: { ]; description = "Durations and generalized time parsing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "releaser" = callPackage @@ -208994,6 +219331,8 @@ self: { libraryHaskellDepends = [ aeson base chronos text torsor ]; description = "humanised relevant time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reliable-io" = callPackage @@ -209053,6 +219392,8 @@ self: { ]; description = "A web based Haskell IDE"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "relude" = callPackage @@ -209115,6 +219456,8 @@ self: { ]; description = "A DSL for marking student work"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "remarks" = callPackage @@ -209136,6 +219479,8 @@ self: { ]; description = "A DSL for marking student work"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rematch" = callPackage @@ -209177,6 +219522,8 @@ self: { ]; description = "Cloud Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "remote-debugger" = callPackage @@ -209192,6 +219539,8 @@ self: { ]; description = "Interface to ghci debugger"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "remote-json" = callPackage @@ -209216,6 +219565,7 @@ self: { ]; description = "Remote Monad implementation of the JSON RPC protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "remote-json-client" = callPackage @@ -209233,6 +219583,7 @@ self: { ]; description = "Web client wrapper for remote-json"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "remote-json-server" = callPackage @@ -209250,6 +219601,7 @@ self: { ]; description = "Web server wrapper for remote-json"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "remote-monad" = callPackage @@ -209272,6 +219624,8 @@ self: { ]; description = "An parametrizable Remote Monad, and parametrizable Applicative Functor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "remotion" = callPackage @@ -209304,6 +219658,7 @@ self: { ]; description = "A library for client-server applications based on custom protocols"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "render-utf8" = callPackage @@ -209354,6 +219709,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Reorder expressions in a syntax tree according to operator fixities"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reorderable" = callPackage @@ -209400,6 +219757,8 @@ self: { libraryHaskellDepends = [ base repa vector ]; description = "Algorithms using the Repa array library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repa-array" = callPackage @@ -209417,6 +219776,7 @@ self: { ]; description = "Bulk array representations and operators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-bytestring" = callPackage @@ -209429,6 +219789,8 @@ self: { doHaddock = false; description = "(deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repa-convert" = callPackage @@ -209444,6 +219806,7 @@ self: { ]; description = "Packing and unpacking flat tables"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-devil" = callPackage @@ -209456,6 +219819,8 @@ self: { librarySystemDepends = [ libdevil ]; description = "Support for image reading and writing of Repa arrays using in-place FFI calls"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libdevil;}; "repa-eval" = callPackage @@ -209467,6 +219832,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Low-level parallel operators on bulk random-accessble arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repa-examples" = callPackage @@ -209487,6 +219854,7 @@ self: { ]; description = "Examples using the Repa array library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-fftw" = callPackage @@ -209525,6 +219893,7 @@ self: { ]; description = "Data-parallel data flows"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-io" = callPackage @@ -209553,6 +219922,8 @@ self: { libraryHaskellDepends = [ base hmatrix repa vector ]; description = "HMatrix operations for Repa"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repa-plugin" = callPackage @@ -209569,6 +219940,7 @@ self: { ]; description = "Data Flow Fusion GHC Plugin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-scalar" = callPackage @@ -209586,6 +219958,8 @@ self: { ]; description = "Scalar data types and conversions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repa-series" = callPackage @@ -209597,6 +219971,8 @@ self: { libraryHaskellDepends = [ base ghc ghc-prim vector ]; description = "Series Expressionss API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repa-sndfile" = callPackage @@ -209626,6 +220002,7 @@ self: { libraryHaskellDepends = [ base mtl primitive repa-scalar vector ]; description = "Stream functions not present in the vector library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-v4l2" = callPackage @@ -209645,6 +220022,7 @@ self: { executableHaskellDepends = [ base gloss repa ]; description = "Provides high-level access to webcams"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "repl" = callPackage @@ -209658,6 +220036,8 @@ self: { ]; description = "IRC friendly REPL library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repl-toolkit" = callPackage @@ -209728,6 +220108,8 @@ self: { wai-websockets websockets ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "replicant" = callPackage @@ -209754,6 +220136,7 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repline" = callPackage @@ -209798,6 +220181,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Blogging module using blaze html for markup"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repr" = callPackage @@ -209813,6 +220198,7 @@ self: { ]; description = "Render overloaded expressions to their textual representation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repr-tree-syb" = callPackage @@ -209842,6 +220228,8 @@ self: { ]; description = "Representable functors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "representable-profunctors" = callPackage @@ -209872,6 +220260,7 @@ self: { ]; description = "Tries from representations of polynomial functors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "reprinter" = callPackage @@ -209901,6 +220290,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Define and combine \"materialized\" projections"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "req" = callPackage @@ -209956,6 +220347,8 @@ self: { ]; description = "Conduit helpers for the req HTTP client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "req-oauth2" = callPackage @@ -209978,6 +220371,7 @@ self: { testHaskellDepends = [ base hspec ]; description = "Provides OAuth2 authentication for use with Req"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "req-url-extra" = callPackage @@ -209993,6 +220387,8 @@ self: { testHaskellDepends = [ base hspec modern-uri req ]; description = "Provides URI/URL helper functions for use with Req"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reqcatcher" = callPackage @@ -210009,6 +220405,8 @@ self: { ]; description = "A local http server to catch the HTTP redirect"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "request" = callPackage @@ -210035,6 +220433,8 @@ self: { libraryHaskellDepends = [ base free mtl transformers ]; description = "A transformer for generic requests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "require" = callPackage @@ -210202,6 +220602,8 @@ self: { ]; description = "Reserve reloads web applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reservoir" = callPackage @@ -210213,6 +220615,8 @@ self: { libraryHaskellDepends = [ base containers random ]; description = "Unweighted reservoir sampling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "resin" = callPackage @@ -210224,6 +220628,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ralist semigroupoids ]; description = "High performance variable binders"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "resistor-cube" = callPackage @@ -210237,6 +220643,7 @@ self: { executableHaskellDepends = [ base comfort-array lapack ]; description = "Compute total resistance of a cube of resistors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "resolv_0_1_1_2" = callPackage @@ -210293,6 +220700,8 @@ self: { ]; description = "A name resolusion library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "resolve-trivial-conflicts" = callPackage @@ -210311,6 +220720,8 @@ self: { ]; description = "Remove trivial conflict markers in a git repository"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "resource-effect" = callPackage @@ -210329,6 +220740,8 @@ self: { ]; description = "A port of the package 'resourcet' for extensible effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "resource-embed" = callPackage @@ -210342,6 +220755,8 @@ self: { executableHaskellDepends = [ base bytestring directory ]; description = "Embed data files via C and FFI"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "resource-pool" = callPackage @@ -210374,6 +220789,7 @@ self: { ]; description = "Fork of resource-pool, with a MonadCatchIO constraint"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "resource-pool-monad" = callPackage @@ -210405,6 +220821,7 @@ self: { ]; description = "Allocate resources which are guaranteed to be released"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "resourcet" = callPackage @@ -210460,6 +220877,7 @@ self: { ]; description = "process and route HTTP requests and generate responses on top of WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-client" = callPackage @@ -210481,6 +220899,7 @@ self: { ]; description = "Utility library for use in generated API client libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-core" = callPackage @@ -210508,6 +220927,7 @@ self: { ]; description = "Rest API library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-example" = callPackage @@ -210530,6 +220950,7 @@ self: { executableHaskellDepends = [ base base-compat rest-gen ]; description = "Example project for rest"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-gen" = callPackage @@ -210557,6 +220978,7 @@ self: { ]; description = "Documentation and client generation from rest definition"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-happstack" = callPackage @@ -210574,6 +220996,7 @@ self: { ]; description = "Rest driver for Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-snap" = callPackage @@ -210591,6 +221014,7 @@ self: { ]; description = "Rest driver for Snap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-stringmap" = callPackage @@ -210607,6 +221031,7 @@ self: { ]; description = "Maps with stringy keys that can be transcoded to JSON and XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-types" = callPackage @@ -210626,6 +221051,7 @@ self: { ]; description = "Silk Rest Framework Types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rest-wai" = callPackage @@ -210645,6 +221071,7 @@ self: { ]; description = "Rest driver for WAI applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "restartable" = callPackage @@ -210656,6 +221083,8 @@ self: { libraryHaskellDepends = [ aeson base bytestring unix ]; description = "Minimal live coding library for model-view-event-update applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "restful-snap" = callPackage @@ -210675,6 +221104,7 @@ self: { time-locale-compat xmlhtml ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "restless-git" = callPackage @@ -210711,6 +221141,7 @@ self: { ]; description = "Running worker processes under system resource restrictions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "restyle" = callPackage @@ -210725,6 +221156,8 @@ self: { executableHaskellDepends = [ base directory filepath utf8-string ]; description = "Convert between camel case and separated words style"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "result" = callPackage @@ -210772,6 +221205,8 @@ self: { benchmarkHaskellDepends = [ aeson async base criterion text ]; description = "A driver for RethinkDB 2.2"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rethinkdb-client-driver" = callPackage @@ -210800,6 +221235,8 @@ self: { ]; description = "Client driver for RethinkDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rethinkdb-model" = callPackage @@ -210815,6 +221252,7 @@ self: { ]; description = "Useful tools for modeling data with rethinkdb"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rethinkdb-wereHamster" = callPackage @@ -210834,6 +221272,8 @@ self: { ]; description = "RethinkDB driver for Haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "retrie" = callPackage @@ -210895,6 +221335,8 @@ self: { executableHaskellDepends = [ base optparse-applicative process ]; description = "Retry failed commands"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rev-state" = callPackage @@ -210959,6 +221401,8 @@ self: { ]; description = "Simple reverse geocoding using OpenStreeMap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reversi" = callPackage @@ -210972,6 +221416,8 @@ self: { executableHaskellDepends = [ array base process ]; description = "Text-only reversi (aka othelo) game"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rewrite" = callPackage @@ -210987,6 +221433,7 @@ self: { ]; description = "open file and rewrite it with new contents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rewrite-inspector" = callPackage @@ -211006,6 +221453,8 @@ self: { executableHaskellDepends = [ base prettyprinter ]; description = "Inspection of rewriting steps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rewriting" = callPackage @@ -211017,6 +221466,7 @@ self: { libraryHaskellDepends = [ base containers regular ]; description = "Generic rewriting library for regular datatypes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rex" = callPackage @@ -211052,6 +221502,7 @@ self: { ]; description = "Github resume generator"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "rfc" = callPackage @@ -211085,6 +221536,7 @@ self: { ]; description = "Robert Fischer's Common library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rfc-env" = callPackage @@ -211096,6 +221548,7 @@ self: { libraryHaskellDepends = [ base envy network rfc-prelude time ]; description = "Environment variable support from the Robert Fischer Commons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rfc-http-client" = callPackage @@ -211113,6 +221566,7 @@ self: { ]; description = "The HTTP client extensions from the Robert Fischer Commons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rfc-prelude" = callPackage @@ -211136,6 +221590,8 @@ self: { ]; description = "The Prelude from the Robert Fischer Commons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rfc-psql" = callPackage @@ -211152,6 +221608,7 @@ self: { ]; description = "The PostgreSQL extensions from the Robert Fischer Commons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rfc-redis" = callPackage @@ -211163,6 +221620,7 @@ self: { libraryHaskellDepends = [ base hedis rfc-env rfc-prelude time ]; description = "The Redis extensions from the Robert Fischer Commons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rfc-servant" = callPackage @@ -211184,6 +221642,7 @@ self: { ]; description = "The Servant extensions from the Robert Fischer Commons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rfc1413-server" = callPackage @@ -211298,6 +221757,8 @@ self: { testHaskellDepends = [ base simple-cmd ]; description = "Bugzilla query tool"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rhine" = callPackage @@ -211349,6 +221810,7 @@ self: { ]; description = "Haskell rhythm game tutorial"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "riak" = callPackage @@ -211450,6 +221912,7 @@ self: { ]; description = "Static site generator based on Shake"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rib-core" = callPackage @@ -211482,6 +221945,8 @@ self: { libraryHaskellDepends = [ base Only postgresql-simple text time ]; description = "Type-level Relational DB combinators"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ribosome" = callPackage @@ -211609,6 +222074,8 @@ self: { ]; description = "Quick metrics to grow your app strong"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ridley-extras" = callPackage @@ -211626,6 +222093,7 @@ self: { testHaskellDepends = [ base ]; description = "Handy metrics that don't belong to ridley"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "riemann" = callPackage @@ -211655,6 +222123,8 @@ self: { ]; description = "A Riemann client for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "riff" = callPackage @@ -211673,6 +222143,8 @@ self: { executableHaskellDepends = [ base bytestring filepath ]; description = "RIFF parser for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rigel-viz" = callPackage @@ -211703,6 +222175,8 @@ self: { testHaskellDepends = [ base HUnit QuickCheck vector ]; description = "A concurrent, mutable ring-buffer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ring-buffers" = callPackage @@ -211831,6 +222305,7 @@ self: { ]; description = "A library for process pools coupled with asynchronous message queues"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "riot" = callPackage @@ -211850,6 +222325,7 @@ self: { executableSystemDepends = [ ncurses ]; description = "Riot is an Information Organisation Tool"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) ncurses;}; "ripple" = callPackage @@ -211907,6 +222383,7 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "RISC-V"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "risc386" = callPackage @@ -211936,6 +222413,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Haskell representation of the RISC-V instruction set architecture"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rison" = callPackage @@ -211967,6 +222446,8 @@ self: { libraryHaskellDepends = [ base lazysmallcheck oeis QuickCheck ]; description = "Rivers are like Streams, but different"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rivet" = callPackage @@ -211980,6 +222461,7 @@ self: { executableHaskellDepends = [ base rivet-core rivet-simple-deploy ]; description = "A project management tool for Haskell applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rivet-adaptor-postgresql" = callPackage @@ -212027,6 +222509,8 @@ self: { libraryHaskellDepends = [ base postgresql-simple text ]; description = "Postgresql migration support for project management tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rivet-simple-deploy" = callPackage @@ -212038,6 +222522,8 @@ self: { libraryHaskellDepends = [ base configurator mtl rivet-core text ]; description = "Basic deployment support for project management tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rl-satton" = callPackage @@ -212063,6 +222549,8 @@ self: { ]; description = "Collection of Reinforcement Learning algorithms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rlglue" = callPackage @@ -212085,6 +222573,8 @@ self: { ]; description = "A Haskell codec for RL-Glue"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rlist" = callPackage @@ -212120,6 +222610,7 @@ self: { executableHaskellDepends = [ ansi-terminal base options time ]; description = "Ring-LWE/LWR challenges using Lol"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "rmonad" = callPackage @@ -212136,6 +222627,7 @@ self: { ]; description = "Restricted monad library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rncryptor" = callPackage @@ -212164,6 +222656,7 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion ]; description = "Haskell implementation of the RNCryptor file format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rng-utils" = callPackage @@ -212202,6 +222695,7 @@ self: { testHaskellDepends = [ base directory ]; description = "Simple projects generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "robin" = callPackage @@ -212221,6 +222715,8 @@ self: { ]; description = "A build daemon for Haskell development"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "roboservant" = callPackage @@ -212275,6 +222771,8 @@ self: { ]; description = "Parser for robots.txt"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "roc-cluster" = callPackage @@ -212289,6 +222787,8 @@ self: { testHaskellDepends = [ base hspec HUnit ]; description = "ROC online clustering algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "roc-cluster-demo" = callPackage @@ -212306,6 +222806,7 @@ self: { ]; description = "Gloss interactive demo for roc-cluster package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "roc-id" = callPackage @@ -212350,6 +222851,7 @@ self: { ]; description = "A build system for incremental, parallel, and demand-driven computations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rocksdb-haskell" = callPackage @@ -212497,6 +222999,8 @@ self: { ]; description = "Bindings to Roku's External Control API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "roles" = callPackage @@ -212524,6 +223028,8 @@ self: { ]; description = "error tracking through rollbar.com"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rollbar-cli" = callPackage @@ -212541,6 +223047,7 @@ self: { testHaskellDepends = [ base ]; description = "Simple CLI tool to perform commons tasks such as tracking deploys"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rollbar-client" = callPackage @@ -212564,6 +223071,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Core library to communicate with Rollbar API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rollbar-hs" = callPackage @@ -212586,6 +223095,8 @@ self: { ]; description = "Core Rollbar data types and APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rollbar-wai" = callPackage @@ -212610,6 +223121,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Provides error reporting capabilities to WAI based applications through Rollbar API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "rollbar-yesod" = callPackage @@ -212631,6 +223143,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Provides error reporting capabilities to Yesod applications through Rollbar API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "roller" = callPackage @@ -212651,6 +223164,8 @@ self: { ]; description = "Playing with applicatives and dice!"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rolling-queue" = callPackage @@ -212727,6 +223242,8 @@ self: { ]; description = "Replicated Data Types (RON-RDT)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ron-schema" = callPackage @@ -212744,6 +223261,7 @@ self: { ]; description = "RON-Schema"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ron-storage" = callPackage @@ -212761,6 +223279,7 @@ self: { ]; description = "RON Storage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "roots" = callPackage @@ -212785,6 +223304,8 @@ self: { ]; description = "Tools for manipulating fingertrees of bytestrings with optional annotations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rope-utf16-splay" = callPackage @@ -212863,6 +223384,8 @@ self: { ]; description = "Various trie implementations in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rose-trie" = callPackage @@ -212878,6 +223401,7 @@ self: { ]; description = "Trees with polymorphic paths to nodes, combining properties of Rose Trees and Tries"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "rosebud" = callPackage @@ -212893,6 +223417,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Common rose tree/forest functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rosezipper" = callPackage @@ -212936,6 +223462,7 @@ self: { ]; description = "Haskell support for the ROS robotics framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rosmsg" = callPackage @@ -212953,6 +223480,8 @@ self: { ]; description = "ROS message parser, render, TH"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rosmsg-bin" = callPackage @@ -212970,6 +223499,7 @@ self: { ]; description = "ROS message management tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rospkg" = callPackage @@ -213001,6 +223531,8 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "General purpose utility library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rot13" = callPackage @@ -213032,6 +223564,8 @@ self: { ]; description = "Size-limited, concurrent, automatically-rotating log writer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "roundRobin" = callPackage @@ -213090,6 +223624,7 @@ self: { ]; description = "Directed rounding for built-in floating types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rounding" = callPackage @@ -213101,6 +223636,8 @@ self: { libraryHaskellDepends = [ array base numeric-extras ]; description = "Explicit floating point rounding mode wrappers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "roundtrip" = callPackage @@ -213136,6 +223673,8 @@ self: { ]; description = "Un-/parse JSON with roundtrip invertible syntax definitions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "roundtrip-string" = callPackage @@ -213168,6 +223707,7 @@ self: { ]; description = "Bidirectional (de-)serialization for XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "route-generator" = callPackage @@ -213202,6 +223742,7 @@ self: { ]; description = "A library and utilities for creating a route"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "row" = callPackage @@ -213271,6 +223812,8 @@ self: { libraryHaskellDepends = [ base containers template-haskell ]; description = "Build records from lists of strings, as from CSV files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rpc" = callPackage @@ -213287,6 +223830,7 @@ self: { ]; description = "type safe rpcs provided as basic IO actions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rpc-framework" = callPackage @@ -213305,6 +223849,8 @@ self: { executableHaskellDepends = [ base ]; description = "a remote procedure call framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rpf" = callPackage @@ -213324,6 +223870,7 @@ self: { ]; description = "Receiver Policy Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rpm" = callPackage @@ -213337,6 +223884,8 @@ self: { libraryHaskellDepends = [ base directory filepath HaXml process ]; description = "Cozy little project to question unruly rpm packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rpmbuild-order" = callPackage @@ -213360,6 +223909,8 @@ self: { testHaskellDepends = [ base extra hspec simple-cmd unix ]; description = "Order RPM packages by dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rrule" = callPackage @@ -213376,6 +223927,8 @@ self: { testHaskellDepends = [ base hspec text ]; description = "Recurrence rule parser and formatter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rsagl" = callPackage @@ -213395,6 +223948,7 @@ self: { ]; description = "The RogueStar Animation and Graphics Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rsagl-frp" = callPackage @@ -213410,6 +223964,7 @@ self: { ]; description = "The RogueStar Animation and Graphics Library: Functional Reactive Programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rsagl-math" = callPackage @@ -213426,6 +223981,7 @@ self: { ]; description = "The RogueStar Animation and Graphics Library: Mathematics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rset" = callPackage @@ -213450,6 +224006,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A Rational Street Performer Protocol solver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rss" = callPackage @@ -213463,6 +224021,8 @@ self: { libraryHaskellDepends = [ base HaXml network network-uri time ]; description = "A library for generating RSS 2.0 feeds."; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rss-conduit" = callPackage @@ -213516,6 +224076,8 @@ self: { ]; description = "watches an RSS/Atom feed and writes it to an IRC channel"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rstream" = callPackage @@ -213527,6 +224089,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "stream-fusion framework from vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rtcm" = callPackage @@ -213555,6 +224119,7 @@ self: { ]; description = "Haskell bindings for RTCM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "rtld" = callPackage @@ -213605,6 +224170,8 @@ self: { ]; description = "Manipulate network devices, addresses, and routes on Linux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rtorrent-rpc" = callPackage @@ -213621,6 +224188,8 @@ self: { ]; description = "A library for communicating with RTorrent over its XML-RPC interface"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rtorrent-state" = callPackage @@ -213660,6 +224229,8 @@ self: { executableHaskellDepends = [ base Cabal process ]; description = "Dynamically load Haskell libraries"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rubberband" = callPackage @@ -213698,6 +224269,8 @@ self: { ]; description = "Parse a subset of Ruby objects serialised with Marshal.dump."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ruby-qq" = callPackage @@ -213714,6 +224287,8 @@ self: { ]; description = "rubyish quasiquoters"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ruff" = callPackage @@ -213725,6 +224300,8 @@ self: { libraryHaskellDepends = [ array base mtl parsec safe strict Vec ]; description = "relatively useful fractal functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ruin" = callPackage @@ -213746,6 +224323,8 @@ self: { ]; description = "Pliable records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ruler" = callPackage @@ -213764,6 +224343,7 @@ self: { ]; description = "Ruler tool for UHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ruler-core" = callPackage @@ -213781,6 +224361,7 @@ self: { uulib ]; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "run-haskell-module" = callPackage @@ -213814,6 +224395,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A collection of explicit Runge-Kutta methods of various orders"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "runghc" = callPackage @@ -213850,6 +224433,8 @@ self: { testHaskellDepends = [ base directory hspec process ]; description = "Stack wrapper for single-file Haskell programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "runmany" = callPackage @@ -213867,6 +224452,8 @@ self: { ]; description = "Run multiple commands, interleaving output and errors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "runmemo" = callPackage @@ -213889,6 +224476,7 @@ self: { libraryHaskellDepends = [ base ifcxt QuickCheck template-haskell ]; description = "Runtime generation of Arbitrary values"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "rv" = callPackage @@ -213952,6 +224540,8 @@ self: { ]; description = "Packet Generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rz-pipe" = callPackage @@ -214011,6 +224601,7 @@ self: { executableHaskellDepends = [ base ]; description = "simple general-purpose s-expressions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "s3-signer" = callPackage @@ -214070,6 +224661,8 @@ self: { ]; description = "A monadic buffer resilient to exceptions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-coerce" = callPackage @@ -214081,6 +224674,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A friendly shorthand for an old friend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-coloured-text" = callPackage @@ -214189,6 +224784,8 @@ self: { libraryHaskellDepends = [ base indexed mtl vector ]; description = "Support for safely freezing multiple arrays in the ST monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-globals" = callPackage @@ -214200,6 +224797,8 @@ self: { libraryHaskellDepends = [ base stm template-haskell ]; description = "Safe top-level mutable variables which scope like ordinary values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-json" = callPackage @@ -214238,6 +224837,8 @@ self: { ]; description = "A library providing safe lazy IO features"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-length" = callPackage @@ -214255,6 +224856,8 @@ self: { ]; description = "Tired of accidentally calling length on tuples? Relief at last!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-money" = callPackage @@ -214373,6 +224976,7 @@ self: { testHaskellDepends = [ base containers doctest ]; description = "Safe arithmetic operations"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "safe-plugins" = callPackage @@ -214388,6 +224992,8 @@ self: { ]; description = "A small wrapper over hs-plugins to allow loading safe plugins"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-printf" = callPackage @@ -214407,6 +225013,8 @@ self: { ]; description = "Well-typed, flexible and variadic printf for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safe-tensor" = callPackage @@ -214462,6 +225070,8 @@ self: { ]; description = "Making SafeCopy migrations easier"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safecopy-store" = callPackage @@ -214485,6 +225095,8 @@ self: { ]; description = "Binary serialization with version control"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safeint" = callPackage @@ -214502,6 +225114,8 @@ self: { ]; description = "overflow-checked Int type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safeio" = callPackage @@ -214536,6 +225150,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Safe Paths in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "safer-file-handles" = callPackage @@ -214552,6 +225168,7 @@ self: { ]; description = "Type-safe file handling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "safer-file-handles-bytestring" = callPackage @@ -214568,6 +225185,7 @@ self: { ]; description = "Extends safer-file-handles with ByteString operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "safer-file-handles-text" = callPackage @@ -214583,6 +225201,7 @@ self: { ]; description = "Extends safer-file-handles with Text operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "saferoute" = callPackage @@ -214594,6 +225213,8 @@ self: { libraryHaskellDepends = [ base blaze-html containers text ]; description = "A simple type-safe routing library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sai-shape-syb" = callPackage @@ -214609,6 +225230,7 @@ self: { ]; description = "Obtain homogeneous values from arbitrary values, transforming or culling data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sajson" = callPackage @@ -214631,6 +225253,8 @@ self: { ]; description = "Fast JSON parsing powered by Chad Austin's sajson library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sak" = callPackage @@ -214652,6 +225276,7 @@ self: { executableToolDepends = [ cpphs ]; description = "Compression command-line tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sakuraio-platform" = callPackage @@ -214723,6 +225348,8 @@ self: { ]; description = "Configuration Loader for toml"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "salak-yaml" = callPackage @@ -214782,6 +225409,7 @@ self: { ]; description = "Quickcheck implementations for some NaCl data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libsodium;}; "salve" = callPackage @@ -214814,6 +225442,7 @@ self: { ]; description = "Modular web application framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "salvia-demo" = callPackage @@ -214836,6 +225465,7 @@ self: { doHaddock = false; description = "Demo Salvia servers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "salvia-extras" = callPackage @@ -214856,6 +225486,7 @@ self: { ]; description = "Collection of non-fundamental handlers for the Salvia web server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "salvia-protocol" = callPackage @@ -214872,6 +225503,8 @@ self: { ]; description = "Salvia webserver protocol suite supporting URI, HTTP, Cookie and MIME"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "salvia-sessions" = callPackage @@ -214889,6 +225522,7 @@ self: { ]; description = "Session support for the Salvia webserver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "salvia-websocket" = callPackage @@ -214905,6 +225539,7 @@ self: { ]; description = "Websocket implementation for the Salvia Webserver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sample-frame" = callPackage @@ -214961,6 +225596,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "Binding to the C samtools library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) zlib;}; "samtools-conduit" = callPackage @@ -214981,6 +225617,7 @@ self: { ]; description = "Conduit interface to SAM/BAM format files through samtools"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "samtools-enumerator" = callPackage @@ -214996,6 +225633,7 @@ self: { ]; description = "Enumerator interface to SamTools library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "samtools-iteratee" = callPackage @@ -215012,6 +225650,7 @@ self: { ]; description = "Iteratee interface to SamTools library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sandi" = callPackage @@ -215042,6 +225681,8 @@ self: { libraryHaskellDepends = [ base ]; description = "SAND data serialization and manipulation library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sandman" = callPackage @@ -215060,6 +225701,8 @@ self: { ]; description = "Manages Cabal sandboxes to avoid rebuilding packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sandwich" = callPackage @@ -215207,6 +225850,8 @@ self: { libraryHaskellDepends = [ base deepseq portaudio ]; description = "audio library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sarsi" = callPackage @@ -215235,6 +225880,7 @@ self: { ]; description = "A universal quickfix toolkit and his protocol"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "sasl" = callPackage @@ -215251,6 +225897,7 @@ self: { ]; description = "SASL implementation using simple-pipe"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sat" = callPackage @@ -215264,6 +225911,8 @@ self: { executableHaskellDepends = [ base ]; description = "CNF SATisfier"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sat-micro-hs" = callPackage @@ -215281,6 +225930,7 @@ self: { ]; description = "A minimal SAT solver"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "satchmo" = callPackage @@ -215299,6 +225949,8 @@ self: { testHaskellDepends = [ array base ]; description = "SAT encoding monad"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "satchmo-backends" = callPackage @@ -215314,6 +225966,7 @@ self: { ]; description = "driver for external satchmo backends"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "satchmo-examples" = callPackage @@ -215331,6 +225984,7 @@ self: { ]; description = "examples that show how to use satchmo"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "satchmo-funsat" = callPackage @@ -215346,6 +226000,7 @@ self: { ]; description = "funsat driver as backend for satchmo"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "satchmo-minisat" = callPackage @@ -215357,6 +226012,7 @@ self: { libraryHaskellDepends = [ base containers process satchmo ]; description = "minisat driver as backend for satchmo"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "satchmo-toysat" = callPackage @@ -215372,6 +226028,7 @@ self: { ]; description = "toysat driver as backend for satchmo"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "savage" = callPackage @@ -215390,6 +226047,8 @@ self: { ]; description = "re-export of the random generators from Hedgehog"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sax" = callPackage @@ -215408,6 +226067,8 @@ self: { testHaskellDepends = [ base bytestring hspec ]; description = "Monadic streaming XML parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "say" = callPackage @@ -215569,6 +226230,8 @@ self: { ]; description = "Formally prove properties of Haskell programs using SBV/SMT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sc2-lowlevel" = callPackage @@ -215588,6 +226251,7 @@ self: { ]; description = "Low-level Starcraft II API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sc2-proto" = callPackage @@ -215607,6 +226271,8 @@ self: { libraryToolDepends = [ proto-lens-protoc protoc ]; description = "A protocol buffer model for the Starcraft II bot API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {protoc = null;}; "sc2-support" = callPackage @@ -215623,6 +226289,7 @@ self: { ]; description = "Support and utility library for sc2hs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sc2hs" = callPackage @@ -215663,6 +226330,7 @@ self: { libraryHaskellDepends = [ base hsc3 hsc3-db ]; description = "Haskell bindings to sc3-rdu (sc3 rd ugens)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "scalable-server" = callPackage @@ -215680,6 +226348,7 @@ self: { ]; description = "Library for writing fast/scalable TCP-based services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scaleimage" = callPackage @@ -215693,6 +226362,8 @@ self: { executableHaskellDepends = [ base filepath gd ]; description = "Scale an image to a new geometry"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scalendar" = callPackage @@ -215709,6 +226380,8 @@ self: { ]; description = "This is a library for handling calendars and resource availability based on the \"top-nodes algorithm\" and set operations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scalp-webhooks" = callPackage @@ -215735,6 +226408,7 @@ self: { ]; description = "Test webhooks locally"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "scalpel" = callPackage @@ -215786,6 +226460,7 @@ self: { ]; description = "scalpel scrapers for search engines"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "scan" = callPackage @@ -215830,6 +226505,7 @@ self: { testHaskellDepends = [ array base HUnit ]; description = "An implementation of the Scan Vector Machine instruction set in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scanf" = callPackage @@ -215871,6 +226547,8 @@ self: { testHaskellDepends = [ attoparsec base bytestring hspec scanner ]; description = "Inject attoparsec parser with backtracking into non-backtracking scanner"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scat" = callPackage @@ -215926,6 +226604,8 @@ self: { ]; description = "Streaming component combinators"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scenegraph" = callPackage @@ -215943,6 +226623,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Scene Graph"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scgi" = callPackage @@ -215958,6 +226640,8 @@ self: { ]; description = "A Haskell library for writing SCGI programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "schedevr" = callPackage @@ -215975,6 +226659,8 @@ self: { ]; description = "Marge schedules and show EVR"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "schedule" = callPackage @@ -216015,6 +226701,8 @@ self: { ]; description = "Find the ideal lesson layout"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scheduler" = callPackage @@ -216046,6 +226734,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Exposes standard POSIX function sched_yield"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "schema" = callPackage @@ -216060,6 +226750,7 @@ self: { ]; description = "Encoding-independent schemas for Haskell data types"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "schemas" = callPackage @@ -216084,6 +226775,8 @@ self: { ]; description = "schema guided serialization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "schematic" = callPackage @@ -216112,6 +226805,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "JSON-biased spec and validation tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scholdoc" = callPackage @@ -216156,6 +226850,7 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Converts ScholarlyMarkdown documents to HTML5/LaTeX/Docx format"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "scholdoc-citeproc" = callPackage @@ -216189,6 +226884,7 @@ self: { ]; description = "Scholdoc fork of pandoc-citeproc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scholdoc-texmath" = callPackage @@ -216211,6 +226907,7 @@ self: { ]; description = "Scholdoc fork of texmath"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "scholdoc-types" = callPackage @@ -216226,6 +226923,8 @@ self: { ]; description = "Scholdoc fork of pandoc-types"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "schonfinkeling" = callPackage @@ -216249,6 +226948,8 @@ self: { testHaskellDepends = [ base ]; description = "Rational numbers in scientific notation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scidb-hquery" = callPackage @@ -216282,6 +226983,8 @@ self: { ]; description = "Haskell query for SciDB via shim"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "science-constants" = callPackage @@ -216355,6 +227058,7 @@ self: { ]; description = "Scientific notation intended for tokenization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scion" = callPackage @@ -216380,6 +227084,7 @@ self: { ]; description = "Haskell IDE library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scion-browser" = callPackage @@ -216414,6 +227119,7 @@ self: { ]; description = "Command-line interface for browsing and searching packages documentation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scons2dot" = callPackage @@ -216427,6 +227133,8 @@ self: { executableHaskellDepends = [ base bytestring containers process ]; description = "Generates graphviz file of scons dependency information"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scope" = callPackage @@ -216444,6 +227152,7 @@ self: { ]; description = "An interactive renderer for plotting time-series data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scope-cairo" = callPackage @@ -216467,6 +227176,7 @@ self: { ]; description = "An interactive renderer for plotting time-series data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scottish" = callPackage @@ -216484,6 +227194,8 @@ self: { ]; description = "scotty with batteries included"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty" = callPackage @@ -216535,6 +227247,8 @@ self: { ]; description = "The Play Framework style data binding in Scotty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-blaze" = callPackage @@ -216549,6 +227263,8 @@ self: { ]; description = "blaze-html integration for Scotty"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-cookie" = callPackage @@ -216589,6 +227305,8 @@ self: { ]; description = "Fay integration for Scotty"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-form" = callPackage @@ -216602,6 +227320,8 @@ self: { ]; description = "Html form validation using `ditto`"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-format" = callPackage @@ -216618,6 +227338,8 @@ self: { testHaskellDepends = [ base ]; description = "Response format helper for the Scotty web framework"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-hastache" = callPackage @@ -216634,6 +227356,7 @@ self: { ]; description = "Easy Mustache templating support for Scotty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scotty-haxl" = callPackage @@ -216661,6 +227384,8 @@ self: { ]; description = "HTTP-request's query parameters parser abstraction for \"scotty\""; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-path-normalizer" = callPackage @@ -216688,6 +227413,8 @@ self: { ]; description = "A Better way of modeling web resources"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-rest" = callPackage @@ -216713,6 +227440,8 @@ self: { ]; description = "Webmachine-style REST library for scotty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-session" = callPackage @@ -216731,6 +227460,8 @@ self: { ]; description = "Adding session functionality to scotty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-tls" = callPackage @@ -216744,6 +227475,8 @@ self: { ]; description = "TLS for Scotty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scotty-utils" = callPackage @@ -216775,6 +227508,8 @@ self: { libraryHaskellDepends = [ base scotty text transformers ]; executableHaskellDepends = [ base scotty text transformers ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scp-streams" = callPackage @@ -216796,6 +227531,7 @@ self: { testHaskellDepends = [ base bytestring io-streams ]; description = "An SCP protocol implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scrabble-bot" = callPackage @@ -216815,6 +227551,7 @@ self: { ]; description = "Scrabble play generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "scrapbook" = callPackage @@ -216838,6 +227575,7 @@ self: { ]; description = "collect posts of site that is wrote in config yaml using feed or scraping"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "scrapbook-core" = callPackage @@ -216859,6 +227597,8 @@ self: { ]; description = "Core Package for scrapbook"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scrape-changes" = callPackage @@ -216885,6 +227625,8 @@ self: { ]; description = "Scrape websites for changes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "script-monad" = callPackage @@ -216911,6 +227653,8 @@ self: { ]; description = "Stack of error, reader, writer, state, and prompt monad transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scrobble" = callPackage @@ -216933,6 +227677,8 @@ self: { ]; description = "Scrobbling server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scroll" = callPackage @@ -217041,6 +227787,8 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Fast CSV lexing on ByteString"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "scyther-proof" = callPackage @@ -217062,6 +227810,8 @@ self: { executableToolDepends = [ alex ]; description = "Automatic generation of Isabelle/HOL correctness proofs for security protocols"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sde-solver" = callPackage @@ -217080,6 +227830,7 @@ self: { ]; description = "Distributed SDE solver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sdf2p1-parser" = callPackage @@ -217157,6 +227908,8 @@ self: { ]; description = "An image loading and rendering library for sdl2 / sdl2-cairo"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sdl2-compositor" = callPackage @@ -217180,6 +227933,8 @@ self: { ]; description = "image compositing with sdl2 - declarative style"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sdl2-fps" = callPackage @@ -217193,6 +227948,8 @@ self: { libraryHaskellDepends = [ base sdl2 ]; description = "Run of the mill, frames per second timer implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sdl2-gfx" = callPackage @@ -217490,6 +228247,8 @@ self: { description = "A software defined radio library"; license = lib.licenses.bsd3; platforms = [ "x86_64-darwin" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "seacat" = callPackage @@ -217525,6 +228284,8 @@ self: { libraryHaskellDepends = [ base bytestring free mtl text ]; description = "Pure SQL layer on top of other libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "seakale-postgresql" = callPackage @@ -217540,6 +228301,7 @@ self: { ]; description = "PostgreSQL backend for Seakale"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "seakale-tests" = callPackage @@ -217555,6 +228317,7 @@ self: { ]; description = "Helpers to test code using Seakale"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "seal-module" = callPackage @@ -217607,6 +228370,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Semantic Editor Combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "secd" = callPackage @@ -217637,6 +228402,8 @@ self: { executableHaskellDepends = [ base containers ]; description = "SECDH Machine Simulator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "seclib" = callPackage @@ -217648,6 +228415,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple library for static information-flow security in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "second-transfer" = callPackage @@ -217675,6 +228444,8 @@ self: { testToolDepends = [ cpphs ]; description = "Second Transfer HTTP/2 web server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "secp256k1" = callPackage @@ -217698,6 +228469,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bindings for secp256k1 library from Bitcoin Core"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) secp256k1;}; "secp256k1-haskell" = callPackage @@ -217723,6 +228496,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Bindings for secp256k1"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) secp256k1;}; "secp256k1-legacy" = callPackage @@ -217748,6 +228523,8 @@ self: { ]; description = "fork of secp256k1"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "secret-santa" = callPackage @@ -217765,6 +228542,8 @@ self: { ]; description = "Secret Santa game assigner using QR-Codes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "secret-sharing" = callPackage @@ -217798,6 +228577,7 @@ self: { executableHaskellDepends = [ base haskell98 ]; description = "Example of writing \"secure\" file removal in Haskell rather than C"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "secure-sockets" = callPackage @@ -217813,6 +228593,8 @@ self: { ]; description = "Secure point-to-point connectivity library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "secureUDP" = callPackage @@ -217824,6 +228606,8 @@ self: { libraryHaskellDepends = [ base bytestring containers network ]; description = "Setups secure (unsorted) UDP packet transfer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "securemem" = callPackage @@ -217853,6 +228637,7 @@ self: { librarySystemDepends = [ sedna ]; description = "Sedna C API XML Binding"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {sedna = null;}; "seitz-symbol" = callPackage @@ -217872,6 +228657,7 @@ self: { ]; description = "Read and Display Seitz Symbol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "selda" = callPackage @@ -217994,6 +228780,8 @@ self: { libraryToolDepends = [ alex happy ]; description = "CSS Selectors for DOM traversal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "selenium" = callPackage @@ -218005,6 +228793,8 @@ self: { libraryHaskellDepends = [ base HTTP HUnit mtl network pretty ]; description = "Test web applications through a browser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "selenium-server" = callPackage @@ -218024,6 +228814,7 @@ self: { testHaskellDepends = [ base hspec text webdriver ]; description = "Run the selenium standalone server for usage with webdriver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "self-extract" = callPackage @@ -218043,6 +228834,7 @@ self: { executableHaskellDepends = [ base ]; description = "A Haskell library to make self-extracting executables"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "selfrestart" = callPackage @@ -218066,6 +228858,8 @@ self: { librarySystemDepends = [ selinux ]; description = "SELinux bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {selinux = null;}; "semantic" = callPackage @@ -218097,6 +228891,8 @@ self: { ]; description = "Types and functionality for working with source code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semaphore-plus" = callPackage @@ -218128,6 +228924,8 @@ self: { executableHaskellDepends = [ base ]; description = "Evaluate code snippets in Literate Haskell"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semi-iso" = callPackage @@ -218143,6 +228941,7 @@ self: { ]; description = "Weakened partial isomorphisms, reversible computations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "semialign" = callPackage @@ -218196,6 +228995,8 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "Extra functions for working with Semialigns"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semialign-indexed" = callPackage @@ -218270,6 +229071,8 @@ self: { testHaskellDepends = [ base ]; description = "A Haskell implementation of semibounded lattices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semigroupoid-extras" = callPackage @@ -218320,6 +229123,8 @@ self: { ]; description = "RebindableSyntax using the semigroupoids package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semigroups" = callPackage @@ -218342,6 +229147,8 @@ self: { libraryHaskellDepends = [ base containers semigroups ]; description = "Semigroups actions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semilattices" = callPackage @@ -218373,6 +229180,7 @@ self: { libraryHaskellDepends = [ base Boolean containers monoids ]; description = "Semirings, ring-like structures used for dynamic programming applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "semiring-num" = callPackage @@ -218398,6 +229206,7 @@ self: { ]; description = "Basic semiring class and instances"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "semiring-simple" = callPackage @@ -218487,6 +229296,8 @@ self: { ]; description = "Sengrid API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sendgrid-v3" = callPackage @@ -218505,6 +229316,8 @@ self: { ]; description = "Sendgrid v3 API library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sensei" = callPackage @@ -218531,6 +229344,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Automatically run Hspec tests on file modifications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sensenet" = callPackage @@ -218548,6 +229363,7 @@ self: { ]; description = "Distributed sensor network for the raspberry pi"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sensu-run" = callPackage @@ -218569,6 +229385,8 @@ self: { ]; description = "A tool to send command execution results to Sensu"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sentence-jp" = callPackage @@ -218582,6 +229400,7 @@ self: { ]; description = "Easily generating message of japanese natural language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sentiwordnet-parser" = callPackage @@ -218618,6 +229437,8 @@ self: { executableHaskellDepends = [ base directory filepath unix ]; description = "Process monitoring tool written and configured in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "senza" = callPackage @@ -218665,6 +229486,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "SmartyPants for Korean language"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "separated" = callPackage @@ -218711,6 +229533,7 @@ self: { ]; description = "Dynamic strictness control, including space leak repair"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "seqalign" = callPackage @@ -218764,6 +229587,7 @@ self: { ]; description = "Handle sequence locations for bioinformatics"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "seqloc-datafiles" = callPackage @@ -218797,6 +229621,7 @@ self: { ]; description = "Read and write BED and GTF format genome annotations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sequence" = callPackage @@ -218875,6 +229700,8 @@ self: { ]; description = "Alternative Core language for GHC plugins"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sequential-index" = callPackage @@ -218909,6 +229736,7 @@ self: { ]; description = "A sequence labeler based on Collins's sequence perceptron"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "serf" = callPackage @@ -219023,6 +229851,8 @@ self: { ]; description = "Instances for Serialize of cereal"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serialport" = callPackage @@ -219035,6 +229865,8 @@ self: { testHaskellDepends = [ base bytestring HUnit ]; description = "Cross platform serial port library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serokell-util" = callPackage @@ -219065,6 +229897,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "General-purpose functions by Serokell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serpentine" = callPackage @@ -219083,6 +229917,7 @@ self: { executableHaskellDepends = [ base singletons text ]; description = "Simple project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "serv" = callPackage @@ -219096,6 +229931,7 @@ self: { ]; description = "Dependently typed API framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "serv-wai" = callPackage @@ -219120,6 +229956,7 @@ self: { ]; description = "Dependently typed API servers with Serv"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant" = callPackage @@ -219166,6 +230003,8 @@ self: { ]; description = "Servant support for JuicyPixels"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-aeson-specs" = callPackage @@ -219191,6 +230030,8 @@ self: { ]; description = "generic tests for aeson serialization in servant"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-auth" = callPackage @@ -219262,6 +230103,8 @@ self: { ]; description = "Authentication via encrypted cookies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-auth-docs" = callPackage @@ -219321,6 +230164,8 @@ self: { ]; description = "Authentication via HMAC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-auth-server" = callPackage @@ -219388,6 +230233,7 @@ self: { ]; description = "Servant based API and server for token based authorisation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-auth-token-acid" = callPackage @@ -219409,6 +230255,7 @@ self: { ]; description = "Acid-state backend for servant-auth-token server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-auth-token-api" = callPackage @@ -219425,6 +230272,8 @@ self: { ]; description = "Servant based API for token based authorisation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-auth-token-leveldb" = callPackage @@ -219446,6 +230295,7 @@ self: { ]; description = "Leveldb backend for servant-auth-token server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-auth-token-persistent" = callPackage @@ -219465,6 +230315,7 @@ self: { ]; description = "Persistent backend for servant-auth-token server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-auth-token-rocksdb" = callPackage @@ -219487,6 +230338,7 @@ self: { ]; description = "RocksDB backend for servant-auth-token server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-auth-wordpress" = callPackage @@ -219502,6 +230354,7 @@ self: { ]; description = "Authenticate Routes Using Wordpress Cookies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-avro" = callPackage @@ -219519,6 +230372,8 @@ self: { ]; description = "Avro content type for Servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-benchmark" = callPackage @@ -219645,6 +230500,7 @@ self: { ]; description = "Command line interface for Servant API clients"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-client" = callPackage @@ -219717,6 +230573,8 @@ self: { ]; description = "A servant client for frontend JavaScript"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-client-namedargs" = callPackage @@ -219738,6 +230596,7 @@ self: { ]; description = "Automatically derive API client functions with named and optional parameters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-conduit" = callPackage @@ -219777,6 +230636,7 @@ self: { ]; description = "Generate servant client library for C#"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-db" = callPackage @@ -219788,6 +230648,8 @@ self: { libraryHaskellDepends = [ base servant ]; description = "Servant types for defining API with relational DBs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-db-postgresql" = callPackage @@ -219813,6 +230675,7 @@ self: { ]; description = "Derive a postgres client to database API specified by servant-db"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-dhall" = callPackage @@ -219834,6 +230697,8 @@ self: { ]; description = "Servant Dhall content-type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-docs" = callPackage @@ -219884,6 +230749,8 @@ self: { ]; description = "Generate endpoints overview for Servant API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-ede" = callPackage @@ -219907,6 +230774,7 @@ self: { ]; description = "Combinators for rendering EDE templates in servant web applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-ekg" = callPackage @@ -219933,6 +230801,8 @@ self: { ]; description = "Helpers for using ekg with servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-elm" = callPackage @@ -219955,6 +230825,8 @@ self: { ]; description = "Automatically derive Elm functions to query servant webservices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-errors" = callPackage @@ -219998,6 +230870,7 @@ self: { testHaskellDepends = [ base ]; description = "Servant support for Server-Sent events"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-examples" = callPackage @@ -220020,6 +230893,7 @@ self: { ]; description = "Example programs for servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-exceptions" = callPackage @@ -220063,6 +230937,8 @@ self: { ]; description = "Fiat content types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-flatten" = callPackage @@ -220104,6 +230980,8 @@ self: { libraryHaskellDepends = [ base servant servant-server ]; description = "Utilities for generating mock server implementations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-generic" = callPackage @@ -220120,6 +230998,8 @@ self: { ]; description = "Specify Servant APIs with records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-github" = callPackage @@ -220143,6 +231023,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Bindings to GitHub API using servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-github-webhook" = callPackage @@ -220192,6 +231074,8 @@ self: { ]; description = "automatical derivation of querying functions for servant webservices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-hmac-auth" = callPackage @@ -220218,6 +231102,8 @@ self: { testHaskellDepends = [ base ]; description = "Servant authentication with HMAC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-http-streams" = callPackage @@ -220251,6 +231137,8 @@ self: { testToolDepends = [ hspec-discover markdown-unlit ]; description = "Automatic derivation of querying functions for servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-http2-client" = callPackage @@ -220275,6 +231163,7 @@ self: { ]; description = "Generate HTTP2 clients from Servant API descriptions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-iCalendar" = callPackage @@ -220309,6 +231198,8 @@ self: { ]; description = "Automatically derive (jquery) javascript functions to query servant webservices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-js" = callPackage @@ -220332,6 +231223,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Automatically derive javascript functions to query servant webservices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-jsonrpc" = callPackage @@ -220398,6 +231291,8 @@ self: { ]; description = "Automatically derive Kotlin class to query servant webservices"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-lucid" = callPackage @@ -220466,6 +231361,7 @@ self: { ]; description = "Matrix parameter combinator for servant"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "servant-mock" = callPackage @@ -220494,6 +231390,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Derive a mock server for free from your servant API types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-multipart" = callPackage @@ -220556,6 +231454,8 @@ self: { testHaskellDepends = [ base hspec named QuickCheck servant ]; description = "Combinators for servant providing named parameters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-nix" = callPackage @@ -220577,6 +231477,8 @@ self: { ]; description = "Servant Nix content-type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-openapi3" = callPackage @@ -220638,6 +231540,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck servant-server text ]; description = "Type-safe pagination for Servant APIs"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-pandoc" = callPackage @@ -220655,6 +231559,8 @@ self: { ]; description = "Use Pandoc to render servant API documentation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-pipes" = callPackage @@ -220701,6 +231607,7 @@ self: { ]; description = "Utilities for using servant in a polysemy stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-pool" = callPackage @@ -220714,6 +231621,8 @@ self: { libraryHaskellDepends = [ base resource-pool servant time ]; description = "Utility functions for creating servant 'Context's with \"context/connection pooling\" support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-postgresql" = callPackage @@ -220730,6 +231639,7 @@ self: { ]; description = "Useful functions and instances for using servant with a PostgreSQL context"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-proto-lens" = callPackage @@ -220752,6 +231662,8 @@ self: { ]; description = "Servant Content-Type for proto-lens protobuf modules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-purescript" = callPackage @@ -220775,6 +231687,8 @@ self: { ]; description = "Generate PureScript accessor functions for you servant API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-pushbullet-client" = callPackage @@ -220794,6 +231708,8 @@ self: { ]; description = "Bindings to the Pushbullet API using servant-client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-py" = callPackage @@ -220815,6 +231731,8 @@ self: { ]; description = "Automatically derive python functions to query servant webservices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-quickcheck" = callPackage @@ -220843,6 +231761,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "QuickCheck entire APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-rawm" = callPackage @@ -220916,6 +231836,8 @@ self: { ]; description = "Derive Reason types to interact with a Haskell backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-reflex" = callPackage @@ -220938,6 +231860,8 @@ self: { ]; description = "servant API generator for reflex apps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-response" = callPackage @@ -220970,6 +231894,8 @@ self: { ]; description = "Servant router for non-server applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-ruby" = callPackage @@ -221002,6 +231928,8 @@ self: { ]; description = "Generate a web service for servant 'Resource's using scotty and JSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-seo" = callPackage @@ -221024,6 +231952,8 @@ self: { ]; description = "Generate Robots.txt and Sitemap.xml specification for your servant API."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-serf" = callPackage @@ -221095,6 +232025,7 @@ self: { ]; description = "Automatically derive API server functions with named and optional parameters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-smsc-ru" = callPackage @@ -221117,6 +232048,8 @@ self: { ]; description = "Servant client for smsc.ru service for sending SMS to cell phones"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-snap" = callPackage @@ -221154,6 +232087,7 @@ self: { ]; description = "A family of combinators for defining webservices APIs and serving them"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-stache" = callPackage @@ -221202,6 +232136,8 @@ self: { ]; description = "Embed a directory of static files in your Servant server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-streaming" = callPackage @@ -221216,6 +232152,8 @@ self: { testHaskellDepends = [ base hspec http-types QuickCheck servant ]; description = "Servant combinators for the 'streaming' package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-streaming-client" = callPackage @@ -221241,6 +232179,7 @@ self: { ]; description = "Client instances for the 'servant-streaming' package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-streaming-docs" = callPackage @@ -221258,6 +232197,7 @@ self: { ]; description = "Client instances for the 'servant-docs' package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-streaming-server" = callPackage @@ -221284,6 +232224,7 @@ self: { ]; description = "Server instances for the 'servant-streaming' package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-subscriber" = callPackage @@ -221354,6 +232295,7 @@ self: { ]; description = "Swagger Tags for Servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-swagger-ui" = callPackage @@ -221444,6 +232386,8 @@ self: { ]; description = "Automatically generate Elm clients for Servant APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-tracing" = callPackage @@ -221514,6 +232458,7 @@ self: { ]; description = "Servant Integration for Waargonaut JSON Package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-wasm" = callPackage @@ -221590,6 +232535,8 @@ self: { ]; description = "Servant support for yaml"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-zeppelin" = callPackage @@ -221601,6 +232548,8 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Types and definitions of servant-zeppelin combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-zeppelin-client" = callPackage @@ -221624,6 +232573,7 @@ self: { ]; description = "Client library for servant-zeppelin combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-zeppelin-server" = callPackage @@ -221647,6 +232597,7 @@ self: { ]; description = "Server library for servant-zeppelin combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-zeppelin-swagger" = callPackage @@ -221668,6 +232619,7 @@ self: { ]; description = "Swagger instances for servant-zeppelin combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "server-generic" = callPackage @@ -221683,6 +232635,8 @@ self: { ]; description = "Auto-generate a server for your datatype"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serverless-haskell" = callPackage @@ -221780,6 +232734,8 @@ self: { ]; description = "Storage backend for serversession using persistent and an RDBMS"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serversession-backend-redis" = callPackage @@ -221801,6 +232757,8 @@ self: { ]; description = "Storage backend for serversession using Redis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serversession-frontend-snap" = callPackage @@ -221853,6 +232811,8 @@ self: { ]; description = "Yesod bindings for serversession"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "services" = callPackage @@ -221870,6 +232830,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Tools for building services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serviette" = callPackage @@ -221935,6 +232897,8 @@ self: { ]; description = "Snaplet for the ses-html package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sessions" = callPackage @@ -221949,6 +232913,8 @@ self: { ]; description = "Session Types for Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sessiontypes" = callPackage @@ -221970,6 +232936,8 @@ self: { testHaskellDepends = [ base directory exceptions hspec ]; description = "Session types library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sessiontypes-distributed" = callPackage @@ -221992,6 +232960,7 @@ self: { ]; description = "Session types distributed"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "set-cover" = callPackage @@ -222053,6 +233022,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Sets of fixed size, with typelits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "set-with" = callPackage @@ -222070,6 +233041,8 @@ self: { ]; description = "Set of elements sorted by a different data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "setdown" = callPackage @@ -222089,6 +233062,7 @@ self: { executableToolDepends = [ alex happy ]; description = "Treating files as sets to perform rapid set manipulation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "setenv" = callPackage @@ -222118,6 +233092,8 @@ self: { executableHaskellDepends = [ base ]; description = "A console interface to the game of Set"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "setlocale" = callPackage @@ -222147,6 +233123,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "A Haskell implementation of setoid"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "setop" = callPackage @@ -222224,6 +233202,8 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Small (TH) library to declare setters for typical `record' data type fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "settings" = callPackage @@ -222259,6 +233239,8 @@ self: { ]; description = "S-Expression parsing/printing made fun and easy"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sexp-grammar" = callPackage @@ -222335,6 +233317,8 @@ self: { testHaskellDepends = [ base data-default hspec megaparsec ]; description = "Simple s-expression parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sexpresso" = callPackage @@ -222374,6 +233358,8 @@ self: { ]; description = "Lists, Texts, ByteStrings and Vectors with type-encoded length"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sfml-audio" = callPackage @@ -222398,6 +233384,8 @@ self: { libraryHaskellDepends = [ base bytestring entropy primitive ]; description = "SIMD-oriented Fast Mersenne Twister(SFMT) binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sfnt2woff" = callPackage @@ -222418,6 +233406,8 @@ self: { testHaskellDepends = [ base ]; description = "A command line tool to convert TrueType/OpenType fonts to WOFF format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) zlib;}; "sgd" = callPackage @@ -222442,6 +233432,8 @@ self: { ]; description = "Stochastic gradient descent library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sgf" = callPackage @@ -222458,6 +233450,7 @@ self: { ]; description = "SGF (Smart Game Format) parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sgrep" = callPackage @@ -222471,6 +233464,7 @@ self: { executableHaskellDepends = [ base bio regex-compat ]; description = "Sgrep - grep Fasta files for sequences matching a regular expression"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "sh2md" = callPackage @@ -222497,6 +233491,8 @@ self: { ]; description = "Record your shell session and print in the markdown format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sha-streams" = callPackage @@ -222511,6 +233507,8 @@ self: { executableHaskellDepends = [ base io-streams SHA ]; description = "SHA hashes for io-streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sha1" = callPackage @@ -222527,6 +233525,7 @@ self: { ]; description = "SHA-1 Hash"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shade" = callPackage @@ -222540,6 +233539,8 @@ self: { libraryHaskellDepends = [ base mtl transformers ]; description = "A control structure used to combine heterogenous types with delayed effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shadower" = callPackage @@ -222562,6 +233563,8 @@ self: { ]; description = "An automated way to run doctests in files that are changing"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shadowsocks" = callPackage @@ -222709,6 +233712,8 @@ self: { ]; description = "Rules for binary distributions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-c" = callPackage @@ -222751,6 +233756,8 @@ self: { ]; description = "Utility for building Shake build systems using Cabal sandboxes"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-ccjs" = callPackage @@ -222778,6 +233785,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Dhall dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-elm" = callPackage @@ -222815,6 +233824,8 @@ self: { ]; description = "Extra utilities for shake build systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-futhark" = callPackage @@ -222883,6 +233894,8 @@ self: { ]; description = "Shake Minify Rules"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-minify-css" = callPackage @@ -222896,6 +233909,7 @@ self: { ]; description = "Shake rules for CSS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shake-pack" = callPackage @@ -222907,6 +233921,8 @@ self: { libraryHaskellDepends = [ base bytestring bzlib shake tar ]; description = "Shake File Pack Rule"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-path" = callPackage @@ -222918,6 +233934,8 @@ self: { libraryHaskellDepends = [ base path path-io shake ]; description = "path alternatives to shake functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-persist" = callPackage @@ -222935,6 +233953,8 @@ self: { executableHaskellDepends = [ base shake ]; description = "Shake build system on-disk caching"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shake-plus" = callPackage @@ -223010,6 +234030,8 @@ self: { ]; description = "Shake-based technical documentation generator; HTML & PDF"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shaker" = callPackage @@ -223038,6 +234060,7 @@ self: { ]; description = "simple and interactive command-line build tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shakers" = callPackage @@ -223093,6 +234116,8 @@ self: { ]; description = "compile es2015"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shakespeare-css" = callPackage @@ -223144,6 +234169,8 @@ self: { ]; description = "SASS support for Shakespeare and Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shakespeare-text" = callPackage @@ -223200,6 +234227,7 @@ self: { ]; description = "Parser and related tools for ESRI shapefile format"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "shapely-data" = callPackage @@ -223218,6 +234246,7 @@ self: { ]; description = "Generics using @(,)@ and @Either@, with algebraic operations and typed conversions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shapes" = callPackage @@ -223315,6 +234344,8 @@ self: { ]; description = "A circular buffer built on shared memory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shared-fields" = callPackage @@ -223328,6 +234359,8 @@ self: { testHaskellDepends = [ base Cabal hspec lens text ]; description = "a tiny library for using shared lens fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shared-memory" = callPackage @@ -223367,6 +234400,8 @@ self: { executableHaskellDepends = [ base filepath mtl ]; description = "A Haskell preprocessor adding miscellaneous features"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shelduck" = callPackage @@ -223397,6 +234432,7 @@ self: { ]; description = "Test webhooks locally"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "shell-conduit" = callPackage @@ -223459,6 +234495,8 @@ self: { executableHaskellDepends = [ base ]; description = "Pipe streams through external shell commands"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shell-utility" = callPackage @@ -223486,6 +234524,8 @@ self: { ]; description = "shell-/perl- like (systems) programming in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shellmate" = callPackage @@ -223502,6 +234542,8 @@ self: { ]; description = "Simple interface for shell scripting in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shellmate-extras" = callPackage @@ -223518,6 +234560,7 @@ self: { ]; description = "Extra functionality for shellmate"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shellmet" = callPackage @@ -223747,6 +234790,8 @@ self: { ]; description = "The Reflective Lambda Machine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shine" = callPackage @@ -223776,6 +234821,8 @@ self: { isExecutable = true; description = "Examples for the shine package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shine-varying" = callPackage @@ -223806,6 +234853,8 @@ self: { ]; description = "Implementation of Shivers' Control-Flow Analysis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shoap" = callPackage @@ -223817,6 +234866,8 @@ self: { libraryHaskellDepends = [ base curl ]; description = "A very basic SOAP package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shopify" = callPackage @@ -223837,6 +234888,8 @@ self: { ]; description = "A haskell API binding for shopify.com"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shortcircuit" = callPackage @@ -223883,6 +234936,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Shorten a variety of string-like types adding ellipsis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "should-not-typecheck" = callPackage @@ -223957,6 +235012,8 @@ self: { ]; description = "Robust prettyprinter for output of auto-generated Show instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "show-type" = callPackage @@ -223982,6 +235039,7 @@ self: { executableHaskellDepends = [ base glade gtk random ]; description = "A simple gtk based Russian Roulette game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shower" = callPackage @@ -224023,6 +235081,7 @@ self: { ]; description = "Web automation library in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shplit" = callPackage @@ -224072,6 +235131,7 @@ self: { executableHaskellDepends = [ base ]; description = "Shuffle tool for UHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "shunya-library" = callPackage @@ -224112,6 +235172,8 @@ self: { ]; description = "Generate swift types from haskell types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "si-clock" = callPackage @@ -224125,6 +235187,7 @@ self: { ]; description = "An interface to the Silicon Labs Si5351 clock chip"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sibe" = callPackage @@ -224150,6 +235213,7 @@ self: { ]; description = "Machine Learning algorithms"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "sieve" = callPackage @@ -224184,6 +235248,8 @@ self: { ]; description = "Simple, visual, functional language for learning about recursion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sifflet-lib" = callPackage @@ -224202,6 +235268,8 @@ self: { librarySystemDepends = [ gdk_x11 gtk_x11 ]; description = "Library of modules shared by sifflet and its tests and its exporters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {gdk_x11 = null; gtk_x11 = null;}; "siggy-chardust" = callPackage @@ -224242,6 +235310,7 @@ self: { ]; description = "Thom polynomials of second order Thom-Boardman singularities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sign" = callPackage @@ -224292,6 +235361,7 @@ self: { ]; description = "Deterministic serialisation and signatures with proto-lens support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "signable-haskell-protoc" = callPackage @@ -224341,6 +235411,7 @@ self: { ]; description = "Synchronous signal processing for DSLs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "signature" = callPackage @@ -224358,6 +235429,7 @@ self: { ]; description = "Hmac sha256 signature json and http payload"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "signed-multiset" = callPackage @@ -224369,6 +235441,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Multisets with negative membership"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "signify-hs" = callPackage @@ -224392,6 +235466,7 @@ self: { ]; description = "A Haskell clone of OpenBSD signify"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "silently" = callPackage @@ -224432,6 +235507,7 @@ self: { testHaskellDepends = [ base quantification savage text ]; description = "A generator for different kinds of data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "simd" = callPackage @@ -224443,6 +235519,8 @@ self: { libraryHaskellDepends = [ base ghc-prim primitive vector ]; description = "simple interface to GHC's SIMD instructions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simgi" = callPackage @@ -224460,6 +235538,7 @@ self: { ]; description = "stochastic simulation engine"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "simple" = callPackage @@ -224508,6 +235587,8 @@ self: { ]; description = "A library for more structured concurrent programming, based on the Actor Model"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-affine-space" = callPackage @@ -224536,6 +235617,8 @@ self: { libraryHaskellDepends = [ base containers deepseq ]; description = "Atom (or symbol) datatype for fast comparision and sorting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-bluetooth" = callPackage @@ -224548,6 +235631,8 @@ self: { librarySystemDepends = [ bluetooth ]; description = "Simple Bluetooth API for Windows and Linux (bluez)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {bluetooth = null;}; "simple-c-value" = callPackage @@ -224570,6 +235655,7 @@ self: { ]; description = "A simple C value type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "simple-cabal" = callPackage @@ -224638,6 +235724,8 @@ self: { ]; description = "A simple streaming I/O library based on monadic folds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-config" = callPackage @@ -224655,6 +235743,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Simple config file parser generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-css" = callPackage @@ -224670,6 +235760,8 @@ self: { ]; description = "simple binding of css and html"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-download" = callPackage @@ -224685,6 +235777,8 @@ self: { ]; description = "A simple wrapper of http-conduit for file download"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-effects" = callPackage @@ -224732,6 +235826,8 @@ self: { executableHaskellDepends = [ base text ]; description = "Evaluate a Text to an Integer: \"1 + 1\" -> 2"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-firewire" = callPackage @@ -224743,6 +235839,7 @@ self: { libraryHaskellDepends = [ base bindings-dc1394 CV ]; description = "Simplified interface for firewire cameras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "simple-form" = callPackage @@ -224774,6 +235871,8 @@ self: { executableHaskellDepends = [ base deepseq parallel random ]; description = "Simple parallel genetic algorithm implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-genetic-algorithm-mr" = callPackage @@ -224820,6 +235919,8 @@ self: { ]; description = "Allows simple indexation on any data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-log" = callPackage @@ -224851,6 +235952,8 @@ self: { libraryHaskellDepends = [ base hsyslog simple-log text ]; description = "Syslog backend for simple-log"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-logger" = callPackage @@ -224884,6 +235987,8 @@ self: { ]; description = "Logging effect to plug into the simple-effects framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-ltl" = callPackage @@ -224908,6 +236013,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple library to handle and interexchange money"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-neural-networks" = callPackage @@ -224927,6 +236034,8 @@ self: { ]; description = "Simple parallel neural networks implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-nix" = callPackage @@ -224948,6 +236057,7 @@ self: { ]; description = "Simple parsing/pretty printing for Nix expressions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "simple-observer" = callPackage @@ -224997,6 +236107,7 @@ self: { ]; description = "Simplified Pascal language to SSVM compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "simple-pipe" = callPackage @@ -225015,6 +236126,8 @@ self: { ]; description = "simple pipeline library like conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-postgresql-orm" = callPackage @@ -225054,6 +236167,8 @@ self: { libraryHaskellDepends = [ base bytestring QuickCheck ]; description = "Memory-efficient strings with concatenation and splitting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-sendfile" = callPackage @@ -225087,6 +236202,8 @@ self: { ]; description = "Simple Server interface"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-session" = callPackage @@ -225140,6 +236257,8 @@ self: { testHaskellDepends = [ base mtl parsec pretty tasty tasty-hunit ]; description = "A parser for SQL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-src-utils" = callPackage @@ -225172,6 +236291,8 @@ self: { ]; description = "Simple stacked virtual machine: assembler, disassembler, bytecode interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-tabular" = callPackage @@ -225183,6 +236304,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Simple tabular-text formatter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-tar" = callPackage @@ -225198,6 +236321,8 @@ self: { ]; description = "Simple, pure, file-system-free reading of tar files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-templates" = callPackage @@ -225249,6 +236374,8 @@ self: { ]; description = "UI library for terminal"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-units" = callPackage @@ -225261,6 +236388,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Simple arithmetic with SI units using type-checked dimensional analysis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-vec3" = callPackage @@ -225278,6 +236407,8 @@ self: { benchmarkHaskellDepends = [ base criterion vector ]; description = "Three-dimensional vectors of doubles with basic operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-zipper" = callPackage @@ -225290,6 +236421,8 @@ self: { testHaskellDepends = [ base hspec lens ]; description = "Zippers made slightly easier"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simpleargs" = callPackage @@ -225302,6 +236435,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Provides a more flexible getArgs function with better error reporting"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simpleconfig" = callPackage @@ -225318,6 +236453,8 @@ self: { ]; description = "Short description of your package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simpleirc" = callPackage @@ -225334,6 +236471,8 @@ self: { testHaskellDepends = [ base bytestring hspec HUnit knob ]; description = "Simple IRC Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simpleirc-lens" = callPackage @@ -225345,6 +236484,7 @@ self: { libraryHaskellDepends = [ base bytestring simpleirc ]; description = "Lenses for simpleirc types"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "simplelru" = callPackage @@ -225386,6 +236526,8 @@ self: { ]; description = "Haskell interface for the simplenote API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simpleprelude" = callPackage @@ -225404,6 +236546,8 @@ self: { ]; description = "A simplified Haskell prelude for teaching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simplesmtpclient" = callPackage @@ -225417,6 +236561,8 @@ self: { libraryHaskellDepends = [ array base directory network old-time ]; description = "Very simple SMTP Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simplessh" = callPackage @@ -225445,6 +236591,8 @@ self: { librarySystemDepends = [ sqlite ]; description = "Simplest SQLite3 binding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) sqlite;}; "simplex" = callPackage @@ -225512,6 +236660,7 @@ self: { executableHaskellDepends = [ base bio bytestring random ]; description = "Simulate sequencing with different models for priming and errors"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "simtreelo" = callPackage @@ -225624,6 +236773,8 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Typelevel balanced search trees via a singletonized Data.Map"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "singleton-nats" = callPackage @@ -225658,6 +236809,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Singletons and induction over GHC TypeLits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "singletons" = callPackage @@ -225718,6 +236871,7 @@ self: { ]; description = "A promoted and singled version of the base library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "singletons-presburger" = callPackage @@ -225751,6 +236905,8 @@ self: { ]; description = "A framework for generating singleton types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "singnal" = callPackage @@ -225762,6 +236918,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Singnal"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "singular-factory" = callPackage @@ -225782,6 +236940,8 @@ self: { ]; description = "Multivariate polynomial factorization via bindings to Singular-factory"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {singular-factory = null;}; "sink" = callPackage @@ -225793,6 +236953,8 @@ self: { libraryHaskellDepends = [ base ]; description = "An alternative to lazy I/O that doesn't conflate execution with evaluation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "siphash" = callPackage @@ -225839,6 +237001,7 @@ self: { ]; description = "Encode and decode CSV files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "siren-json" = callPackage @@ -225863,6 +237026,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Siren Tools for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sirkel" = callPackage @@ -225879,6 +237043,7 @@ self: { ]; description = "Sirkel, a Chord DHT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sitemap" = callPackage @@ -225926,6 +237091,8 @@ self: { ]; description = "A simple to understand static site generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sixel" = callPackage @@ -225961,6 +237128,8 @@ self: { ]; description = "A six figure group of time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sixty-five-oh-two" = callPackage @@ -226040,6 +237209,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Multidimensional grids with sized specified at compile time"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sized-types" = callPackage @@ -226058,6 +237229,8 @@ self: { ]; description = "Sized types in Haskell using the GHC Nat kind"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sized-vector" = callPackage @@ -226074,6 +237247,8 @@ self: { ]; description = "Size-parameterized vector types and functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sizes" = callPackage @@ -226093,6 +237268,8 @@ self: { ]; description = "Recursively show space (size and i-nodes) used in subdirectories"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sjsp" = callPackage @@ -226114,6 +237291,8 @@ self: { executableToolDepends = [ alex happy ]; description = "Simple JavaScript Profiler"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skein" = callPackage @@ -226150,6 +237329,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Skeletal set - a set with equivalence relation different from equality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skeleton" = callPackage @@ -226168,6 +237349,7 @@ self: { ]; description = "a tool to access the OSX keychain"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "skeletons" = callPackage @@ -226186,6 +237368,7 @@ self: { ]; description = "Manage project skeletons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "skell" = callPackage @@ -226201,6 +237384,8 @@ self: { ]; description = "An overly complex Haskell web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skemmtun" = callPackage @@ -226219,6 +237404,8 @@ self: { ]; description = "A MyAnimeList.net client."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skews" = callPackage @@ -226235,6 +237422,8 @@ self: { ]; description = "A very quick-and-dirty WebSocket server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skip-list" = callPackage @@ -226273,6 +237462,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Eclectic collection of utility functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skylark-client" = callPackage @@ -226295,6 +237486,7 @@ self: { ]; description = "Skylark client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "skylighting" = callPackage @@ -226375,6 +237567,8 @@ self: { ]; description = "Lucid support for Skylighting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skylighting-modding" = callPackage @@ -226403,6 +237597,8 @@ self: { ]; description = "Skype Desktop API binding for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "skypelogexport" = callPackage @@ -226440,6 +237636,8 @@ self: { ]; description = "Haskell API for interacting with Slack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slack-api" = callPackage @@ -226482,6 +237680,8 @@ self: { executableHaskellDepends = [ base ]; description = "Slack notifier for Haskell project"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slack-progressbar" = callPackage @@ -226525,6 +237725,8 @@ self: { ]; description = "Slack API Request Verification HMAC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slack-web" = callPackage @@ -226598,6 +237800,8 @@ self: { ]; description = "A fundamental solution to ghost threads and silent exceptions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sleep" = callPackage @@ -226654,6 +237858,8 @@ self: { ]; description = "Python-ish slicing traversals for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slick" = callPackage @@ -226688,6 +237894,7 @@ self: { ]; description = "ws convert markdown to reveal-js"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "slim" = callPackage @@ -226703,6 +237910,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Functional reactive user interface programming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slip32" = callPackage @@ -226723,6 +237932,7 @@ self: { ]; description = "SLIP-0032: Extended serialization format for BIP-32 wallets"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "slist" = callPackage @@ -226760,6 +237970,8 @@ self: { ]; description = "A command line interface to Sloane's OEIS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slope-field" = callPackage @@ -226794,6 +238006,8 @@ self: { ]; description = "Write lambdas without naming the parameters"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sloth" = callPackage @@ -226805,6 +238019,8 @@ self: { libraryHaskellDepends = [ base mtl process ]; description = "Testing for minimal strictness"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slotmap" = callPackage @@ -226838,6 +238054,8 @@ self: { ]; description = "Type-safe slugs for Yesod ecosystem"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slugify" = callPackage @@ -226853,6 +238071,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Convert text into slugs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "slynx" = callPackage @@ -226887,6 +238107,7 @@ self: { doHaddock = false; description = "Serialize to bytes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "smallarray" = callPackage @@ -226898,6 +238119,8 @@ self: { libraryHaskellDepends = [ base bytestring deepseq hashable ]; description = "low-level unboxed arrays, with minimal features"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smallcaps" = callPackage @@ -226948,6 +238171,8 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "See README for more info"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smallcheck-laws" = callPackage @@ -226959,6 +238184,8 @@ self: { libraryHaskellDepends = [ base smallcheck smallcheck-series ]; description = "SmallCheck properties for common laws"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smallcheck-lens" = callPackage @@ -226974,6 +238201,8 @@ self: { ]; description = "SmallCheck properties for lens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smallcheck-series" = callPackage @@ -227006,6 +238235,8 @@ self: { executableHaskellDepends = [ base vector ]; description = "A Haskell port of the smallpt path tracer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smallstring" = callPackage @@ -227021,6 +238252,7 @@ self: { ]; description = "A Unicode text type, optimized for low memory overhead"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "smaoin" = callPackage @@ -227067,6 +238299,8 @@ self: { ]; description = "A command line tool for working with sets and maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smartGroup" = callPackage @@ -227080,6 +238314,8 @@ self: { ]; description = "group strings or bytestrings by words in common"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smartcheck" = callPackage @@ -227100,6 +238336,8 @@ self: { ]; description = "A smarter QuickCheck"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smartconstructor" = callPackage @@ -227111,6 +238349,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "A package exposing a helper function for generating smart constructors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smarties" = callPackage @@ -227152,6 +238392,7 @@ self: { ]; description = "Web based flash card for Word Smart I and II vocabularies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "smash" = callPackage @@ -227258,6 +238499,7 @@ self: { benchmarkHaskellDepends = [ base criterion time ]; description = "Symbolic Model Checking for Dynamic Epistemic Logic"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "sme" = callPackage @@ -227269,6 +238511,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for Secure Multi-Execution in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smerdyakov" = callPackage @@ -227287,6 +238531,8 @@ self: { transformers yaml ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smiles" = callPackage @@ -227298,6 +238544,8 @@ self: { libraryHaskellDepends = [ base megaparsec text ]; testHaskellDepends = [ base hspec megaparsec QuickCheck text ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smith" = callPackage @@ -227309,6 +238557,7 @@ self: { libraryHaskellDepends = [ base bytesmith primitive ]; description = "Parse arrays of tokens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "smith-cli" = callPackage @@ -227332,6 +238581,7 @@ self: { ]; description = "Command line tool for ."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "smith-client" = callPackage @@ -227355,6 +238605,7 @@ self: { ]; description = "API client for ."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "smoothie" = callPackage @@ -227383,6 +238634,8 @@ self: { ]; description = "SMSAero API and HTTP client based on servant library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smt" = callPackage @@ -227409,6 +238662,8 @@ self: { libraryHaskellDepends = [ array base directory polyparse ]; description = "Parsing and printing SMT-LIB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smt2-parser" = callPackage @@ -227421,6 +238676,8 @@ self: { testHaskellDepends = [ base HUnit parsec text ]; description = "A Haskell parser for SMT-LIB version 2.6"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smtLib" = callPackage @@ -227448,6 +238705,8 @@ self: { ]; description = "A type-safe interface to communicate with an SMT solver"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smtlib2-debug" = callPackage @@ -227464,6 +238723,7 @@ self: { ]; description = "Dump the communication with an SMT solver for debugging purposes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "smtlib2-pipe" = callPackage @@ -227485,6 +238745,7 @@ self: { ]; description = "A type-safe interface to communicate with an SMT solver"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "smtlib2-quickcheck" = callPackage @@ -227500,6 +238761,7 @@ self: { ]; description = "Helper functions to create SMTLib expressions in QuickCheck"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "smtlib2-timing" = callPackage @@ -227511,6 +238773,7 @@ self: { libraryHaskellDepends = [ base dependent-sum mtl smtlib2 time ]; description = "Get timing informations for SMT queries"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "smtp-mail" = callPackage @@ -227549,6 +238812,8 @@ self: { ]; description = "An SMTP client EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smtp2mta" = callPackage @@ -227581,6 +238846,8 @@ self: { ]; description = "Gmail SMTP Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smuggler" = callPackage @@ -227603,6 +238870,8 @@ self: { testHaskellDepends = [ base directory filepath ]; description = "GHC Source Plugin that helps to manage imports"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smuggler2" = callPackage @@ -227624,6 +238893,8 @@ self: { ]; description = "GHC Source Plugin that helps to minimise imports and generate explicit exports"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snake" = callPackage @@ -227637,6 +238908,8 @@ self: { executableHaskellDepends = [ base random split terminal-size ]; description = "A basic console snake game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snake-game" = callPackage @@ -227648,6 +238921,8 @@ self: { libraryHaskellDepends = [ base GLUT OpenGL random ]; description = "Snake Game Using OpenGL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap" = callPackage @@ -227698,6 +238973,8 @@ self: { ]; description = "Accept header branching for the Snap web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap-app" = callPackage @@ -227729,6 +239006,7 @@ self: { ]; description = "Command-line tool to manage Snap AuthManager database"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snap-blaze" = callPackage @@ -227751,6 +239029,8 @@ self: { libraryHaskellDepends = [ base blaze-html clay snap-core ]; description = "blaze-html-clay integration for Snap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap-configuration-utilities" = callPackage @@ -227764,6 +239044,8 @@ self: { ]; description = "Methods to manipulate Configurator objects for Snap & Snaplets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap-core" = callPackage @@ -227845,6 +239127,8 @@ self: { ]; description = "Collect errors in batches and dispatch them"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap-extras" = callPackage @@ -227876,6 +239160,7 @@ self: { ]; description = "A collection of useful helpers and utilities for Snap web applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snap-language" = callPackage @@ -227961,6 +239246,8 @@ self: { ]; description = "Typesafe URLs for Snap applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap-server" = callPackage @@ -228018,6 +239305,8 @@ self: { ]; description = "Streaming Snap handlers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap-templates" = callPackage @@ -228062,6 +239351,8 @@ self: { ]; description = "A library for BDD-style testing with the Snap Web Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snap-utils" = callPackage @@ -228079,6 +239370,7 @@ self: { ]; description = "Snap Framework utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snap-web-routes" = callPackage @@ -228094,6 +239386,8 @@ self: { ]; description = "Type safe URLs for Snap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-acid-state" = callPackage @@ -228107,6 +239401,8 @@ self: { ]; description = "acid-state snaplet for Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-actionlog" = callPackage @@ -228131,6 +239427,7 @@ self: { ]; description = "Generic action log snaplet for the Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-amqp" = callPackage @@ -228148,6 +239445,8 @@ self: { ]; description = "Snap framework snaplet for the AMQP library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-auth-acid" = callPackage @@ -228168,6 +239467,7 @@ self: { ]; description = "Provides an Acid-State backend for the Auth Snaplet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-coffee" = callPackage @@ -228185,6 +239485,7 @@ self: { ]; description = "CoffeeScript for Snap, auto-compilation and pre-compilation"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-css-min" = callPackage @@ -228201,6 +239502,8 @@ self: { ]; description = "A Snaplet for CSS minification"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-customauth" = callPackage @@ -228224,6 +239527,8 @@ self: { ]; description = "Alternate authentication snaplet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-environments" = callPackage @@ -228240,6 +239545,7 @@ self: { ]; description = "DEPRECATED! You should use standard Snap >= 0.9 \"environments\" functionality. It provided ability to easly read configuration based on given app environment given at command line, envs are defined in app configuration file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-fay" = callPackage @@ -228259,6 +239565,8 @@ self: { ]; description = "Fay integration for Snap with request- and pre-compilation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-ghcjs" = callPackage @@ -228292,6 +239600,7 @@ self: { ]; description = "A Hasql snaplet"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-haxl" = callPackage @@ -228307,6 +239616,7 @@ self: { ]; description = "Snaplet for Facebook's Haxl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-hdbc" = callPackage @@ -228327,6 +239637,7 @@ self: { ]; description = "HDBC snaplet for Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-hslogger" = callPackage @@ -228343,6 +239654,8 @@ self: { ]; description = "Snap framework snaplet for the Logger API library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-i18n" = callPackage @@ -228384,6 +239697,8 @@ self: { ]; description = "Snap framework snaplet for the InfluxDB library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-lss" = callPackage @@ -228417,6 +239732,7 @@ self: { ]; description = "Snap framework snaplet for the Mandrill API library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-mongoDB" = callPackage @@ -228436,6 +239752,7 @@ self: { ]; description = "Snap Framework MongoDB support as Snaplet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-mongodb-minimalistic" = callPackage @@ -228450,6 +239767,7 @@ self: { ]; description = "Minimalistic MongoDB Snaplet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-mysql-simple" = callPackage @@ -228470,6 +239788,7 @@ self: { ]; description = "mysql-simple snaplet for the Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-oauth" = callPackage @@ -228495,6 +239814,7 @@ self: { ]; description = "snaplet-oauth"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-persistent" = callPackage @@ -228517,6 +239837,8 @@ self: { ]; description = "persistent snaplet for the Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-postgresql-simple" = callPackage @@ -228541,6 +239863,8 @@ self: { ]; description = "postgresql-simple snaplet for the Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-postmark" = callPackage @@ -228557,6 +239881,7 @@ self: { ]; description = "Postmark snaplet for the Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-purescript" = callPackage @@ -228590,6 +239915,7 @@ self: { ]; description = "A ReCAPTCHA verification snaplet with Heist integration and connection sharing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-redis" = callPackage @@ -228628,6 +239954,7 @@ self: { ]; description = "CRUD for JSON data with Redis storage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-rest" = callPackage @@ -228645,6 +239972,7 @@ self: { ]; description = "REST resources for the Snap web framework"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-riak" = callPackage @@ -228662,6 +239990,7 @@ self: { ]; description = "A Snaplet for the Riak database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-sass" = callPackage @@ -228679,6 +240008,8 @@ self: { ]; description = "Sass integration for Snap with request- and pre-compilation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-scoped-session" = callPackage @@ -228695,6 +240026,8 @@ self: { ]; description = "Modularised session state for Snaplets, in a Snaplet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-sedna" = callPackage @@ -228711,6 +240044,7 @@ self: { ]; description = "Snaplet for Sedna Bindings. Essentailly a rip of snaplet-hdbc."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-ses-html" = callPackage @@ -228727,6 +240061,8 @@ self: { ]; description = "Snaplet for the ses-html package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-sqlite-simple" = callPackage @@ -228757,6 +240093,8 @@ self: { ]; description = "sqlite-simple snaplet for the Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-sqlite-simple-jwt-auth" = callPackage @@ -228776,6 +240114,7 @@ self: { ]; description = "Snaplet for JWT authentication with snaplet-sqlite-simple"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-stripe" = callPackage @@ -228794,6 +240133,7 @@ self: { ]; description = "Stripe snaplet for the Snap Framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-tasks" = callPackage @@ -228810,6 +240150,7 @@ self: { ]; description = "Snaplet for Snap Framework enabling developers to administrative tasks akin to Rake tasks from Ruby On Rails framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snaplet-typed-sessions" = callPackage @@ -228827,6 +240168,8 @@ self: { ]; description = "Typed session snaplets and continuation-based programming for the Snap web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-wordpress" = callPackage @@ -228853,6 +240196,7 @@ self: { ]; description = "A snaplet that communicates with wordpress over its api"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snappy" = callPackage @@ -228882,6 +240226,8 @@ self: { libraryHaskellDepends = [ base bytestring conduit snappy ]; description = "Conduit bindings for Snappy (see snappy package)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snappy-framing" = callPackage @@ -228904,6 +240250,7 @@ self: { libraryHaskellDepends = [ base bytestring iteratee snappy ]; description = "An enumeratee that uses Google's snappy compression library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snappy-lazy" = callPackage @@ -228936,6 +240283,7 @@ self: { ]; description = "Audio file reading/writing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sneakyterm" = callPackage @@ -228951,6 +240299,8 @@ self: { ]; description = "Tiny, declarative wrapper around ncurses"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sneathlane-haste" = callPackage @@ -228974,6 +240324,8 @@ self: { libraryHaskellDepends = [ base containers pandoc process text ]; description = "Markdown tester"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snippet-extractor" = callPackage @@ -229008,6 +240360,7 @@ self: { ]; description = "The Simple Nice-Looking Manual Generator"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "snmp" = callPackage @@ -229026,6 +240379,7 @@ self: { ]; description = "SNMP protocol library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snorkels" = callPackage @@ -229048,6 +240402,8 @@ self: { ]; description = "Strategic board game of medium complexity"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snow-white" = callPackage @@ -229060,6 +240416,7 @@ self: { libraryHaskellDepends = [ base binary bytestring mps ]; description = "encode any binary instance to white space"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snowball" = callPackage @@ -229107,6 +240464,7 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "twitter's snowflake"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snowflake-server" = callPackage @@ -229125,6 +240483,7 @@ self: { ]; description = "snowflake http server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "snowglobe" = callPackage @@ -229158,6 +240517,8 @@ self: { ]; description = "snowtify send your result of `stack build` (`stack test`) to notify-daemon :dog2:"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "soap" = callPackage @@ -229277,6 +240638,8 @@ self: { libraryHaskellDepends = [ base network transformers unix ]; description = "systemd socket activation library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "socket-icmp" = callPackage @@ -229316,6 +240679,8 @@ self: { testHaskellDepends = [ base bytestring socket ]; description = "STCP socket extensions library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) lksctp-tools;}; "socket-unix" = callPackage @@ -229332,6 +240697,8 @@ self: { ]; description = "Unix domain sockets"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "socketed" = callPackage @@ -229358,6 +240725,8 @@ self: { ]; description = "simpe tool to serve piped data over http and websocket"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "socketio" = callPackage @@ -229386,6 +240755,8 @@ self: { ]; description = "Socket.IO server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sockets" = callPackage @@ -229416,6 +240787,7 @@ self: { doHaddock = false; description = "High-level network sockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sockets-and-pipes" = callPackage @@ -229432,6 +240804,8 @@ self: { ]; description = "Support for the Sockets and Pipes book"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "socketson" = callPackage @@ -229457,6 +240831,8 @@ self: { ]; description = "A small websocket backend provider"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "socks" = callPackage @@ -229481,6 +240857,8 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Sodium Reactive Programming (FRP) System"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "soegtk" = callPackage @@ -229493,6 +240871,8 @@ self: { libraryHaskellDepends = [ base cairo gtk old-time stm ]; description = "GUI functions as used in the book \"The Haskell School of Expression\""; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "softfloat-hs" = callPackage @@ -229505,6 +240885,8 @@ self: { librarySystemDepends = [ softfloat ]; description = "Haskell bindings for SoftFloat"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {softfloat = null;}; "solar" = callPackage @@ -229541,6 +240923,8 @@ self: { ]; description = "Simple typesafe web routing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "solga-swagger" = callPackage @@ -229558,6 +240942,7 @@ self: { ]; description = "Swagger generation for Solga"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "solr" = callPackage @@ -229582,6 +240967,7 @@ self: { ]; description = "A minimal Solr client library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "solve" = callPackage @@ -229629,6 +241015,8 @@ self: { ]; description = "Sonic Visualiser"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sop-core" = callPackage @@ -229699,6 +241087,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Efficient, type-safe sorted sequences"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sorted-list" = callPackage @@ -229734,6 +241124,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Utils for sorting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sorty" = callPackage @@ -229747,6 +241139,8 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Sort lines per file size"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "souffle-dsl" = callPackage @@ -229770,6 +241164,7 @@ self: { ]; description = "Haskell EDSL for Souffle"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "souffle-haskell" = callPackage @@ -229800,6 +241195,8 @@ self: { ]; description = "Souffle Datalog bindings for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sound-collage" = callPackage @@ -229822,6 +241219,8 @@ self: { ]; description = "Approximate a song from other pieces of sound"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sounddelay" = callPackage @@ -229835,6 +241234,7 @@ self: { executableHaskellDepends = [ base containers parseargs WAVE ]; description = "Audio delay line"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "soundgen" = callPackage @@ -229848,6 +241248,7 @@ self: { executableHaskellDepends = [ base split WAVE ]; description = "sound generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "source-code-server" = callPackage @@ -229871,6 +241272,7 @@ self: { ]; description = "The server backend for the source code iPhone app"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "source-constraints" = callPackage @@ -229929,6 +241331,8 @@ self: { ]; description = "Source/Sink/Transform: An alternative to lazy IO and iteratees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sox" = callPackage @@ -229984,6 +241388,8 @@ self: { ]; description = "DCPU-16 architecture utilities for Notch's 0x10c game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "space" = callPackage @@ -230057,6 +241463,8 @@ self: { libraryHaskellDepends = [ base vector-space ]; description = "Space partition data structures. Currently only a QuadTree."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spaceprobe" = callPackage @@ -230101,6 +241509,8 @@ self: { ]; description = "Implementation of the SPAKE2 Password-Authenticated Key Exchange algorithm"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spanout" = callPackage @@ -230118,6 +241528,8 @@ self: { ]; description = "A breakout clone written in netwire and gloss"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sparkle" = callPackage @@ -230145,6 +241557,7 @@ self: { ]; description = "Distributed Apache Spark applications in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sparql-protocol" = callPackage @@ -230190,6 +241603,7 @@ self: { ]; description = "Unified streaming data-dependency framework for web apps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "spars" = callPackage @@ -230201,6 +241615,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A sparse set-based parsing library for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sparse" = callPackage @@ -230228,6 +241644,8 @@ self: { benchmarkHaskellDepends = [ array base criterion deepseq vector ]; description = "A playground of sparse linear algebra primitives using Morton ordering"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sparse-lin-alg" = callPackage @@ -230245,6 +241663,8 @@ self: { ]; description = "Effective linear algebra on sparse matrices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sparse-linear-algebra" = callPackage @@ -230300,6 +241720,7 @@ self: { libraryHaskellDepends = [ base haskell98 ]; description = "Sparse bitmaps for pattern match coverage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sparsecheck" = callPackage @@ -230311,6 +241732,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A Logic Programming Library for Test-Data Generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sparser" = callPackage @@ -230326,6 +241749,7 @@ self: { ]; description = "Lightweight parsing library based on partial functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "spartacon" = callPackage @@ -230356,6 +241780,7 @@ self: { libraryHaskellDepends = [ base dlist mps mtl ]; description = "brainless form validation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "spatial-math" = callPackage @@ -230466,6 +241891,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Control.Applicative, Data.Foldable, Data.Traversable (compatibility package)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "special-keys" = callPackage @@ -230483,6 +241910,8 @@ self: { ]; description = "Simple data types that help me here and there"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "special-values" = callPackage @@ -230522,6 +241951,7 @@ self: { ]; description = "Create specialized types from polymorphic ones using TH"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "species" = callPackage @@ -230540,6 +241970,7 @@ self: { ]; description = "Computational combinatorial species"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "spectral-clustering" = callPackage @@ -230557,6 +241988,7 @@ self: { ]; description = "Library for spectral clustering"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "speculate" = callPackage @@ -230583,6 +242015,8 @@ self: { libraryHaskellDepends = [ base ghc-prim stm transformers ]; description = "A framework for safe, programmable, speculative parallelism"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "speculation-transformers" = callPackage @@ -230595,6 +242029,7 @@ self: { doHaddock = false; description = "Merged into 'speculation'. Use that instead."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "speechmatics" = callPackage @@ -230625,6 +242060,7 @@ self: { ]; description = "Speechmatics api client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "speedy-slice" = callPackage @@ -230663,6 +242099,7 @@ self: { ]; description = "Spelling suggestion tool with library and command-line interfaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "spherical" = callPackage @@ -230689,6 +242126,7 @@ self: { ]; description = "Orbotix Sphero client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sphinx" = callPackage @@ -230705,6 +242143,8 @@ self: { ]; description = "Haskell bindings to the Sphinx full-text searching daemon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sphinx-cli" = callPackage @@ -230718,6 +242158,7 @@ self: { executableHaskellDepends = [ base sphinx ]; description = "Sphinx CLI and demo of Haskell Sphinx library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sphinxesc" = callPackage @@ -230736,6 +242177,8 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Transform queries for sphinx input"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spice" = callPackage @@ -230752,6 +242195,7 @@ self: { ]; description = "An FRP-based game engine written in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "spike" = callPackage @@ -230795,6 +242239,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Some utilities for reading and writing SPIR-V files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spiros" = callPackage @@ -230821,6 +242267,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Spiros Boosalis's Custom Prelude"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "splay" = callPackage @@ -230832,6 +242280,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Generic splay-based sequence representation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "splaytree" = callPackage @@ -230849,6 +242299,8 @@ self: { ]; description = "Provides an annotated splay tree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "splice" = callPackage @@ -230883,6 +242335,7 @@ self: { ]; description = "A parallel implementation of the Sorokina/Zeilfelder spline scheme"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "splines" = callPackage @@ -230904,6 +242357,7 @@ self: { benchmarkHaskellDepends = [ base criterion polynomial vector ]; description = "B-Splines, other splines, and NURBS"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "splint" = callPackage @@ -230915,6 +242369,8 @@ self: { libraryHaskellDepends = [ base containers ghc hlint stm ]; description = "HLint as a GHC source plugin"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "split" = callPackage @@ -230952,6 +242408,8 @@ self: { testHaskellDepends = [ base invariant lens QuickCheck ]; description = "Split Epimorphisms and Monomorphisms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "split-record" = callPackage @@ -231035,6 +242493,8 @@ self: { ]; description = "Use numerical ranges to split out certain lines from a file"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "splot" = callPackage @@ -231095,6 +242555,8 @@ self: { ]; description = "Spoon's utilities. Simple testing and nice looking error reporting."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spork" = callPackage @@ -231122,6 +242584,8 @@ self: { ]; description = "Spotify web API wrapper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spreadsheet" = callPackage @@ -231181,6 +242645,7 @@ self: { ]; description = "JSON API to HTML website wrapper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "spritz" = callPackage @@ -231192,6 +242657,8 @@ self: { libraryHaskellDepends = [ base lens mtl vector ]; description = "An implementation of the Spritz RC4-like stream cipher in Haskell"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sproxy" = callPackage @@ -231216,6 +242683,7 @@ self: { ]; description = "HTTP proxy for authenticating users via OAuth2"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sproxy-web" = callPackage @@ -231241,6 +242709,7 @@ self: { ]; description = "Web interface to sproxy database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sproxy2" = callPackage @@ -231266,6 +242735,7 @@ self: { ]; description = "Secure HTTP proxy for authenticating users via OAuth2"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "spsa" = callPackage @@ -231285,6 +242755,8 @@ self: { benchmarkHaskellDepends = [ base criterion hmatrix random ]; description = "Simultaneous Perturbation Stochastic Approximation Optimization Algorithm"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spy" = callPackage @@ -231310,6 +242782,8 @@ self: { ]; description = "A compact file system watcher for Mac OS X, Linux and Windows"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sql-simple" = callPackage @@ -231326,6 +242800,8 @@ self: { ]; description = "common middle-level sql client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sql-simple-mysql" = callPackage @@ -231341,6 +242817,7 @@ self: { ]; description = "mysql backend for sql-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sql-simple-pool" = callPackage @@ -231357,6 +242834,7 @@ self: { ]; description = "conection pool for sql-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sql-simple-postgresql" = callPackage @@ -231372,6 +242850,7 @@ self: { ]; description = "postgresql backend for sql-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sql-simple-sqlite" = callPackage @@ -231383,6 +242862,7 @@ self: { libraryHaskellDepends = [ base sql-simple sqlite-simple ]; description = "sqlite backend for sql-simple"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sql-words" = callPackage @@ -231413,6 +242893,8 @@ self: { testHaskellDepends = [ base filepath hspec temporary ]; description = "Haskell binding to sqlcipher"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) openssl;}; "sqlcli" = callPackage @@ -231453,6 +242935,8 @@ self: { testHaskellDepends = [ base ]; description = "Haskell binding to sqlite3"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) sqlite;}; "sqlite-simple" = callPackage @@ -231486,6 +242970,8 @@ self: { testHaskellDepends = [ base mtl sqlite-simple text ]; description = "Wrapper around errors from sqlite-simple"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sqlite-simple-typed" = callPackage @@ -231502,6 +242988,7 @@ self: { ]; description = "Typed extension to sqlite simple"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sqlvalue-list" = callPackage @@ -231513,6 +243000,8 @@ self: { libraryHaskellDepends = [ base convertible HDBC template-haskell ]; description = "Class and instances for conversion to list of SqlValue"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sqsd-local" = callPackage @@ -231534,6 +243023,8 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "squares" = callPackage @@ -231589,6 +243080,8 @@ self: { ]; description = "Squeal PostgreSQL Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "squeather" = callPackage @@ -231674,6 +243167,7 @@ self: { ]; description = "Module limbo"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "srcinst" = callPackage @@ -231692,6 +243186,8 @@ self: { ]; description = "Build and install Debian packages completely from source"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "srcloc" = callPackage @@ -231732,6 +243228,8 @@ self: { ]; description = "text UI for scanning with SANE"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sscgi" = callPackage @@ -231749,6 +243247,7 @@ self: { ]; description = "Simple SCGI Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sscript" = callPackage @@ -231792,6 +243291,8 @@ self: { doCheck = false; description = "A pure-Haskell SSH server library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ssh-known-hosts" = callPackage @@ -231831,6 +243332,8 @@ self: { ]; description = "Proxy http-client via ssh tunnel"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sshd-lint" = callPackage @@ -231851,6 +243354,7 @@ self: { ]; description = "Check sshd configuration for adherence to best practices"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "sshtun" = callPackage @@ -231898,6 +243402,7 @@ self: { ]; description = "HTTP proxy for S3"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sstable" = callPackage @@ -231916,6 +243421,7 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "SSTables in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ssv" = callPackage @@ -231941,6 +243447,8 @@ self: { libraryHaskellDepends = [ base gdp ghc-prim primitive ]; description = "shared heap regions between local mutable state threads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stable-heap" = callPackage @@ -231957,6 +243465,8 @@ self: { ]; description = "Purely functional stable heaps (fair priority queues)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stable-maps" = callPackage @@ -231968,6 +243478,8 @@ self: { libraryHaskellDepends = [ base containers ghc-prim ]; description = "Heterogeneous maps keyed by StableNames"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stable-marriage" = callPackage @@ -231980,6 +243492,8 @@ self: { testHaskellDepends = [ base ghc-prim ]; description = "algorithms around stable marriage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stable-memo" = callPackage @@ -231993,6 +243507,8 @@ self: { libraryHaskellDepends = [ base ghc-prim hashtables ]; description = "Memoization based on argument identity"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stable-tree" = callPackage @@ -232017,6 +243533,7 @@ self: { ]; description = "Trees whose branches are resistant to change"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stache" = callPackage @@ -232186,6 +243703,8 @@ self: { ]; description = "Dead simple version bumping for hpack packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack-clean-old" = callPackage @@ -232216,6 +243735,8 @@ self: { executableHaskellDepends = [ base options text turtle ]; description = "Console program used to fix Stack build errors automatically"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack-hpc-coveralls" = callPackage @@ -232242,6 +243763,7 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "stack-lib" = callPackage @@ -232257,6 +243779,8 @@ self: { ]; description = "Wrapper to use stack as a library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack-network" = callPackage @@ -232298,6 +243822,7 @@ self: { ]; description = "A program for extending Stack to add distributed capabilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stack-prism" = callPackage @@ -232316,6 +243841,8 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Stack prisms"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack-run" = callPackage @@ -232335,6 +243862,8 @@ self: { ]; description = "An equivalent to cabal run for stack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack-run-auto" = callPackage @@ -232362,6 +243891,7 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stack-tag" = callPackage @@ -232407,6 +243937,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "The basic stack type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack-wrapper" = callPackage @@ -232423,6 +243955,8 @@ self: { executableHaskellDepends = [ base filepath process ]; description = "Call ghc within stack by calling ghc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack-yaml" = callPackage @@ -232467,6 +244001,8 @@ self: { ]; description = "Convert stack projects to cabal.project + cabal.project.freeze"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stack2nix" = callPackage @@ -232493,6 +244029,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Convert stack.yaml files into Nix build instructions."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stackage" = callPackage @@ -232511,6 +244049,7 @@ self: { ]; description = "Dummy package forcing installation of other Stackage packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stackage-build-plan" = callPackage @@ -232535,6 +244074,7 @@ self: { ]; description = "Calculate and print (in different formats) Stackage build plans"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stackage-cabal" = callPackage @@ -232555,6 +244095,7 @@ self: { ]; description = "A CLI executable for cabal-based stackage commands"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stackage-cli" = callPackage @@ -232576,6 +244117,8 @@ self: { executableHaskellDepends = [ base text ]; description = "A CLI library for stackage commands"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stackage-curator" = callPackage @@ -232620,6 +244163,8 @@ self: { ]; description = "Tools for curating Stackage bundles"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stackage-install" = callPackage @@ -232668,6 +244213,8 @@ self: { ]; description = "DEPRECATED Grab current metadata for all packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stackage-query" = callPackage @@ -232691,6 +244238,7 @@ self: { ]; description = "Tool for querying Stackage"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stackage-sandbox" = callPackage @@ -232711,6 +244259,7 @@ self: { ]; description = "Work with shared stackage sandboxes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stackage-setup" = callPackage @@ -232734,6 +244283,7 @@ self: { ]; description = "An executable for downloading a Haskell setup"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stackage-to-hackage" = callPackage @@ -232759,6 +244309,8 @@ self: { ]; description = "Convert stack.yaml to cabal.project + cabal.project.freeze"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stackage-types" = callPackage @@ -232778,6 +244330,8 @@ self: { ]; description = "Shared data types between various Stackage packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stackage-update" = callPackage @@ -232814,6 +244368,7 @@ self: { ]; description = "A more secure version of cabal upload which uses HTTPS"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stackage2nix" = callPackage @@ -232844,6 +244399,7 @@ self: { ]; description = "Convert Stack files into Nix build instructions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stackcollapse-ghc" = callPackage @@ -232867,6 +244423,8 @@ self: { ]; description = "Program to fold GHC prof files into flamegraph input"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stacked-dag" = callPackage @@ -232914,6 +244472,8 @@ self: { ]; description = "GHC.Generics style staged generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stagen" = callPackage @@ -232979,6 +244539,8 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "This package will derive class instance along the data type declaration tree. (Deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "standalone-haddock" = callPackage @@ -232996,6 +244558,8 @@ self: { ]; description = "Generate standalone haddock documentation for a set of packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "star" = callPackage @@ -233044,6 +244608,8 @@ self: { ]; description = "A memcached client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "starrover2" = callPackage @@ -233090,6 +244656,8 @@ self: { ]; description = "To be written"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "state" = callPackage @@ -233101,6 +244669,8 @@ self: { libraryHaskellDepends = [ arrows base mtl ]; description = "Data.State"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "state-bag" = callPackage @@ -233117,6 +244687,8 @@ self: { testHaskellDepends = [ base hspec transformers ]; description = "Monad transformers for holding bags of state"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "state-codes" = callPackage @@ -233142,6 +244714,8 @@ self: { testHaskellDepends = [ base checkers mtl QuickCheck ]; description = "MonadPlus for StateT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "state-record" = callPackage @@ -233153,6 +244727,8 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Better records for State monad states"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stateWriter" = callPackage @@ -233195,6 +244771,7 @@ self: { libraryHaskellDepends = [ base MaybeT mtl ]; description = "Typeclass instances for monad transformer stacks with an ST thread at the bottom"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stateref" = callPackage @@ -233282,6 +244859,8 @@ self: { libraryHaskellDepends = [ base double-conversion free mtl text ]; description = "DSL to generate HTML5 Canvas javascript"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "static-closure" = callPackage @@ -233298,6 +244877,7 @@ self: { ]; description = "Serialisable static pointers to functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "static-hash" = callPackage @@ -233353,6 +244933,8 @@ self: { ]; description = "Tensors of statically known size"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "static-text" = callPackage @@ -233426,6 +245008,8 @@ self: { ]; description = "Functions for working with Dirichlet densities and mixtures on vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "statistics-fusion" = callPackage @@ -233437,6 +245021,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "An implementation of high performance, minimal statistics functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "statistics-hypergeometric-genvar" = callPackage @@ -233452,6 +245038,8 @@ self: { ]; description = "Random variate generation from hypergeometric distributions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "statistics-linreg" = callPackage @@ -233505,6 +245093,8 @@ self: { executableHaskellDepends = [ base statistics text vector ]; description = "command line statistics"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "statsd" = callPackage @@ -233520,6 +245110,8 @@ self: { ]; description = "StatsD API"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "statsd-client" = callPackage @@ -233575,6 +245167,7 @@ self: { ]; description = "A lovely [Dog]StatsD implementation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "status-notifier-item" = callPackage @@ -233609,6 +245202,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Get unix filesystem statistics with statfs, statvfs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "staversion" = callPackage @@ -233662,6 +245257,7 @@ self: { description = "Image loading and writing microlibrary"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stb-image-redux" = callPackage @@ -233674,6 +245270,8 @@ self: { testHaskellDepends = [ base hspec vector ]; description = "Image loading and writing microlibrary"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stb-truetype" = callPackage @@ -233718,6 +245316,8 @@ self: { ]; description = "A library for implicit, monadic dataflow parallelism"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "std" = callPackage @@ -233740,6 +245340,8 @@ self: { libraryHaskellDepends = [ base parsec syb template-haskell ]; description = "Structure Data Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stdf" = callPackage @@ -233762,6 +245364,8 @@ self: { ]; description = "Parse Structured Test Data Format (STDF)"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stdio" = callPackage @@ -233787,6 +245391,8 @@ self: { ]; description = "A simple and high performance IO toolkit for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libuv;}; "steambrowser" = callPackage @@ -233800,6 +245406,8 @@ self: { executableHaskellDepends = [ base directory parsec transformers ]; description = "List and launch steam games from the cli"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "steeloverseer" = callPackage @@ -233843,6 +245451,8 @@ self: { testHaskellDepends = [ base random uuid ]; description = "Generator and verifier for steganographic numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stemmer" = callPackage @@ -233854,6 +245464,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Haskell bindings to the Snowball stemming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stemmer-german" = callPackage @@ -233867,6 +245479,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Extract the stem of a German inflected word form"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "step-function" = callPackage @@ -233895,6 +245509,8 @@ self: { sha256 = "059k8g3wb4hkxk42vm83vv6kh3igrpf7fc97xvn3qai5rx3jmgqf"; libraryHaskellDepends = [ base containers mtl ]; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stern-brocot" = callPackage @@ -233912,6 +245528,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Positive rational numbers represented as paths in the Stern-Brocot tree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stgi" = callPackage @@ -233940,6 +245558,8 @@ self: { ]; description = "Educational implementation of the STG (Spineless Tagless G-machine)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stickyKeysHotKey" = callPackage @@ -234035,6 +245655,8 @@ self: { testHaskellDepends = [ async base HUnit stm tasty tasty-hunit ]; description = "Chunked Communication Queues"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stm-conduit" = callPackage @@ -234122,6 +245744,8 @@ self: { testHaskellDepends = [ base hspec HUnit stm ]; description = "Conduits and STM operations for fire hoses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stm-hamt" = callPackage @@ -234216,6 +245840,8 @@ self: { testHaskellDepends = [ base QuickCheck stm ]; description = "Simple STM Promises for IO computations and external processes"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stm-queue" = callPackage @@ -234278,6 +245904,8 @@ self: { ]; description = "retry statistics for STM transactions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stm-supply" = callPackage @@ -234315,6 +245943,7 @@ self: { libraryHaskellDepends = [ base haskell98 mtl stm ]; description = "Control communication among retrying transactions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stochastic" = callPackage @@ -234330,6 +245959,8 @@ self: { ]; description = "Monadic composition of probabilistic functions and sampling"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stocks" = callPackage @@ -234432,6 +246063,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Storable type class for variable-sized data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "storable-complex" = callPackage @@ -234493,6 +246126,8 @@ self: { libraryHaskellDepends = [ array base tagged vector ]; description = "Statically-sized array wrappers with Storable instances for FFI marshaling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "storable-tuple" = callPackage @@ -234555,6 +246190,7 @@ self: { ]; description = "Conversion between storablevector and stream-fusion lists with fusion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "store" = callPackage @@ -234654,6 +246290,8 @@ self: { executableHaskellDepends = [ base regex-compat ]; description = "Simple Theorem Prover"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "str" = callPackage @@ -234670,6 +246308,8 @@ self: { ]; description = "A type class to abstract between many different string types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stratosphere" = callPackage @@ -234714,6 +246354,8 @@ self: { ]; description = "Client for Stratum protocol"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stratux" = callPackage @@ -234729,6 +246371,7 @@ self: { ]; description = "A library for stratux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stratux-demo" = callPackage @@ -234751,6 +246394,7 @@ self: { ]; description = "A demonstration of the stratux library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stratux-http" = callPackage @@ -234766,6 +246410,7 @@ self: { ]; description = "A library for using HTTP with stratux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stratux-types" = callPackage @@ -234781,6 +246426,8 @@ self: { ]; description = "A library for reading JSON output from stratux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stratux-websockets" = callPackage @@ -234797,6 +246444,7 @@ self: { ]; description = "A library for using websockets with stratux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stream" = callPackage @@ -234816,6 +246464,8 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stream-fusion" = callPackage @@ -234829,6 +246479,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Faster Haskell lists using stream fusion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stream-monad" = callPackage @@ -234842,6 +246494,8 @@ self: { libraryHaskellDepends = [ base logict ]; description = "Simple, Fair and Terminating Backtracking Monad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streamdeck" = callPackage @@ -234853,6 +246507,8 @@ self: { libraryHaskellDepends = [ base bytestring hidapi mtl split ]; description = "Control library for the Elgato Stream Deck"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streamed" = callPackage @@ -234871,6 +246527,8 @@ self: { ]; description = "Programmatically edit MIDI event streams via ALSA"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming" = callPackage @@ -234926,6 +246584,7 @@ self: { ]; description = "Streaming conversion from/to base64"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "streaming-benchmarks" = callPackage @@ -235006,6 +246665,7 @@ self: { ]; description = "Streaming interface for Brotli (RFC7932) compression"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "streaming-bytestring" = callPackage @@ -235094,6 +246754,7 @@ self: { ]; description = "Concurrency support for the streaming ecosystem"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "streaming-conduit" = callPackage @@ -235110,6 +246771,8 @@ self: { testHaskellDepends = [ base conduit hspec streaming ]; description = "Bidirectional support between the streaming and conduit libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming-events" = callPackage @@ -235126,6 +246789,8 @@ self: { ]; description = "Client-side consumption of a ServerEvent"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming-eversion" = callPackage @@ -235161,6 +246826,7 @@ self: { ]; description = "online streaming fft"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "streaming-histogram" = callPackage @@ -235197,6 +246863,8 @@ self: { ]; description = "Streaming interface for LZMA/XZ compression"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming-nonempty" = callPackage @@ -235231,6 +246899,8 @@ self: { ]; description = "A hand-written streaming byte parser for OpenStreetMap Protobuf data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming-pcap" = callPackage @@ -235252,6 +246922,8 @@ self: { ]; description = "Stream packets via libpcap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming-png" = callPackage @@ -235272,6 +246944,8 @@ self: { ]; description = "Perfectly streaming PNG image decoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming-postgresql-simple" = callPackage @@ -235313,6 +246987,7 @@ self: { ]; description = "Streaming support for running system process"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "streaming-sort" = callPackage @@ -235334,6 +247009,7 @@ self: { ]; description = "Sorting streams"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "streaming-utils" = callPackage @@ -235355,6 +247031,8 @@ self: { ]; description = "http, attoparsec, pipes and other utilities for the streaming libraries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streaming-wai" = callPackage @@ -235388,6 +247066,8 @@ self: { ]; description = "with/bracket-style idioms for use with streaming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streamly" = callPackage @@ -235515,6 +247195,8 @@ self: { ]; description = "Folder watching as a Streamly stream"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streamly-lmdb" = callPackage @@ -235568,6 +247250,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Stream Processer Arrow"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streams" = callPackage @@ -235604,6 +247288,7 @@ self: { ]; description = "A simple, flexible and composable web-router"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "strelka-core" = callPackage @@ -235769,6 +247454,7 @@ self: { ]; description = "A collection of commonly used strict data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "strict-ghc-plugin" = callPackage @@ -235780,6 +247466,8 @@ self: { libraryHaskellDepends = [ base ghc syb ]; description = "Compiler plugin for making Haskell strict"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "strict-identity" = callPackage @@ -235870,6 +247558,8 @@ self: { libraryHaskellDepends = [ base lens strict-tuple ]; description = "Optics for the `strict-tuple` library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "strict-tuple-lens_0_2" = callPackage @@ -235882,6 +247572,7 @@ self: { description = "Optics for the `strict-tuple` library"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "strict-types" = callPackage @@ -235936,6 +247627,8 @@ self: { libraryHaskellDepends = [ base deepseq ]; description = "Combinators for strictifying functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "string" = callPackage @@ -236067,6 +247760,8 @@ self: { ]; description = "Tools for working with isomorphisms of strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "string-like" = callPackage @@ -236102,6 +247797,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "QuasiQuoter for non-interpolated strings, texts and bytestrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "string-random" = callPackage @@ -236171,6 +247868,7 @@ self: { ]; description = "Type-level Chars and Strings, with decidable equality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stringable" = callPackage @@ -236211,6 +247909,8 @@ self: { ]; description = "Transformations to several string-like types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stringprep" = callPackage @@ -236263,6 +247963,8 @@ self: { libraryHaskellDepends = [ base binary bytestring containers syb ]; description = "Memoize Strings as Atoms for fast comparison and sorting, with maps and sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "strio" = callPackage @@ -236308,6 +248010,8 @@ self: { ]; description = "A Haskell implementation of the Stripe API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stripe-concepts" = callPackage @@ -236371,6 +248075,8 @@ self: { ]; description = "Unofficial Stripe client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stripe-http-client" = callPackage @@ -236410,6 +248116,8 @@ self: { doCheck = false; description = "Stripe API for Haskell - http-streams backend"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stripe-scotty" = callPackage @@ -236426,6 +248134,7 @@ self: { ]; description = "Listen for Stripe webhook events with Scotty"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stripe-servant" = callPackage @@ -236459,6 +248168,8 @@ self: { testHaskellDepends = [ base bytestring text ]; description = "Verification of Stripe webhook signatures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stripe-tests" = callPackage @@ -236571,6 +248282,8 @@ self: { ]; description = "Interface library for strongSwan SQL backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "strptime" = callPackage @@ -236621,6 +248334,7 @@ self: { ]; description = "Instantiate structural induction schemas for algebraic data types"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "structural-traversal" = callPackage @@ -236633,6 +248347,8 @@ self: { testHaskellDepends = [ base HUnit mtl ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "structured" = callPackage @@ -236709,6 +248425,7 @@ self: { ]; description = "Structured MongoDB interface"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "structures" = callPackage @@ -236739,6 +248456,8 @@ self: { ]; description = "\"Advanced\" Data Structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stt" = callPackage @@ -236755,6 +248474,8 @@ self: { ]; description = "A monad transformer version of the ST monad"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stunclient" = callPackage @@ -236778,6 +248499,8 @@ self: { ]; description = "RFC 5389: Session Traversal Utilities for NAT (STUN) client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stunts" = callPackage @@ -236798,6 +248521,7 @@ self: { ]; description = "A revival of the classic game Stunts (LambdaCube tech demo)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "stutter" = callPackage @@ -236825,6 +248549,7 @@ self: { ]; description = "(Stutter Text|String)-Utterer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "stylish-cabal" = callPackage @@ -236851,6 +248576,8 @@ self: { doHaddock = false; description = "Format Cabal files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stylish-haskell" = callPackage @@ -236915,6 +248642,8 @@ self: { libraryHaskellDepends = [ ansi-terminal base ]; description = "Ways to output stylized text on ANSI consoles"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "styx" = callPackage @@ -236971,6 +248700,8 @@ self: { ]; description = "Get the total, put a single element"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "subG" = callPackage @@ -237048,6 +248779,7 @@ self: { benchmarkHaskellDepends = [ base criterion MonadRandom ]; description = "Type safe interface for programming in subcategories of Hask"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "subleq-toolchain" = callPackage @@ -237069,6 +248801,8 @@ self: { ]; description = "Toolchain of subleq computer"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sublists" = callPackage @@ -237101,6 +248835,8 @@ self: { ]; description = "Extract a part from CommonMark/Markdown docs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "subnet" = callPackage @@ -237130,6 +248866,8 @@ self: { ]; description = "Subsample data"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "substring-parser" = callPackage @@ -237148,6 +248886,7 @@ self: { ]; description = "Match / replace substrings with a parser combinators"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "subtitleParser" = callPackage @@ -237184,6 +248923,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Subword graph implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "subzero" = callPackage @@ -237242,6 +248983,8 @@ self: { benchmarkHaskellDepends = [ base criterion random ]; description = "Simple and moderately efficient suffix array implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "suffixarray" = callPackage @@ -237256,6 +248999,8 @@ self: { executableHaskellDepends = [ base HUnit ]; description = "n log n implementation of suffix array"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "suffixtree" = callPackage @@ -237280,6 +249025,8 @@ self: { executableHaskellDepends = [ base process ]; description = "Library-based syntactic extensibility for Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "suitable" = callPackage @@ -237291,6 +249038,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Abstract over the constraints on the parameters to type constructors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sum-type-boilerplate" = callPackage @@ -237342,6 +249091,8 @@ self: { ]; description = "Tool for scaffolding fully configured batteries-included production-level Haskell projects"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "summoner-tui" = callPackage @@ -237361,6 +249112,7 @@ self: { executableHaskellDepends = [ base relude ]; description = "Tool for scaffolding fully configured batteries-included production-level Haskell projects using TUI"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "sump" = callPackage @@ -237378,6 +249130,7 @@ self: { ]; description = "A Haskell interface to SUMP-compatible logic analyzers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sundown" = callPackage @@ -237405,6 +249158,8 @@ self: { ]; description = "Test Cabalized package against multiple dependency versions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sunroof-compiler" = callPackage @@ -237422,6 +249177,8 @@ self: { ]; description = "Monadic Javascript Compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sunroof-examples" = callPackage @@ -237443,6 +249200,7 @@ self: { ]; description = "Tests for Sunroof"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sunroof-server" = callPackage @@ -237464,6 +249222,7 @@ self: { ]; description = "Monadic Javascript Compiler - Server Utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "super-user-spark" = callPackage @@ -237493,6 +249252,8 @@ self: { ]; description = "Configure your dotfile deployment with a DSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "superbubbles" = callPackage @@ -237507,6 +249268,8 @@ self: { testHaskellDepends = [ base containers hspec ]; description = "Find \"superbubbles\", as described in https://arxiv.org/abs/1307.7925"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "superbuffer" = callPackage @@ -237541,6 +249304,7 @@ self: { ]; description = "Haskell SuperCollider utilities"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "supercollider-midi" = callPackage @@ -237563,6 +249327,7 @@ self: { ]; description = "Demonstrate how to control SuperCollider via ALSA-MIDI"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "superconstraints" = callPackage @@ -237579,6 +249344,7 @@ self: { ]; description = "Access an instance's constraints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "superdoc" = callPackage @@ -237618,6 +249384,8 @@ self: { ]; description = "A simple opinionated event store implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "supermonad" = callPackage @@ -237634,6 +249402,8 @@ self: { testHaskellDepends = [ base containers ghc QuickCheck ]; description = "Plugin and base library to support supermonads in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "supernova" = callPackage @@ -237654,6 +249424,8 @@ self: { testHaskellDepends = [ aeson async base bytestring streamly text ]; description = "Apache Pulsar client for Haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "supero" = callPackage @@ -237672,6 +249444,8 @@ self: { ]; description = "A Supercompiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "superrecord" = callPackage @@ -237704,6 +249478,8 @@ self: { ]; description = "Control an internal monad execution for trace generation, backtrakcking, testing and other purposes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "supervisors" = callPackage @@ -237738,6 +249514,8 @@ self: { ]; description = "Early termination for monads"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "surjective" = callPackage @@ -237749,6 +249527,8 @@ self: { libraryHaskellDepends = [ base lens mtl template-haskell ]; description = "An output coverage checker"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "suspend" = callPackage @@ -237788,6 +249568,7 @@ self: { ]; description = "Encode and decode separated values (CSV, PSV, ...)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sv-cassava" = callPackage @@ -237809,6 +249590,7 @@ self: { ]; description = "Integration to use sv with cassava's parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sv-core" = callPackage @@ -237836,6 +249618,8 @@ self: { ]; description = "Encode and decode separated values (CSV, PSV, ...)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sv-svfactor" = callPackage @@ -237853,6 +249637,7 @@ self: { ]; description = "sv-core + svfactor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "svfactor" = callPackage @@ -237878,6 +249663,8 @@ self: { ]; description = "Syntax-preserving CSV manipulation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "svg-builder" = callPackage @@ -237910,6 +249697,8 @@ self: { ]; description = "DSL for building SVG"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "svg-tree" = callPackage @@ -237946,6 +249735,7 @@ self: { ]; description = "Code generation tool for Quartz code from a SVG"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "svgcairo" = callPackage @@ -237962,6 +249752,8 @@ self: { libraryPkgconfigDepends = [ librsvg ]; description = "Binding to the libsvg-cairo library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) librsvg;}; "svgone" = callPackage @@ -237985,6 +249777,7 @@ self: { ]; description = "Optimise SVGs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "svgutils" = callPackage @@ -237999,6 +249792,8 @@ self: { executableHaskellDepends = [ base filepath xml ]; description = "Helper functions for dealing with SVG files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "svm" = callPackage @@ -238023,6 +249818,8 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring containers ]; description = "Parsers and formatters for the SVMlight input file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "svm-simple" = callPackage @@ -238039,6 +249836,8 @@ self: { ]; description = "Medium level, simplified, bindings to libsvm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "svndump" = callPackage @@ -238057,6 +249856,8 @@ self: { ]; description = "Library for reading Subversion dump files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "swagger" = callPackage @@ -238101,6 +249902,8 @@ self: { ]; description = "Auto-generated openapi-petstore API Client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "swagger-test" = callPackage @@ -238130,6 +249933,8 @@ self: { ]; description = "Testing of Swagger APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "swagger2" = callPackage @@ -238181,6 +249986,7 @@ self: { librarySystemDepends = [ tokyocabinet ]; description = "Transparently swapping data from in-memory structures to disk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) tokyocabinet;}; "swearjure" = callPackage @@ -238200,6 +250006,7 @@ self: { ]; description = "Clojure without alphanumerics"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "sweet-egison" = callPackage @@ -238222,6 +250029,7 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Shallow embedding implementation of non-linear pattern matching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "swf" = callPackage @@ -238233,6 +250041,8 @@ self: { libraryHaskellDepends = [ base mtl pretty ]; description = "A library for creating Shockwave Flash (SWF) files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "swift-lda" = callPackage @@ -238248,6 +250058,8 @@ self: { ]; description = "Online sampler for Latent Dirichlet Allocation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "swish" = callPackage @@ -238287,6 +250099,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell bindings for the Swiss Ephemeris C library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "swisstable" = callPackage @@ -238310,6 +250124,8 @@ self: { ]; description = "SwissTable hash map"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "switch" = callPackage @@ -238326,6 +250142,7 @@ self: { ]; description = "Nintendo Switch Controller Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sws" = callPackage @@ -238387,6 +250204,8 @@ self: { libraryHaskellDepends = [ base eq prelude-extras ]; description = "Higher order versions of the Scrap Your Boilerplate classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "syb-with-class" = callPackage @@ -238414,6 +250233,8 @@ self: { libraryHaskellDepends = [ base syb-with-class text ]; description = "Scrap Your Boilerplate With Class Text instance"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sydtest" = callPackage @@ -238567,6 +250388,8 @@ self: { ]; description = "Synthesis Format Conversion Tool / Library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sylvia" = callPackage @@ -238592,6 +250415,7 @@ self: { ]; description = "Lambda calculus visualization"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "sym" = callPackage @@ -238604,6 +250428,8 @@ self: { testHaskellDepends = [ base hashable QuickCheck ]; description = "Permutations, patterns, and statistics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sym-plot" = callPackage @@ -238615,6 +250441,7 @@ self: { libraryHaskellDepends = [ base diagrams-cairo diagrams-lib sym ]; description = "Plot permutations; an addition to the sym package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "symantic" = callPackage @@ -238631,6 +250458,8 @@ self: { ]; description = "Library for Typed Tagless-Final Higher-Order Composable DSL"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "symantic-atom" = callPackage @@ -238652,6 +250481,7 @@ self: { ]; description = "Library for reading and writing Atom"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "symantic-base" = callPackage @@ -238679,6 +250509,8 @@ self: { ]; description = "Symantics for parsing and documenting a CLI"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "symantic-document" = callPackage @@ -238837,6 +250669,8 @@ self: { ]; description = "Test symantic-http and its companion libraries"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "symantic-lib" = callPackage @@ -238859,6 +250693,7 @@ self: { ]; description = "Symantics for common types"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "symantic-parser" = callPackage @@ -238882,6 +250717,8 @@ self: { ]; description = "Parser combinators statically optimized and staged via typed meta-programming"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "symantic-xml" = callPackage @@ -238905,6 +250742,8 @@ self: { ]; description = "Library for reading, validating and writing XML"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "symbiote" = callPackage @@ -238936,6 +250775,7 @@ self: { ]; description = "Data serialization, communication, and operation verification implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "symbol" = callPackage @@ -238961,6 +250801,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit unix ]; description = "Symlink functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "symbols" = callPackage @@ -238987,6 +250829,8 @@ self: { testSystemDepends = [ gmp gmpxx symengine ]; description = "SymEngine symbolic mathematics engine for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gmp; inherit (pkgs) gmpxx; inherit (pkgs) symengine;}; @@ -239005,6 +250849,8 @@ self: { testSystemDepends = [ gmp gmpxx symengine ]; description = "SymEngine symbolic mathematics engine for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gmp; inherit (pkgs) gmpxx; inherit (pkgs) symengine;}; @@ -239034,6 +250880,7 @@ self: { ]; description = "Derivation of symbols and coordinate triplets Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "symon" = callPackage @@ -239060,6 +250907,8 @@ self: { libraryHaskellDepends = [ base stm ]; description = "A fast implementation of synchronous channels with a CML-like API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sync-mht" = callPackage @@ -239097,6 +250946,8 @@ self: { ]; description = "Fast incremental file transfer using Merkle-Hash-Trees"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "synchronous-channels" = callPackage @@ -239135,6 +250986,7 @@ self: { ]; description = "Haskell bindings for the Syncthing REST API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "synt" = callPackage @@ -239211,6 +251063,7 @@ self: { ]; description = "Reversible parsing and pretty-printing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "syntax-attoparsec" = callPackage @@ -239226,6 +251079,7 @@ self: { ]; description = "Syntax instances for Attoparsec"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "syntax-example" = callPackage @@ -239244,6 +251098,7 @@ self: { ]; description = "Example application using syntax, a library for abstract syntax descriptions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "syntax-example-json" = callPackage @@ -239262,6 +251117,7 @@ self: { ]; description = "Example JSON parser/pretty-printer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "syntax-pretty" = callPackage @@ -239276,6 +251132,7 @@ self: { ]; description = "Syntax instance for pretty, the pretty printing library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "syntax-printer" = callPackage @@ -239292,6 +251149,7 @@ self: { ]; description = "Text and ByteString printers for 'syntax'"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "syntax-trees" = callPackage @@ -239307,6 +251165,8 @@ self: { ]; description = "Convert between different Haskell syntax trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "syntax-trees-fork-bairyn" = callPackage @@ -239322,6 +251182,8 @@ self: { ]; description = "Convert between different Haskell syntax trees. Bairyn's fork."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "syntaxnet-haskell" = callPackage @@ -239340,6 +251202,7 @@ self: { testHaskellDepends = [ aeson base cassava haskell-conll hspec ]; description = "Working with Google's SyntaxNet output files - CoNLL, Tree"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "synthesizer" = callPackage @@ -239361,6 +251224,8 @@ self: { ]; description = "Audio signal processing coded in Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "synthesizer-alsa" = callPackage @@ -239502,6 +251367,7 @@ self: { doHaddock = false; description = "Efficient signal processing using runtime compilation"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "synthesizer-midi" = callPackage @@ -239561,6 +251427,8 @@ self: { ]; description = "A replacement for System.Exit and System.Process."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sysinfo" = callPackage @@ -239600,6 +251468,8 @@ self: { testHaskellDepends = [ base basic-prelude chell system-filepath ]; description = "Abstract data type for canonical paths with some utilities"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-command" = callPackage @@ -239618,6 +251488,8 @@ self: { ]; description = "A replacement for System.Exit and System.Process"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-error" = callPackage @@ -239643,6 +251515,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "A bunch of system utilities used by other projects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-fileio" = callPackage @@ -239714,6 +251588,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Binding to Linux's inotify interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-lifted" = callPackage @@ -239736,6 +251612,8 @@ self: { ]; description = "Lifted versions of System functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-linux-proc" = callPackage @@ -239752,6 +251630,8 @@ self: { testHaskellDepends = [ base directory hedgehog pretty-show ]; description = "A library for accessing the /proc filesystem in Linux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-locale" = callPackage @@ -239768,6 +251648,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Get system locales"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-posix-redirect" = callPackage @@ -239805,6 +251687,8 @@ self: { ]; description = "Random number generation for extensible effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "system-test" = callPackage @@ -239910,6 +251794,7 @@ self: { ]; description = "An application that regularly logs system stats for later analysis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "syz" = callPackage @@ -239938,6 +251823,8 @@ self: { ]; description = "Matchers and grammars using tree regular expressions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "t3-client" = callPackage @@ -239949,6 +251836,7 @@ self: { libraryHaskellDepends = [ base t3-game t3-server ]; description = "tic-tac-toe Rexports for client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "t3-game" = callPackage @@ -239984,6 +251872,8 @@ self: { ]; description = "tic-tac-toe server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ta" = callPackage @@ -239999,6 +251889,7 @@ self: { ]; description = "Transito Abierto: convenience library when using Takusen and Oracle"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tabl" = callPackage @@ -240028,6 +251919,8 @@ self: { ]; description = "Simple tool to generate tables from DSV input"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "table-layout" = callPackage @@ -240052,6 +251945,8 @@ self: { ]; description = "Format tabular data as grid or table"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "table-tennis" = callPackage @@ -240063,6 +251958,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A table tennis game tracking engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tableaux" = callPackage @@ -240080,6 +251977,8 @@ self: { ]; description = "An interactive theorem prover based on semantic tableaux"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tables" = callPackage @@ -240103,6 +252002,8 @@ self: { ]; description = "In-memory storage with multiple keys using lenses and traversals"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tablestorage" = callPackage @@ -240123,6 +252024,8 @@ self: { ]; description = "Azure Table Storage REST API Wrapper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tablize" = callPackage @@ -240159,6 +252062,8 @@ self: { ]; description = "View the output of shell commands in a table"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tabs" = callPackage @@ -240173,6 +252078,8 @@ self: { executableHaskellDepends = [ base filepath monadlist mtl tagged ]; description = "Indents source files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tabular" = callPackage @@ -240231,6 +252138,7 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gtk3;}; "tag-bits" = callPackage @@ -240242,6 +252150,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Provides access to the dynamic pointer tagging bits used by GHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tag-stream" = callPackage @@ -240257,6 +252167,7 @@ self: { ]; description = "streamlined html tag parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tagchup" = callPackage @@ -240323,6 +252234,8 @@ self: { ]; description = "Reflect exceptions using phantom types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tagged-identity" = callPackage @@ -240353,6 +252266,7 @@ self: { ]; description = "Lists tagged with a type-level natural number representing their length"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tagged-th" = callPackage @@ -240366,6 +252280,7 @@ self: { ]; description = "QuasiQuoter and Template Haskell splices for creating proxies at higher-kinds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tagged-timers" = callPackage @@ -240379,6 +252294,8 @@ self: { ]; description = "Simple wrappers for timing IO actions (single-threaded)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tagged-transformer" = callPackage @@ -240481,6 +252398,8 @@ self: { libraryPkgconfigDepends = [ taglib ]; description = "An FFI layer over TagLib's C bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) taglib;}; "tagset-positional" = callPackage @@ -240546,6 +252465,8 @@ self: { ]; description = "alternative parser for the tagsoup package"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tagsoup-megaparsec" = callPackage @@ -240562,6 +252483,8 @@ self: { ]; description = "A Tag token parser and Tag specific parsing combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tagsoup-navigate" = callPackage @@ -240579,6 +252502,7 @@ self: { ]; description = "Tagsoup Navigate"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tagsoup-parsec" = callPackage @@ -240590,6 +252514,8 @@ self: { libraryHaskellDepends = [ base parsec tagsoup ]; description = "Tokenizes Tag, so [ Tag ] can be used as parser input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tagsoup-selection" = callPackage @@ -240601,6 +252527,8 @@ self: { libraryHaskellDepends = [ base containers parsec tagsoup ]; description = "Selecting subtrees from TagSoup's TagTrees using CSS selectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tagstew" = callPackage @@ -240621,6 +252549,7 @@ self: { ]; description = "Black magic tagsoup"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tagstream-conduit" = callPackage @@ -240658,6 +252587,8 @@ self: { ]; description = "Support library to enable TAI usage on systems with time kept in UTC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tai64" = callPackage @@ -240676,6 +252607,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Tai64 Labels for Haskell"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tailfile-hinotify" = callPackage @@ -240748,6 +252681,8 @@ self: { libraryHaskellDepends = [ base lens monad-skeleton mtl ]; description = "create slide for presentation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "takusen-oracle" = callPackage @@ -240762,6 +252697,8 @@ self: { librarySystemDepends = [ clntsh ]; description = "Database library with left-fold interface for Oracle"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {clntsh = null;}; "tal" = callPackage @@ -240777,6 +252714,7 @@ self: { ]; description = "An implementation of Typed Assembly Language (Morrisett, Walker, Crary, Glew)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "tamarin-prover" = callPackage @@ -240806,6 +252744,7 @@ self: { ]; description = "The Tamarin prover for security protocol analysis"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "tamarin-prover-term" = callPackage @@ -240824,6 +252763,7 @@ self: { ]; description = "Term manipulation library for the tamarin prover"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "tamarin-prover-theory" = callPackage @@ -240845,6 +252785,7 @@ self: { ]; description = "Term manipulation library for the tamarin prover"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "tamarin-prover-utils" = callPackage @@ -240862,6 +252803,8 @@ self: { ]; description = "Utility library for the tamarin prover"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tamper" = callPackage @@ -240923,6 +252866,8 @@ self: { testHaskellDepends = [ base hspec vector ]; description = "A tasty enhancement to cassava for easy csv exporting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tar" = callPackage @@ -241053,6 +252998,7 @@ self: { ]; description = "Generate test-suites from refinement types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) z3;}; "tart" = callPackage @@ -241094,6 +253040,7 @@ self: { ]; description = "A command line tool for keeping track of tasks you worked on"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "task-distribution" = callPackage @@ -241130,6 +253077,7 @@ self: { ]; description = "Distributed processing of changing tasks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "taskell" = callPackage @@ -241256,6 +253204,8 @@ self: { ]; description = "Auto discovery for Tasty with support for ingredients and test tree generation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-bdd" = callPackage @@ -241281,6 +253231,7 @@ self: { ]; description = "BDD tests language and tasty provider"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tasty-bench" = callPackage @@ -241382,6 +253333,8 @@ self: { ]; description = "Adds the ability to fail a tasty test suite on first test failure"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-focus" = callPackage @@ -241440,6 +253393,8 @@ self: { testHaskellDepends = [ aeson base tasty tasty-hunit ]; description = "Grade your tasty-testsuite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-groundhog-converters" = callPackage @@ -241458,6 +253413,7 @@ self: { ]; description = "Tasty Tests for groundhog converters"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tasty-hedgehog" = callPackage @@ -241515,6 +253471,8 @@ self: { ]; description = "Coverage tracking for Hedgehog Property-Based Testing via Tasty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-hspec" = callPackage @@ -241629,6 +253587,7 @@ self: { ]; description = "automated integration of QuickCheck properties into tasty suites"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tasty-jenkins-xml" = callPackage @@ -241648,6 +253607,7 @@ self: { ]; description = "Render tasty output to both console and XML for Jenkins"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tasty-json" = callPackage @@ -241696,6 +253656,7 @@ self: { testHaskellDepends = [ base smallcheck smallcheck-laws tasty ]; description = "Test common laws"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tasty-leancheck" = callPackage @@ -241724,6 +253685,7 @@ self: { testHaskellDepends = [ base lens tasty ]; description = "Tasty TestTrees for Lens validation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tasty-lua" = callPackage @@ -241767,6 +253729,8 @@ self: { ]; description = "Golden testing provider for tasty with muti-line diff output"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-program" = callPackage @@ -241885,6 +253849,8 @@ self: { ]; description = "Collect statistics of your Tasty testsuite"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-sugar" = callPackage @@ -241955,6 +253921,8 @@ self: { libraryHaskellDepends = [ base tasty ]; description = "Test vector support for tasty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-th" = callPackage @@ -242034,6 +254002,7 @@ self: { ]; description = "Meta tic-tac-toe ncurses game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tau" = callPackage @@ -242075,6 +254044,7 @@ self: { ]; description = "Transactional variables and data structures with IO hooks"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "tcache-AWS" = callPackage @@ -242090,6 +254060,8 @@ self: { ]; description = "tcache using Amazon Web Services as default persistence mechanism"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tccli" = callPackage @@ -242107,6 +254079,7 @@ self: { ]; description = "TokyoCabinet CLI interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tce-conf" = callPackage @@ -242140,6 +254113,8 @@ self: { libraryPkgconfigDepends = [ libtcod ]; description = "Bindings to libtcod roguelike engine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libtcod;}; "tconfig" = callPackage @@ -242162,6 +254137,8 @@ self: { libraryHaskellDepends = [ base containers old-time ]; description = "A purely functional TCP implementation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tcp-streams" = callPackage @@ -242205,6 +254182,8 @@ self: { ]; description = "Tcp streams using openssl for tls support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tdd-util" = callPackage @@ -242232,6 +254211,7 @@ self: { ]; description = "Test framework wrapper"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tdigest" = callPackage @@ -242301,6 +254281,7 @@ self: { testSystemDepends = [ tdlib ]; description = "complete binding to the Telegram Database Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) tdlib;}; "tdlib-gen" = callPackage @@ -242329,6 +254310,7 @@ self: { ]; description = "Codegen for TDLib"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tdlib-types" = callPackage @@ -242349,6 +254331,7 @@ self: { ]; description = "Types and Functions generated from tdlib api spec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tdoc" = callPackage @@ -242385,6 +254368,8 @@ self: { executableHaskellDepends = [ base ]; description = "Pure Haskell TDS protocol implementation. Mainly for beam-mssql and beam-sybase"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "teams" = callPackage @@ -242396,6 +254381,8 @@ self: { libraryHaskellDepends = [ base containers fgl graphviz ]; description = "Graphical modeling tools for sequential teams"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "teardown" = callPackage @@ -242438,6 +254425,7 @@ self: { ]; description = "Bleeding edge prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "technique" = callPackage @@ -242480,6 +254468,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Dental data types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tehepero" = callPackage @@ -242510,6 +254500,8 @@ self: { ]; description = "Telegram API client"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "telegram-api" = callPackage @@ -242537,6 +254529,8 @@ self: { ]; description = "Telegram Bot API bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "telegram-bot" = callPackage @@ -242557,6 +254551,7 @@ self: { testHaskellDepends = [ base ]; description = "Telegram Bot microframework for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "telegram-bot-simple" = callPackage @@ -242612,6 +254607,7 @@ self: { ]; description = "Servant bindings to the Telegram bot API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "telegram-types" = callPackage @@ -242633,6 +254629,7 @@ self: { ]; description = "Types used in Telegram bot API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "telegraph" = callPackage @@ -242673,6 +254670,8 @@ self: { testHaskellDepends = [ base ]; description = "A tool to quickly switch between directories"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "teleshell" = callPackage @@ -242695,6 +254694,8 @@ self: { ]; description = "Telnet client and other things"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tellbot" = callPackage @@ -242714,6 +254715,8 @@ self: { ]; description = "IRC tellbot"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tempered" = callPackage @@ -242746,6 +254749,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "For representing musical tempi"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "template" = callPackage @@ -242768,6 +254773,8 @@ self: { libraryHaskellDepends = [ base data-default template-haskell ]; description = "declaring Default instances just got even easier"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "template-haskell_2_17_0_0" = callPackage @@ -242817,6 +254824,8 @@ self: { ]; description = "Some utilities for template Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "template-hsml" = callPackage @@ -242837,6 +254846,8 @@ self: { ]; description = "Haskell's Simple Markup Language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "template-toolkit" = callPackage @@ -242867,6 +254878,8 @@ self: { libraryHaskellDepends = [ base bytestring text ]; description = "Process template file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "templateify" = callPackage @@ -242880,6 +254893,8 @@ self: { executableHaskellDepends = [ base mtl tagsoup uniplate ]; description = "Make template from website"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "templatepg" = callPackage @@ -242897,6 +254912,8 @@ self: { ]; description = "A PostgreSQL access library with compile-time SQL type inference"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "templater" = callPackage @@ -242951,6 +254968,8 @@ self: { ]; description = "A small Haskell wrapper around the TempoDB api"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "temporal-csound" = callPackage @@ -242968,6 +254987,8 @@ self: { ]; description = "library to make electronic music, brings together temporal-music-notation and csound-expression packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "temporal-media" = callPackage @@ -243089,6 +255110,8 @@ self: { executableToolDepends = [ happy ]; description = "Interpreter for the FRP language Tempus"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tempus-fugit" = callPackage @@ -243116,6 +255139,8 @@ self: { testHaskellDepends = [ base QuickCheck random ]; description = "A completely type-safe library for linear algebra"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tensor-safe" = callPackage @@ -243139,6 +255164,8 @@ self: { ]; description = "Create valid deep neural network architectures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tensorflow" = callPackage @@ -243167,6 +255194,8 @@ self: { ]; description = "TensorFlow bindings"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {libtensorflow = null;}; "tensorflow-core-ops" = callPackage @@ -243187,6 +255216,7 @@ self: { ]; description = "Haskell wrappers for Core Tensorflow Ops"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "tensorflow-logging" = callPackage @@ -243215,6 +255245,7 @@ self: { ]; description = "TensorBoard related functionality"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "tensorflow-mnist" = callPackage @@ -243267,6 +255298,8 @@ self: { ]; description = "Code generation for TensorFlow operations"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tensorflow-ops" = callPackage @@ -243296,6 +255329,7 @@ self: { ]; description = "Friendly layer around TensorFlow bindings"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "tensorflow-proto" = callPackage @@ -243390,6 +255424,8 @@ self: { testHaskellDepends = [ base containers HUnit QuickCheck ]; description = "Term Rewriting Library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "termbox" = callPackage @@ -243416,6 +255452,7 @@ self: { libraryHaskellDepends = [ base reactive-banana termbox ]; description = "reactive-banana + termbox"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "termbox-bindings" = callPackage @@ -243431,6 +255468,8 @@ self: { executableHaskellDepends = [ base ]; description = "Bindings to the Termbox library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "termcolor" = callPackage @@ -243526,6 +255565,7 @@ self: { ]; description = "Text data type for styled terminal output, including all standard ANSI effects (bold, italic, blinking) and ANSI / 256 / truecolor colors support for Unix and Windows (whenever possible)"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "termination-combinators" = callPackage @@ -243537,6 +255577,8 @@ self: { libraryHaskellDepends = [ base containers contravariant ]; description = "Termination combinators for forcing non-terminating algorithms to terminate"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "terminfo_0_4_1_4" = callPackage @@ -243623,6 +255665,8 @@ self: { ]; description = "Plot time series in your terminal using commands stdout"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "terntup" = callPackage @@ -243640,6 +255684,8 @@ self: { ]; description = "a ternary library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "terraform-http-backend-pass" = callPackage @@ -243660,6 +255706,8 @@ self: { executableHaskellDepends = [ base ]; description = "HTTP backend to store terraform state using pass and git"; license = "AGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "terrahs" = callPackage @@ -243672,6 +255720,7 @@ self: { librarySystemDepends = [ terralib4c translib ]; description = "A Haskell GIS Programming Environment"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {terralib4c = null; translib = null;}; "tersmu" = callPackage @@ -243692,6 +255741,8 @@ self: { ]; description = "A semantic parser for lojban"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tesla" = callPackage @@ -243741,6 +255792,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Test monadic side-effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-framework" = callPackage @@ -243781,6 +255834,8 @@ self: { testHaskellDepends = [ base test-framework ]; description = "Test.Framework wrapper for DocTest"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-framework-golden" = callPackage @@ -243850,6 +255905,8 @@ self: { ]; description = "QuickCheck support for the test-framework package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-framework-quickcheck2" = callPackage @@ -243887,6 +255944,7 @@ self: { ]; description = "test-sandbox support for the test-framework package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "test-framework-skip" = callPackage @@ -243906,6 +255964,8 @@ self: { ]; description = "Functions for conveniently marking some of the tests in a suite as being skipped"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-framework-smallcheck" = callPackage @@ -243931,6 +255991,8 @@ self: { testHaskellDepends = [ base test-framework testing-feat ]; description = "A test framework provider for testing-feat"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-framework-th" = callPackage @@ -243962,6 +256024,8 @@ self: { ]; description = "Template Haskell for test framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-fun" = callPackage @@ -244063,6 +256127,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Just tests Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-sandbox" = callPackage @@ -244090,6 +256156,8 @@ self: { ]; description = "Sandbox for system tests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-sandbox-compose" = callPackage @@ -244121,6 +256189,7 @@ self: { ]; description = "Lightweight development enviroments using test-sandbox"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "test-sandbox-hunit" = callPackage @@ -244132,6 +256201,7 @@ self: { libraryHaskellDepends = [ base HUnit lifted-base test-sandbox ]; description = "HUnit convenience functions for use with test-sandbox"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "test-sandbox-quickcheck" = callPackage @@ -244147,6 +256217,7 @@ self: { ]; description = "QuickCheck convenience functions for use with test-sandbox"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "test-shouldbe" = callPackage @@ -244160,6 +256231,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Catchy combinators for HUnit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "test-simple" = callPackage @@ -244178,6 +256251,7 @@ self: { ]; description = "Simple Perl inspired testing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "testCom" = callPackage @@ -244195,6 +256269,8 @@ self: { ]; description = "Write your tests in comments"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "testPkg" = callPackage @@ -244230,6 +256306,7 @@ self: { ]; description = "Create tests and benchmarks together"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "testcontainers" = callPackage @@ -244252,6 +256329,8 @@ self: { testToolDepends = [ hspec-discover tasty-discover ]; description = "Docker containers for your integration tests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "testing-feat" = callPackage @@ -244296,6 +256375,8 @@ self: { ]; description = "Quick feedback loop for test suites"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "testpack" = callPackage @@ -244312,6 +256393,8 @@ self: { ]; description = "Test Utililty Pack for HUnit and QuickCheck (unmaintained)"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "testpattern" = callPackage @@ -244326,6 +256409,8 @@ self: { executableHaskellDepends = [ base filepath gtk ]; description = "Display a monitor test pattern"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "testrunner" = callPackage @@ -244340,6 +256425,8 @@ self: { ]; description = "Easy unit test driver framework"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tetris" = callPackage @@ -244388,6 +256475,8 @@ self: { executableHaskellDepends = [ base containers deepseq parsec ]; description = "LaTeX to plain-text conversion"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "texbuilder" = callPackage @@ -244408,6 +256497,8 @@ self: { ]; description = "View your latex output while editing"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "texmath" = callPackage @@ -244452,6 +256543,8 @@ self: { ]; description = "Functions for running Tex from Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text_1_2_4_1" = callPackage @@ -244484,6 +256577,8 @@ self: { ]; description = "Everything Data.Text related in one package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-and-plots" = callPackage @@ -244500,6 +256595,8 @@ self: { ]; description = "EDSL to create HTML documents with plots based on the C3.js library."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-ansi" = callPackage @@ -244532,6 +256629,8 @@ self: { ]; description = "ASCII string and character processing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-binary" = callPackage @@ -244586,6 +256685,8 @@ self: { ]; description = "Memory-efficient string-indexed container types"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-conversions" = callPackage @@ -244655,6 +256756,8 @@ self: { testHaskellDepends = [ base hspec time ]; description = "Full-weight string formatting library, analog of Python's string.format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-format-simple" = callPackage @@ -244690,6 +256793,8 @@ self: { ]; description = "A generic, derivable, haskell pretty printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-icu" = callPackage @@ -244733,6 +256838,8 @@ self: { ]; description = "Dealing with Strict Text in NFC normalization"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-icu-translit" = callPackage @@ -244816,6 +256923,8 @@ self: { testHaskellDepends = [ base hspec lens ]; description = "Lenses for operating over text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-lips" = callPackage @@ -244831,6 +256940,8 @@ self: { ]; description = "Monadic parsing combinator library with attention to locations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-loc" = callPackage @@ -244883,6 +256994,8 @@ self: { ]; description = "A data structure for mapping metadata to text subsequences"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-metrics" = callPackage @@ -244916,6 +257029,8 @@ self: { ]; description = "Unicode-normalized text"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-offset" = callPackage @@ -244934,6 +257049,8 @@ self: { ]; description = "Library for converting between line/column and byte offset"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-plus" = callPackage @@ -244950,6 +257067,7 @@ self: { testHaskellDepends = [ base doctest HTF text ]; description = "Utils for text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "text-position" = callPackage @@ -244964,6 +257082,8 @@ self: { testHaskellDepends = [ base QuickCheck regex-applicative ]; description = "Handling positions in text and position-tagging it"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-postgresql" = callPackage @@ -245043,6 +257163,8 @@ self: { libraryHaskellDepends = [ base containers mtl vector ]; description = "A Haskell implementation of the 1# Text Register Machine"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-render" = callPackage @@ -245071,6 +257193,8 @@ self: { testHaskellDepends = [ base hedgehog neat-interpolation text ]; description = "Simple text replacements from a list of search/replace pairs"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-short" = callPackage @@ -245209,6 +257333,7 @@ self: { ]; description = "An efficient finite map from Text to values, based on bytestring-trie"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "text-utf7" = callPackage @@ -245250,6 +257375,8 @@ self: { ]; description = "An efficient packed UTF-8 backed Unicode text type"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-utils" = callPackage @@ -245290,6 +257417,8 @@ self: { libraryHaskellDepends = [ base parsec template-haskell xml ]; description = "Quasiquoter for xml. XML DSL in Haskell."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-zipper" = callPackage @@ -245315,6 +257444,8 @@ self: { testHaskellDepends = [ base hspec text-zipper ]; description = "Monadic interface to the text-zipper package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text1" = callPackage @@ -245331,6 +257462,8 @@ self: { ]; description = "Non-empty values of `Data.Text`."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "textPlot" = callPackage @@ -245371,6 +257504,7 @@ self: { executableHaskellDepends = [ base haskell98 process ]; description = "A simple Haskell program to provide tags for Haskell code completion in TextMate"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "textocat-api" = callPackage @@ -245391,6 +257525,8 @@ self: { ]; description = "Unofficial Haskell SDK for Textocat API -- http://textocat.com"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "texts" = callPackage @@ -245413,6 +257549,8 @@ self: { libraryHaskellDepends = [ base bytestring text utf8-string ]; description = "Textual type class for data that represent text"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tf-random" = callPackage @@ -245447,6 +257585,8 @@ self: { libraryHaskellDepends = [ base template-haskell tfp ]; description = "Template-Haskell code for tfp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tftp" = callPackage @@ -245471,6 +257611,8 @@ self: { ]; description = "A library for building tftp servers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tga" = callPackage @@ -245482,6 +257624,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Reading and writing of tga image files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-abstraction" = callPackage @@ -245517,6 +257661,7 @@ self: { ]; description = "Alpha equivalence for TH Exp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "th-bang-compat" = callPackage @@ -245539,6 +257684,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "More convenient construction of TH ASTs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-cas" = callPackage @@ -245602,6 +257749,7 @@ self: { ]; description = "Test instance context"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "th-data-compat" = callPackage @@ -245669,6 +257817,8 @@ self: { libraryHaskellDepends = [ base constraints template-haskell ]; description = "Automatically discover available dictionaries at compile time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-env" = callPackage @@ -245720,6 +257870,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "TH fold generator"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-format" = callPackage @@ -245736,6 +257888,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit text ]; description = "Template Haskell based support for format strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-inline-io-action" = callPackage @@ -245767,6 +257921,8 @@ self: { ]; description = "Fixed versions of instances reification functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-instances" = callPackage @@ -245790,6 +257946,7 @@ self: { ]; description = "A place to collect orphan instances for Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "th-kinds" = callPackage @@ -245805,6 +257962,8 @@ self: { ]; description = "Automated kind inference in Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-kinds-fork" = callPackage @@ -245820,6 +257979,8 @@ self: { ]; description = "Automated kind inference in Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-lego" = callPackage @@ -245840,6 +258001,8 @@ self: { ]; description = "Template Haskell construction utilities"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-lift" = callPackage @@ -245921,6 +258084,8 @@ self: { libraryHaskellDepends = [ base lens pretty template-haskell ]; description = "Simplify and render Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-printf" = callPackage @@ -245979,6 +258144,8 @@ self: { libraryHaskellDepends = [ base containers template-haskell ]; description = "Binding group analysis in Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-strict-compat" = callPackage @@ -246005,6 +258172,8 @@ self: { ]; description = "Typechecking in Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-test-utils" = callPackage @@ -246038,6 +258207,8 @@ self: { testHaskellDepends = [ base hspec template-haskell ]; description = "Provides a way to persist data from compile-time to runtime"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-traced" = callPackage @@ -246049,6 +258220,8 @@ self: { libraryHaskellDepends = [ base containers mtl template-haskell ]; description = "Tracing Q monad computation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "th-typegraph" = callPackage @@ -246076,6 +258249,7 @@ self: { ]; description = "Graph of the subtype relation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "th-utilities" = callPackage @@ -246119,6 +258293,8 @@ self: { ]; description = "Give your dependencies stars on GitHub!"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "theatre" = callPackage @@ -246134,6 +258310,7 @@ self: { ]; description = "Minimalistic actor library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "themoviedb" = callPackage @@ -246206,6 +258383,8 @@ self: { ]; description = "All-in-one session handling for servant-based frontends"; license = "AGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "theoremquest" = callPackage @@ -246217,6 +258396,8 @@ self: { libraryHaskellDepends = [ base HTTP json utf8-string ]; description = "A common library for TheoremQuest, a theorem proving game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "theoremquest-client" = callPackage @@ -246230,6 +258411,7 @@ self: { executableHaskellDepends = [ base HTTP network theoremquest ]; description = "A simple client for the TheoremQuest theorem proving game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "these" = callPackage @@ -246314,6 +258496,8 @@ self: { libraryHaskellDepends = [ base pretty ]; description = "Typing Haskell In Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "thimk" = callPackage @@ -246332,6 +258516,7 @@ self: { ]; description = "Command-line spelling word suggestion tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "thock" = callPackage @@ -246359,6 +258544,8 @@ self: { ]; description = "A modern TUI typing game featuring online racing against friends"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "thorn" = callPackage @@ -246377,6 +258564,8 @@ self: { ]; description = "Datatype Manipulation with Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "thread-hierarchy" = callPackage @@ -246466,6 +258655,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "(deprecated in favor of 'threads') Simple thread management"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "threads" = callPackage @@ -246584,6 +258775,8 @@ self: { ]; description = "Composable algebraic editors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "threepenny-gui" = callPackage @@ -246624,6 +258817,8 @@ self: { executableHaskellDepends = [ base threepenny-gui ]; description = "Write simple nested context menus for threepenny-gui"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "threepenny-gui-flexbox" = callPackage @@ -246638,6 +258833,8 @@ self: { executableHaskellDepends = [ base threepenny-gui ]; description = "Flexbox layouts for Threepenny-gui"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "thrift" = callPackage @@ -246660,6 +258857,8 @@ self: { ]; description = "Haskell bindings for the Apache Thrift RPC system"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "thrist" = callPackage @@ -246722,6 +258921,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "Loop over an action but throttle it to a certain rate"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "through-text" = callPackage @@ -246787,6 +258988,8 @@ self: { ]; description = "Generate thumbnails easily and safely"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "thumbnail-polish" = callPackage @@ -246803,6 +259006,7 @@ self: { ]; description = "Image thumbnail creation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "thyme" = callPackage @@ -246903,6 +259107,7 @@ self: { executableHaskellDepends = [ base glade gtk haskell98 ]; description = "Useful if reading \"Why FP matters\" by John Hughes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ticker" = callPackage @@ -246939,6 +259144,7 @@ self: { ]; description = "A port of @Data.Binary@"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tictactoe3d" = callPackage @@ -246950,6 +259156,8 @@ self: { libraryHaskellDepends = [ base tuples-homogenous-h98 vector ]; description = "3D Tic-Tac-Toe game"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tidal" = callPackage @@ -246989,6 +259197,8 @@ self: { ]; description = "MIDI support for tidal"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tidal-serial" = callPackage @@ -247002,6 +259212,7 @@ self: { ]; description = "Serial support for tidal"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "tidal-vis" = callPackage @@ -247022,6 +259233,8 @@ self: { executableHaskellDepends = [ base ]; description = "Visual rendering for Tidal patterns and osc messages"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tie-knot" = callPackage @@ -247033,6 +259246,8 @@ self: { libraryHaskellDepends = [ base containers mtl recursion-schemes ]; description = "\"Ties the knot\" on a given set of structures that reference each other by keys"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tiempo" = callPackage @@ -247044,6 +259259,8 @@ self: { libraryHaskellDepends = [ base deepseq time ]; description = "Specify time intervals in different units (secs, mins, hours, etc.)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tiger" = callPackage @@ -247060,6 +259277,8 @@ self: { ]; description = "Tiger Compiler of Universiteit Utrecht"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tight-apply" = callPackage @@ -247087,6 +259306,8 @@ self: { ]; description = "Nice API for a Slackbot"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tighttp" = callPackage @@ -247105,6 +259326,7 @@ self: { ]; description = "Tiny and Incrementally-Growing HTTP library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tikzsd" = callPackage @@ -247167,6 +259389,7 @@ self: { executableToolDepends = [ happy ]; description = "The Timber Compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "time_1_11_1_2" = callPackage @@ -247230,6 +259453,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "Data instances for the time package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-exts" = callPackage @@ -247251,6 +259476,7 @@ self: { ]; description = "Yet another time library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "time-http" = callPackage @@ -247274,6 +259500,7 @@ self: { ]; description = "Parse and format HTTP/1.1 Date and Time strings"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "time-interval" = callPackage @@ -247296,6 +259523,7 @@ self: { libraryHaskellDepends = [ base base-io-access time ]; description = "IO Access for time"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "time-lens" = callPackage @@ -247341,6 +259569,8 @@ self: { testHaskellDepends = [ base hspec HUnit mtl time tz ]; description = "A library to mock the current time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-manager" = callPackage @@ -247415,6 +259645,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Quasi-quoter for UTCTime times"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-quote" = callPackage @@ -247431,6 +259663,8 @@ self: { ]; description = "Quasi-quoters for dates and times"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-recurrence" = callPackage @@ -247448,6 +259682,8 @@ self: { ]; description = "Generate recurring dates"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-series" = callPackage @@ -247462,6 +259698,8 @@ self: { executableHaskellDepends = [ base ]; description = "Time series analysis"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-series-lib" = callPackage @@ -247475,6 +259713,8 @@ self: { doHaddock = false; description = "Library for Time Series processing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-units" = callPackage @@ -247499,6 +259739,8 @@ self: { libraryHaskellDepends = [ base convertible parsec time ]; description = "Parse, format and convert W3C Date and Time"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "time-warp" = callPackage @@ -247536,6 +259778,7 @@ self: { ]; description = "Distributed systems execution emulation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "timecalc" = callPackage @@ -247548,6 +259791,8 @@ self: { isExecutable = true; executableHaskellDepends = [ base haskeline uu-parsinglib ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timeconsole" = callPackage @@ -247670,6 +259915,8 @@ self: { time unordered-containers ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timeout" = callPackage @@ -247686,6 +259933,8 @@ self: { ]; description = "Generalized sleep and timeout functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timeout-control" = callPackage @@ -247712,6 +259961,8 @@ self: { libraryHaskellDepends = [ base deepseq mtl parallel ]; description = "Runs a time-limited computation alowing it to return intermediate results"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timeparsers" = callPackage @@ -247727,6 +259978,8 @@ self: { ]; description = "Attoparsec parsers for various Date/Time formats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timeplot" = callPackage @@ -247758,6 +260011,7 @@ self: { libraryHaskellDepends = [ base datetime ]; description = "Prints timestamps after each line evaluated"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "timer-wheel" = callPackage @@ -247847,6 +260101,8 @@ self: { ]; description = "Library for Time Series processing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timespan" = callPackage @@ -247918,6 +260174,8 @@ self: { testHaskellDepends = [ base hspec microlens time ]; description = "Time utilities"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timezone-detect" = callPackage @@ -247937,6 +260195,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell bindings for the zone-detect C library; plus tz-aware utils"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timezone-olson" = callPackage @@ -247967,6 +260227,8 @@ self: { ]; description = "Load TimeZoneSeries from an Olson file at compile time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "timezone-series" = callPackage @@ -247998,6 +260260,7 @@ self: { timezone-series ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "timing-convenience" = callPackage @@ -248021,6 +260284,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Tiny INI file and configuration library with a minimal dependency footprint"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tintin" = callPackage @@ -248046,6 +260311,8 @@ self: { testHaskellDepends = [ base require ]; description = "A softer alternative to Haddock"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tiny-scheduler" = callPackage @@ -248057,6 +260324,8 @@ self: { libraryHaskellDepends = [ async base time ]; description = "tiny no-brainer job scheduler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tinyMesh" = callPackage @@ -248072,6 +260341,7 @@ self: { ]; description = "TinyMesh - communicating with auto-meshing sensor network"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "tinyXml" = callPackage @@ -248096,6 +260366,8 @@ self: { ]; description = "A fast DOM parser for a subset of XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tinyfiledialogs" = callPackage @@ -248137,6 +260409,8 @@ self: { testHaskellDepends = [ base QuickCheck text ]; description = "A tiny text templating library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tip-haskell-frontend" = callPackage @@ -248161,6 +260435,7 @@ self: { ]; description = "Convert from Haskell to Tip"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tip-lib" = callPackage @@ -248184,6 +260459,7 @@ self: { ]; description = "tons of inductive problems - support library and tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tiphys" = callPackage @@ -248228,6 +260504,7 @@ self: { ]; description = "Testing Infrastructure for Temporal AbstractioNs - GUI to debug temporal programs"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "titan-debug-yampa" = callPackage @@ -248245,6 +260522,8 @@ self: { ]; description = "Testing Infrastructure for Temporal AbstractioNs - Interactive Yampa debugging layer"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "titan-record-yampa" = callPackage @@ -248256,6 +260535,8 @@ self: { libraryHaskellDepends = [ base Yampa ]; description = "Testing Infrastructure for Temporal AbstractioNs - Yampa record-and-replay layer"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "titlecase" = callPackage @@ -248290,6 +260571,8 @@ self: { testHaskellDepends = [ HUnit test-framework test-framework-hunit ]; description = "Simple Presentation Utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tkyprof" = callPackage @@ -248316,6 +260599,8 @@ self: { ]; description = "A web-based visualizer for GHC Profiling Reports"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tld" = callPackage @@ -248524,6 +260809,7 @@ self: { ]; description = "TLS extra default values and helpers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tls-session-manager" = callPackage @@ -248631,6 +260917,8 @@ self: { ]; description = "Start and stop a temporary postgres"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tmpl" = callPackage @@ -248668,6 +260956,7 @@ self: { ]; description = "A simple daily journal program"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "tnet" = callPackage @@ -248713,6 +261002,8 @@ self: { ]; description = "A type class and some utilities for generating Haskell code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "to-string-class" = callPackage @@ -248726,6 +261017,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Converting string-like types to Strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "to-string-instances" = callPackage @@ -248737,6 +261030,7 @@ self: { libraryHaskellDepends = [ bytestring pretty text to-string-class ]; description = "Instances for the ToString class"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "toboggan" = callPackage @@ -248755,6 +261049,7 @@ self: { executableHaskellDepends = [ base ]; description = "Twitter bot generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "todo" = callPackage @@ -248766,6 +261061,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A todo bottom"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "todos" = callPackage @@ -248791,6 +261088,7 @@ self: { ]; description = "Easy-to-use TODOs manager"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tofromxml" = callPackage @@ -248809,6 +261107,8 @@ self: { ]; description = "Reading and writing Haskell data from and to XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "toilet" = callPackage @@ -248826,6 +261126,8 @@ self: { ]; description = "Manage the toilet queue at the IMO"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "token-bucket" = callPackage @@ -248861,6 +261163,8 @@ self: { ]; description = "Fast rate limiting using the token bucket algorithm (BSD)"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "token-search" = callPackage @@ -248886,6 +261190,8 @@ self: { text unordered-containers ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tokenify" = callPackage @@ -248897,6 +261203,8 @@ self: { libraryHaskellDepends = [ base containers text ]; description = "A regex lexer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tokenize" = callPackage @@ -248940,6 +261248,8 @@ self: { ]; description = "A variant of tokenizer-monad that supports streaming"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tokstyle" = callPackage @@ -248964,6 +261274,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "TokTok C code style checker"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "toktok" = callPackage @@ -248978,6 +261290,7 @@ self: { libraryHaskellDepends = [ base containers haskell98 ]; executableHaskellDepends = [ base bytestring gf iconv ]; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "tokyocabinet-haskell" = callPackage @@ -248996,6 +261309,8 @@ self: { testSystemDepends = [ tokyocabinet ]; description = "Haskell binding of Tokyo Cabinet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) tokyocabinet;}; "tokyotyrant-haskell" = callPackage @@ -249012,6 +261327,8 @@ self: { platforms = [ "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" ]; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) tokyocabinet; inherit (pkgs) tokyotyrant;}; "tomato-rubato-openal" = callPackage @@ -249023,6 +261340,8 @@ self: { libraryHaskellDepends = [ base OpenAL stm vector ]; description = "Easy to use library for audio programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "toml" = callPackage @@ -249039,6 +261358,8 @@ self: { attoparsec base bytestring containers old-locale time ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "toml-parser" = callPackage @@ -249224,6 +261545,8 @@ self: { ]; description = "tonatona plugin for accessing PostgreSQL database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tonatona-persistent-sqlite" = callPackage @@ -249244,6 +261567,8 @@ self: { ]; description = "tonatona plugin for accessing Sqlite database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tonatona-servant" = callPackage @@ -249267,6 +261592,8 @@ self: { ]; description = "tonatona plugin for servant"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "too-many-cells" = callPackage @@ -249310,6 +261637,7 @@ self: { executableHaskellDepends = [ base optparse-generic ]; description = "Cluster single cells and analyze cell clade relationships"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "toodles" = callPackage @@ -249345,6 +261673,8 @@ self: { ]; description = "Manage the TODO entries in your code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "toolshed" = callPackage @@ -249386,6 +261716,7 @@ self: { ]; description = "Top (typed oriented protocol) API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "topkata" = callPackage @@ -249404,6 +261735,7 @@ self: { ]; description = "OpenGL Arcade Game"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "topograph" = callPackage @@ -249432,6 +261764,8 @@ self: { libraryHaskellDepends = [ base mtl parallel QuickCheck ]; description = "Simple unit test library (or framework)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "torrent" = callPackage @@ -249502,6 +261836,7 @@ self: { libraryHaskellDepends = [ base containers semiring-num ]; description = "Finitely represented total maps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "total-maps" = callPackage @@ -249532,6 +261867,8 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "Library (and cli) to execute a procedure on file change"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tower" = callPackage @@ -249578,6 +261915,7 @@ self: { ]; description = "A Tox protocol implementation in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "toxcore-c" = callPackage @@ -249603,6 +261941,7 @@ self: { ]; description = "Haskell bindings to the C reference implementation of Tox"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {toxcore = null;}; "toxiproxy-haskell" = callPackage @@ -249622,6 +261961,8 @@ self: { ]; description = "Client library for Toxiproxy: a TCP failure testing proxy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "toysolver" = callPackage @@ -249677,6 +262018,7 @@ self: { ]; description = "Assorted decision procedures for SAT, SMT, Max-SAT, PB, MIP, etc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tpar" = callPackage @@ -249713,6 +262055,7 @@ self: { ]; description = "simple, parallel job scheduling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tpb" = callPackage @@ -249738,6 +262081,7 @@ self: { ]; description = "Applications for interacting with the Pushbullet API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "tpdb" = callPackage @@ -249779,6 +262123,8 @@ self: { ]; description = "Parser and pretty printer for the TPTP language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trace" = callPackage @@ -249795,6 +262141,8 @@ self: { ]; description = "A monad transformer for tracing provenience of errors"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trace-call" = callPackage @@ -249806,6 +262154,8 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "functions for logging the arguments and results of function calls"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trace-function-call" = callPackage @@ -249817,6 +262167,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Easy lightweight tracing of function arguments and results for ad hoc debugging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "traced" = callPackage @@ -249828,6 +262180,8 @@ self: { libraryHaskellDepends = [ base containers mtl pretty ]; description = "Simple evaluation trace"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tracer" = callPackage @@ -249857,6 +262211,8 @@ self: { ]; description = "Visualize Haskell data structures as edge-labeled trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tracing" = callPackage @@ -249900,6 +262256,8 @@ self: { ]; description = "Distributed tracing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tracked-files" = callPackage @@ -249915,6 +262273,8 @@ self: { testHaskellDepends = [ base directory hspec process ]; description = "Package to list all tracked and untracked existing files via Git"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tracker" = callPackage @@ -249926,6 +262286,8 @@ self: { libraryHaskellDepends = [ base containers glib ]; description = "Client library for Tracker metadata database, indexer and search tool"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trackit" = callPackage @@ -249946,6 +262308,8 @@ self: { ]; description = "A command-line tool for live monitoring"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "traction" = callPackage @@ -249967,6 +262331,8 @@ self: { ]; description = "Tools for postgresql-simple"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tracy" = callPackage @@ -249978,6 +262344,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Convenience wrappers for non-intrusive debug tracing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trade-journal" = callPackage @@ -250033,6 +262401,8 @@ self: { ]; description = "TrailDB bindings for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {Judy = null; traildb = null;}; "trajectory" = callPackage @@ -250055,6 +262425,7 @@ self: { ]; description = "Tools and a library for working with Trajectory"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trans-fx-core" = callPackage @@ -250118,6 +262489,8 @@ self: { libraryHaskellDepends = [ base ListZipper MonadPrompt stm ]; description = "Transactional events, based on Concurrent ML semantics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "transf" = callPackage @@ -250136,6 +262509,7 @@ self: { ]; description = "Text transformer and interpreter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "transfer-db" = callPackage @@ -250164,6 +262538,7 @@ self: { ]; description = "ODBC database transfer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "transformations" = callPackage @@ -250184,6 +262559,7 @@ self: { ]; description = "Generic representation of tree transformations"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "transformers_0_5_6_2" = callPackage @@ -250262,6 +262638,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "Arrow-like / category-like composition for transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "transformers-continue" = callPackage @@ -250291,6 +262669,7 @@ self: { ]; description = "Sensible conversions between some of the monad transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "transformers-eff" = callPackage @@ -250372,6 +262751,8 @@ self: { ]; description = "Ad-hoc type classes for lifting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "transformers-runnable" = callPackage @@ -250383,6 +262764,8 @@ self: { libraryHaskellDepends = [ base transformers ]; description = "A unified interface for the run operation of monad transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "transformers-supply" = callPackage @@ -250449,6 +262832,8 @@ self: { ]; description = "fully composable remote execution for the creation of distributed systems"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "transient-universe-tls" = callPackage @@ -250465,6 +262850,7 @@ self: { ]; description = "transient with secure communications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "translatable-intset" = callPackage @@ -250478,6 +262864,8 @@ self: { libraryHaskellDepends = [ base fingertree ]; description = "Integer sets with a constant time translate operation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "translate" = callPackage @@ -250490,6 +262878,8 @@ self: { libraryHaskellDepends = [ base curl json network utf8-string ]; description = "Haskell binding to Google's AJAX Language API for Translation and Detection"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "translate-cli" = callPackage @@ -250507,6 +262897,8 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Translation cli tool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trasa" = callPackage @@ -250525,6 +262917,7 @@ self: { testHaskellDepends = [ base doctest ]; description = "Type Safe Web Routing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "trasa-client" = callPackage @@ -250541,6 +262934,7 @@ self: { ]; description = "Type safe http requests"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "trasa-extra" = callPackage @@ -250558,6 +262952,7 @@ self: { ]; description = "Extra functions for trasa"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trasa-form" = callPackage @@ -250576,6 +262971,7 @@ self: { ]; description = "generate forms using lucid, ditto and trasa"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trasa-reflex" = callPackage @@ -250609,6 +263005,7 @@ self: { ]; description = "Type safe web server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "trasa-th" = callPackage @@ -250625,6 +263022,7 @@ self: { testHaskellDepends = [ base trasa ]; description = "Template Haskell to generate trasa routes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "traversal-template" = callPackage @@ -250640,6 +263038,8 @@ self: { benchmarkHaskellDepends = [ base gauge template-haskell util ]; description = "See README for more info"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "traverse-with-class" = callPackage @@ -250671,6 +263071,8 @@ self: { ]; description = "A simple client implementation using Travis CI API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "travis-meta-yaml" = callPackage @@ -250700,6 +263102,8 @@ self: { ]; description = ".travis.yml preprocessor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "travis-pogodi" = callPackage @@ -250732,6 +263136,8 @@ self: { ]; description = "A tool for finding haddocks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "traypoweroff" = callPackage @@ -250746,6 +263152,8 @@ self: { executableHaskellDepends = [ base gtk process ]; description = "Tray Icon application to PowerOff / Reboot computer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "treap" = callPackage @@ -250760,6 +263168,8 @@ self: { testHaskellDepends = [ base doctest Glob hspec hspec-core ]; description = "Efficient implementation of the implicit treap data structure"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tree-diff" = callPackage @@ -250820,6 +263230,8 @@ self: { libraryHaskellDepends = [ base boxes containers mtl ]; description = "Configurable text rendering of trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tree-sitter" = callPackage @@ -250982,6 +263394,8 @@ self: { testHaskellDepends = [ base containers doctest mtl ]; description = "Functions and newtype wrappers for traversing Trees"; license = lib.licenses.cc0; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tree-view" = callPackage @@ -251028,6 +263442,8 @@ self: { ]; description = "A tree of Data.Map."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "treemap-html" = callPackage @@ -251043,6 +263459,8 @@ self: { ]; description = "Generates HTML for Data.Tree as TreeMap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "treemap-html-tools" = callPackage @@ -251062,6 +263480,7 @@ self: { doHaddock = false; description = "Treemap related commands for producing foldable TreeMap HTML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "treersec" = callPackage @@ -251142,6 +263561,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "A PostgreSQL Database Migrator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trek-db" = callPackage @@ -251165,6 +263585,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "A PostgreSQL Database Migrator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trek-lens" = callPackage @@ -251191,6 +263612,8 @@ self: { ]; description = "Library for polling Tremulous servers"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trhsx" = callPackage @@ -251201,6 +263624,8 @@ self: { sha256 = "11jx2jf6vi7368ys39mz0ziy6xknbi0z87926n2y16am6k2h25k3"; description = "Deprecated"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trial" = callPackage @@ -251254,6 +263679,7 @@ self: { ]; description = "triangulation of polygons"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trie-simple" = callPackage @@ -251302,6 +263728,7 @@ self: { ]; description = "Various trie implementations in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trifecta" = callPackage @@ -251347,6 +263774,8 @@ self: { testHaskellDepends = [ base hspec protolude ]; description = "Trigger is a cross platform file system watcher for super fast build-and-restart workflows"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trim" = callPackage @@ -251362,6 +263791,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "A command-line tool for trimming whitespace"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trimpolya" = callPackage @@ -251375,6 +263806,7 @@ self: { executableHaskellDepends = [ base bio bytestring simpleargs ]; description = "Search for, annotate and trim poly-A tail"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "tripLL" = callPackage @@ -251390,6 +263822,8 @@ self: { ]; description = "A very simple triple store"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "triplesec" = callPackage @@ -251420,6 +263854,8 @@ self: { libraryHaskellDepends = [ base comonad distributive ]; description = "The trivial monad and comonad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "trivial-constraint" = callPackage @@ -251442,6 +263878,8 @@ self: { libraryHaskellDepends = [ base semiring-simple ]; description = "A library for tropical mathematics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tropical-geometry" = callPackage @@ -251466,6 +263904,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "A Tropical Geometry package for Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "true-name" = callPackage @@ -251480,6 +263920,8 @@ self: { testHaskellDepends = [ base containers template-haskell time ]; description = "Template Haskell hack to violate module abstractions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "truelevel" = callPackage @@ -251493,6 +263935,7 @@ self: { executableHaskellDepends = [ base containers parseargs WAVE ]; description = "Audio file compressor-limiter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "trurl" = callPackage @@ -251515,6 +263958,7 @@ self: { testHaskellDepends = [ base hastache tasty tasty-hunit ]; description = "Haskell template code generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "truthful" = callPackage @@ -251539,6 +263983,8 @@ self: { libraryHaskellDepends = [ base containers mtl time transformers ]; description = "A Transaction Framework for Web Applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tsession-happstack" = callPackage @@ -251552,6 +263998,7 @@ self: { ]; description = "A Transaction Framework for Happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tsetchan" = callPackage @@ -251642,6 +264089,8 @@ self: { executableHaskellDepends = [ base gloss stm vector ]; description = "Real time TSP tour visualization"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tsparse" = callPackage @@ -251659,6 +264108,8 @@ self: { ]; description = "Parses U.S. federal Thrift Savings Plan PDF quarterly statements"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tst" = callPackage @@ -251690,6 +264141,8 @@ self: { ]; description = "Interacts with tesseract to ease reading of RAW Japanese manga"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tsv2csv" = callPackage @@ -251722,6 +264175,8 @@ self: { ]; description = "Template tsv into SQL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tsweb" = callPackage @@ -251750,6 +264205,7 @@ self: { ]; description = "An API binding Web.Spock to Database.Beam"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ttask" = callPackage @@ -251772,6 +264228,8 @@ self: { testHaskellDepends = [ base ]; description = "This is task management tool for yourself, that inspired by scrum"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ttc" = callPackage @@ -251902,6 +264360,8 @@ self: { ]; description = "Working with files for the Tiptoi® pen"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tubes" = callPackage @@ -251918,6 +264378,8 @@ self: { ]; description = "Write stream processing computations with side effects in a series of tubes"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tuntap" = callPackage @@ -251929,6 +264391,8 @@ self: { libraryHaskellDepends = [ base bytestring unix ]; description = "Interface to TUN/TAP drivers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tuntap-simple" = callPackage @@ -251942,6 +264406,7 @@ self: { libraryHaskellDepends = [ base ioctl ]; description = "A simple tun/tap library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tup-functor" = callPackage @@ -251956,6 +264421,7 @@ self: { executableHaskellDepends = [ base haskell-src-exts parsec2 ]; description = "Homogeneous tuples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tuple" = callPackage @@ -251978,6 +264444,8 @@ self: { libraryHaskellDepends = [ base combinat ]; description = "Enum instances for tuples where the digits increase with the same speed"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tuple-generic" = callPackage @@ -252012,6 +264480,8 @@ self: { libraryHaskellDepends = [ base lens template-haskell ]; description = "Stock FieldN combos and generators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tuple-morph" = callPackage @@ -252025,6 +264495,7 @@ self: { libraryHaskellDepends = [ base HList template-haskell ]; description = "Morph between tuples, or convert them from and to HLists"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "tuple-ops" = callPackage @@ -252036,6 +264507,7 @@ self: { libraryHaskellDepends = [ base type-combinators ]; description = "various operations on n-ary tuples via GHC.Generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tuple-sop" = callPackage @@ -252070,6 +264542,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Functor, Applicative and Monad for n-ary tuples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tuples" = callPackage @@ -252120,6 +264594,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A simple simulator for Turing machines"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "turing-music" = callPackage @@ -252133,6 +264609,8 @@ self: { executableHaskellDepends = [ ALUT base ]; description = "Plays music generated by Turing machines with 5 states and 2 symbols"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "turingMachine" = callPackage @@ -252149,6 +264627,7 @@ self: { ]; description = "An implementation of Turing Machine and Automaton"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "turkish-deasciifier" = callPackage @@ -252227,6 +264706,8 @@ self: { testHaskellDepends = [ base HUnit parsec ]; description = "Collection of command line options and parsers for these options"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tw" = callPackage @@ -252251,6 +264732,8 @@ self: { libraryHaskellDepends = [ base containers lens stm transformers ]; description = "A library for incremental computing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twee" = callPackage @@ -252339,6 +264822,7 @@ self: { ]; description = "Used as Lab Assignments Environment at the University of Twente"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "twentefp-eventloop-trees" = callPackage @@ -252350,6 +264834,7 @@ self: { libraryHaskellDepends = [ base eventloop ]; description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and RedBlackTree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "twentefp-graphs" = callPackage @@ -252361,6 +264846,7 @@ self: { libraryHaskellDepends = [ base twentefp-eventloop-graphics ]; description = "Lab Assignments Environment at Univeriteit Twente"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "twentefp-number" = callPackage @@ -252386,6 +264872,7 @@ self: { ]; description = "RoseTree type and show functions for lab assignment of University of Twente"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "twentefp-trees" = callPackage @@ -252397,6 +264884,7 @@ self: { libraryHaskellDepends = [ base twentefp-eventloop-graphics ]; description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and ParseTree"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "twentefp-websockets" = callPackage @@ -252415,6 +264903,8 @@ self: { ]; description = "A fork of the popular websockets package. It is used for the practical assignments of the University of Twente. A sensible and clean way to write WebSocket-capable servers in Haskell."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twentyseven" = callPackage @@ -252444,6 +264934,7 @@ self: { ]; description = "Rubik's cube solver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "twfy-api-client" = callPackage @@ -252469,6 +264960,8 @@ self: { testHaskellDepends = [ base ]; description = "They Work For You API Client Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twhs" = callPackage @@ -252499,6 +264992,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "CLI twitter client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twidge" = callPackage @@ -252519,6 +265014,7 @@ self: { ]; description = "Unix Command-Line Twitter and Identica Client"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "twilight-stm" = callPackage @@ -252530,6 +265026,7 @@ self: { libraryHaskellDepends = [ base containers haskell98 mtl ]; description = "STM library with safe irrevocable I/O and inconsistency repair"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "twilio" = callPackage @@ -252556,6 +265053,8 @@ self: { doCheck = false; description = "Twilio REST API library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twill" = callPackage @@ -252574,6 +265073,7 @@ self: { ]; description = "Twilio API interaction"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "twiml" = callPackage @@ -252606,6 +265106,8 @@ self: { ]; description = "very simple template language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twirp" = callPackage @@ -252627,6 +265129,8 @@ self: { ]; description = "Haskell twirp foundations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twisty" = callPackage @@ -252680,6 +265184,7 @@ self: { ]; description = "A Haskell-based CLI Twitter client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "twitter-conduit" = callPackage @@ -252728,6 +265233,7 @@ self: { ]; description = "Twitter API package with enumerator interface and Streaming API support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "twitter-feed" = callPackage @@ -252749,6 +265255,8 @@ self: { ]; description = "Client for fetching Twitter timeline via Oauth"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twitter-types" = callPackage @@ -252800,6 +265308,8 @@ self: { ]; description = "Persistent transactions on top of STM"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "txt" = callPackage @@ -252859,6 +265369,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Deprecated in favor of eros"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ty" = callPackage @@ -252883,6 +265395,8 @@ self: { libraryHaskellDepends = [ base containers template-haskell ]; description = "Provide proof witnesses for closed type family evaluation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typalyze" = callPackage @@ -252901,6 +265415,8 @@ self: { ]; description = "Analyzes Haskell source files for easy reference"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-aligned" = callPackage @@ -252925,6 +265441,7 @@ self: { testHaskellDepends = [ base hspec test-fixture ]; description = "Runtime type assertions for testing"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "type-booleans" = callPackage @@ -252951,6 +265468,7 @@ self: { ]; description = "Utilities for caching type families results. Sometimes complex type families take long time to compile, so it is proficient to cache them and use the final result without the need of re-computation."; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "type-cereal" = callPackage @@ -252967,6 +265485,7 @@ self: { ]; description = "Type-level serialization of type constructors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-combinators" = callPackage @@ -252980,6 +265499,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A collection of data types for type-level programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-combinators-quote" = callPackage @@ -252995,6 +265516,7 @@ self: { ]; description = "Quasiquoters for the 'type-combinators' package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-combinators-singletons" = callPackage @@ -253006,6 +265528,7 @@ self: { libraryHaskellDepends = [ base singletons type-combinators ]; description = "Interop between /type-combinators/ and /singletons/"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-digits" = callPackage @@ -253017,6 +265540,7 @@ self: { libraryHaskellDepends = [ base template-haskell type-spine ]; description = "Arbitrary-base type-level digits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-eq" = callPackage @@ -253031,6 +265555,8 @@ self: { libraryToolDepends = [ cpphs ]; description = "Type equality evidence you can carry around"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-equality" = callPackage @@ -253102,6 +265628,8 @@ self: { testHaskellDepends = [ base ]; description = "Collection of widely reimplemented type families"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-functions" = callPackage @@ -253146,6 +265674,8 @@ self: { ]; description = "Queues with verified and unverified versions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-int" = callPackage @@ -253157,6 +265687,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Type Level 2s- and 16s- Complement Integers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-interpreter" = callPackage @@ -253169,6 +265701,8 @@ self: { testHaskellDepends = [ base template-haskell ]; description = "Interpreter for Template Haskell types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-iso" = callPackage @@ -253207,6 +265741,8 @@ self: { libraryHaskellDepends = [ base ]; description = "type-level binary search trees in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-level-integers" = callPackage @@ -253255,6 +265791,8 @@ self: { ]; description = "High-level combinators for performing inductive operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-level-natural-number-operations" = callPackage @@ -253266,6 +265804,8 @@ self: { libraryHaskellDepends = [ base type-level-natural-number ]; description = "Basic operations on type-level natural numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-level-numbers" = callPackage @@ -253313,6 +265853,8 @@ self: { libraryHaskellDepends = [ base singletons ]; description = "Operations on type-level lists and tuples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-map" = callPackage @@ -253388,6 +265930,8 @@ self: { testHaskellDepends = [ base type-of-html ]; description = "Optimize static parts of type-of-html"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-operators" = callPackage @@ -253412,6 +265956,7 @@ self: { ]; description = "Type-level comparison operator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-ord-spine-cereal" = callPackage @@ -253427,6 +265972,7 @@ self: { ]; description = "Generic type-level comparison of types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-prelude" = callPackage @@ -253438,6 +265984,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Partial port of prelude to the type level. Requires GHC 7.6.1."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-sets" = callPackage @@ -253450,6 +265998,7 @@ self: { testHaskellDepends = [ base cmptype ]; description = "Type-level sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-settheory" = callPackage @@ -253465,6 +266014,8 @@ self: { ]; description = "Sets and functions-as-relations in the type system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-spec" = callPackage @@ -253488,6 +266039,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "A spine-view on types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-structure" = callPackage @@ -253514,6 +266067,7 @@ self: { ]; description = "Type structure analysis"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "type-sub-th" = callPackage @@ -253538,6 +266092,7 @@ self: { ]; description = "Substitute types for other types with Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "type-tree" = callPackage @@ -253555,6 +266110,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "Tree representations of datatypes"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-unary" = callPackage @@ -253574,6 +266131,8 @@ self: { ]; description = "Type-level and typed unary natural numbers, inequality proofs, vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typeable-th" = callPackage @@ -253586,6 +266145,8 @@ self: { testHaskellDepends = [ base ]; description = "Automatic deriving of TypeableN instances with Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typecheck-plugin-nat-simple" = callPackage @@ -253678,6 +266239,8 @@ self: { ]; description = "Type safe string transformations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typed-encoding-encoding" = callPackage @@ -253697,6 +266260,7 @@ self: { ]; description = "Bridge between encoding and typed-encoding packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "typed-process" = callPackage @@ -253735,6 +266299,7 @@ self: { executableHaskellDepends = [ base diagrams-lib text ]; description = "Typed and composable spreadsheets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "typed-streams" = callPackage @@ -253756,6 +266321,7 @@ self: { ]; description = "A stream based replacement for lists"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "typed-uuid" = callPackage @@ -253814,6 +266380,8 @@ self: { ]; description = "Language-independent type-safe communication"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typed-wire-utils" = callPackage @@ -253843,6 +266411,8 @@ self: { ]; description = "Typed frontend to TensorFlow and higher-order deep learning"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typedquery" = callPackage @@ -253859,6 +266429,8 @@ self: { ]; description = "Parser for SQL augmented with types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typehash" = callPackage @@ -253870,6 +266442,8 @@ self: { libraryHaskellDepends = [ base binary bytestring mtl pureMD5 syb ]; description = "Create a unique hash value for a type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typelevel" = callPackage @@ -253886,6 +266460,7 @@ self: { ]; description = "Useful type level operations (type families and related operators)"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "typelevel-rewrite-rules" = callPackage @@ -253902,6 +266477,7 @@ self: { testHaskellDepends = [ base ghc-prim vinyl ]; description = "Solve type equalities using custom type-level rewrite rules"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "typelevel-tensor" = callPackage @@ -253919,6 +266495,8 @@ self: { ]; description = "Tensors whose ranks and dimensions type-inferred and type-checked"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typelits-printf" = callPackage @@ -253983,6 +266561,8 @@ self: { ]; description = "Lens-like interface for type level parameters; allows unboxed unboxed vectors and supercompilation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typerep-map" = callPackage @@ -254020,6 +266600,8 @@ self: { libraryHaskellDepends = [ base ]; description = "ghc-7.6/7.8 compatible GHC.TypeLits, Data.Typeable and Data.Proxy."; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typesafe-endian" = callPackage @@ -254050,6 +266632,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Type-safe transformations and purifications of PreCures (Japanese Battle Heroine)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typescript-docs" = callPackage @@ -254069,6 +266653,7 @@ self: { ]; description = "A documentation generator for TypeScript Definition files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "typical" = callPackage @@ -254106,6 +266691,8 @@ self: { ]; description = "Just let me draw nice text already"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "typography-geometry" = callPackage @@ -254143,6 +266730,7 @@ self: { ]; description = "Typson Beam Integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "typson-core" = callPackage @@ -254182,6 +266770,7 @@ self: { ]; description = "Typson Esqueleto Integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "typson-selda" = callPackage @@ -254204,6 +266793,7 @@ self: { ]; description = "Typson Selda Integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "tyro" = callPackage @@ -254224,6 +266814,8 @@ self: { ]; description = "Type derived JSON parsing using Aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tz" = callPackage @@ -254290,6 +266882,7 @@ self: { testHaskellDepends = [ base bytestring either-unwrap hspec text ]; description = "Haskell Universal Two Factor helper toolbox library thing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uAgda" = callPackage @@ -254367,6 +266960,7 @@ self: { testHaskellDepends = [ base hspec text ]; description = "Uber client for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uberlast" = callPackage @@ -254378,6 +266972,8 @@ self: { libraryHaskellDepends = [ base lens tagged template-haskell ]; description = "Generate overloaded lenses from plain data declaration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ucam-webauth" = callPackage @@ -254407,6 +267003,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "The Ucam-Webauth protocol, used by Raven"; license = "(BSD-3-Clause OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; }) {}; "ucam-webauth-types" = callPackage @@ -254428,6 +267025,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Types for the Ucam-Webauth protocol, as used by Raven"; license = "(BSD-3-Clause OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ucd" = callPackage @@ -254446,6 +267045,8 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "Unicode Character Database — Predicates on characters specified by Unicode"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ucl" = callPackage @@ -254474,6 +267075,8 @@ self: { librarySystemDepends = [ icu ]; description = "String encoding conversion with ICU"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) icu;}; "udbus" = callPackage @@ -254551,6 +267154,8 @@ self: { ]; description = "Simple fire-and-forget conduit UDP wrappers"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "udp-streaming" = callPackage @@ -254564,6 +267169,8 @@ self: { ]; description = "Streaming to and from UDP socket"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uglymemo" = callPackage @@ -254602,6 +267209,7 @@ self: { ]; description = "Part of UHC packaged as cabal/hackage installable library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uhc-util" = callPackage @@ -254621,6 +267229,7 @@ self: { ]; description = "UHC utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uhexdump" = callPackage @@ -254634,6 +267243,8 @@ self: { executableHaskellDepends = [ base bytestring split ]; description = "hex dumper for UTF-8 text"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uhttpc" = callPackage @@ -254658,6 +267269,8 @@ self: { ]; description = "Minimal HTTP client library optimized for benchmarking"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ui-command" = callPackage @@ -254671,6 +267284,8 @@ self: { libraryHaskellDepends = [ base data-default mtl old-locale time ]; description = "A framework for friendly commandline programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uid" = callPackage @@ -254766,6 +267381,7 @@ self: { ]; description = "A fast, cache-efficient, concurrent bloom filter"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "unagi-chan" = callPackage @@ -254820,6 +267436,8 @@ self: { libraryHaskellDepends = [ base containers mtl ]; description = "Functional concurrency with unamb using a custom scheduler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unbeliever" = callPackage @@ -254862,6 +267480,7 @@ self: { ]; description = "Generic support for programming with names and binders"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "unbound-generics" = callPackage @@ -254921,6 +267540,8 @@ self: { libraryHaskellDepends = [ base unbounded-delays units units-defs ]; description = "Thread delays and timeouts using proper time units"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unboxed" = callPackage @@ -254945,6 +267566,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Self-optimizing unboxed sets using view patterns and data families"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unboxed-ref" = callPackage @@ -254971,6 +267594,8 @@ self: { executableHaskellDepends = [ base vector ]; description = "A library for reference cells backed by unboxed-vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unboxing-vector" = callPackage @@ -255013,6 +267638,8 @@ self: { executableHaskellDepends = [ base bytestring cmdargs ]; description = "Secure and resilient remote file storage utility"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uncaught-exception" = callPackage @@ -255109,6 +267736,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Unfixing and recursion schemes for data types with binders"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unfoldable" = callPackage @@ -255162,6 +267791,7 @@ self: { libraryHaskellDepends = [ base containers uni-util ]; description = "Event handling for the uniform workbench"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "uni-graphs" = callPackage @@ -255177,6 +267807,7 @@ self: { ]; description = "Graphs"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "uni-htk" = callPackage @@ -255193,6 +267824,7 @@ self: { ]; description = "Graphical User Interface for Haskell Programs"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "uni-posixutil" = callPackage @@ -255208,6 +267840,7 @@ self: { ]; description = "Posix utilities for the uniform workbench"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "uni-reactor" = callPackage @@ -255222,6 +267855,7 @@ self: { ]; description = "Reactors for the uniform workbench"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "uni-uDrawGraph" = callPackage @@ -255238,6 +267872,7 @@ self: { ]; description = "Graphs binding"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "uni-util" = callPackage @@ -255254,6 +267889,8 @@ self: { ]; description = "Utilities for the uniform workbench"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unicode" = callPackage @@ -255338,6 +267975,7 @@ self: { librarySystemDepends = [ icu ]; description = "Unicode normalization using the ICU library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) icu;}; "unicode-prelude" = callPackage @@ -255349,6 +267987,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Unicode notation for some definitions in Prelude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unicode-properties" = callPackage @@ -255372,6 +268012,8 @@ self: { testHaskellDepends = [ base hspec QuickCheck ]; description = "print and show in unicode"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unicode-symbols" = callPackage @@ -255383,6 +268025,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Unicode alternatives for common functions and operators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unicode-transforms" = callPackage @@ -255422,6 +268066,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Functions to work with unicode blocks more convenient"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unicoder" = callPackage @@ -255514,6 +268160,8 @@ self: { ]; description = "Uniform file handling operations"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uniform-io" = callPackage @@ -255533,6 +268181,7 @@ self: { testHaskellDepends = [ attoparsec base bytestring Cabal ]; description = "Uniform IO over files, network, anything"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) openssl;}; "uniform-pair" = callPackage @@ -255598,6 +268247,7 @@ self: { ]; description = "A uniform base to build apps on"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "union" = callPackage @@ -255651,6 +268301,8 @@ self: { libraryHaskellDepends = [ base containers extensible ]; description = "Heterogeneous map by open unions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unipatterns" = callPackage @@ -255697,6 +268349,8 @@ self: { ]; description = "UniProt-KB format parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uniq-deep" = callPackage @@ -255770,6 +268424,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Splittable Unique Identifier Supply"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uniquely-represented-sets" = callPackage @@ -255786,6 +268442,8 @@ self: { ]; benchmarkHaskellDepends = [ base criterion random ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uniqueness-periods" = callPackage @@ -255861,6 +268519,7 @@ self: { ]; description = "Usage examples for the uniqueness-periods-vector series of packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "uniqueness-periods-vector-filters" = callPackage @@ -255906,6 +268565,8 @@ self: { ]; description = "Metrices for the maximum element for the uniqueness-periods-vector packages family"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uniqueness-periods-vector-stats" = callPackage @@ -255977,6 +268638,8 @@ self: { ]; description = "Attoparsec parsers for the units package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "units-defs" = callPackage @@ -256017,6 +268680,8 @@ self: { testHaskellDepends = [ base ]; description = "An extendable library for type-safe computations including units"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unity-testresult-parser" = callPackage @@ -256076,6 +268741,8 @@ self: { libraryHaskellDepends = [ base unitym yesod ]; description = "Implementation of the unity monad for the Yesod framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "universal" = callPackage @@ -256107,6 +268774,8 @@ self: { libraryHaskellDepends = [ base binary bytestring ]; description = "Parser for OS X Universal Binary format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "universe" = callPackage @@ -256240,6 +268909,7 @@ self: { ]; description = "Construct a Dec's ancestor list"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "universum" = callPackage @@ -256314,6 +268984,7 @@ self: { libraryHaskellDepends = [ base foreign-var ]; description = "Comprehensive bindings to fcntl(2)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "unix-handle" = callPackage @@ -256325,6 +268996,8 @@ self: { libraryHaskellDepends = [ base unix ]; description = "POSIX operations on Handles"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unix-io-extra" = callPackage @@ -256374,6 +269047,8 @@ self: { ]; description = "Run processes on Unix systems, with a conduit interface (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unix-pty-light" = callPackage @@ -256402,6 +269077,8 @@ self: { benchmarkHaskellDepends = [ base criterion dir-traverse ]; description = "Fast and flexible primitives for recursive file system IO on Posix systems"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unix-simple" = callPackage @@ -256414,6 +269091,7 @@ self: { testHaskellDepends = [ base bytestring zenhack-prelude ]; description = "Straightforward bindings to the posix API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "unix-time" = callPackage @@ -256508,6 +269186,8 @@ self: { libraryHaskellDepends = [ base ghc-prim semigroups ]; description = "GHC Haskell lists of non-thunks (things of kind TYPE 'UnliftedRep)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unliftio" = callPackage @@ -256604,6 +269284,8 @@ self: { ]; description = "Fast and robust message queues for concurrent processes"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unliftio-path" = callPackage @@ -256673,6 +269355,8 @@ self: { ]; description = "A Library for the manipulation of images"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unmed2" = callPackage @@ -256726,6 +269410,8 @@ self: { ]; description = "Rematch support for unordered containers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unordered-graphs" = callPackage @@ -256741,6 +269427,8 @@ self: { ]; description = "Graph library using unordered-containers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unordered-intmap" = callPackage @@ -256757,6 +269445,8 @@ self: { ]; description = "A specialization of `HashMap Int v`"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unpack-funcs" = callPackage @@ -256772,6 +269462,8 @@ self: { ]; description = "Monad transformers that mirror worker-wrapper transformations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unpacked-containers" = callPackage @@ -256801,6 +269493,8 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked either data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unpacked-maybe" = callPackage @@ -256813,6 +269507,8 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked maybe data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unpacked-maybe-numeric" = callPackage @@ -256827,6 +269523,7 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "maybes of numeric values with fewer indirections"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "unpacked-maybe-text" = callPackage @@ -256854,6 +269551,7 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked these data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "unpacked-validation" = callPackage @@ -256870,6 +269568,7 @@ self: { testHaskellDepends = [ base QuickCheck quickcheck-classes ]; description = "An unpacked validation data type"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "unparse-attoparsec" = callPackage @@ -256890,6 +269589,7 @@ self: { ]; description = "An attoparsec roundtrip"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "unroll-ghc-plugin" = callPackage @@ -256901,6 +269601,8 @@ self: { libraryHaskellDepends = [ base ghc ]; description = "Compiler plugin for loop unrolling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unsafe" = callPackage @@ -256937,6 +269639,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Flexible access control for unsafe operations and instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unsafeperformst" = callPackage @@ -256967,6 +269671,7 @@ self: { ]; description = "Solve Boggle-like word games"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "unsequential" = callPackage @@ -256985,6 +269690,8 @@ self: { ]; description = "An extension removing the sequentiality from monads"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unusable-pkg" = callPackage @@ -257026,6 +269733,8 @@ self: { testHaskellDepends = [ base containers hspec text ]; description = "A command line tool to identify unused code"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unwrapped-functors" = callPackage @@ -257055,6 +269764,8 @@ self: { testHaskellDepends = [ base hlint tasty tasty-hunit ]; description = "Units of measure as a GHC typechecker plugin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "up" = callPackage @@ -257072,6 +269783,7 @@ self: { ]; description = "Command-line tool to generate paths for moving upward in a file system"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "up-grade" = callPackage @@ -257165,6 +269877,8 @@ self: { ]; description = "Haskell client for Uploadcare"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uploadtest" = callPackage @@ -257187,6 +269901,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Binding to upskirt"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urbit-airlock" = callPackage @@ -257203,6 +269919,7 @@ self: { ]; description = "Talk to Urbit from Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "urbit-api" = callPackage @@ -257219,6 +269936,7 @@ self: { ]; description = "Talk to Urbit from Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "urbit-hob" = callPackage @@ -257234,6 +269952,7 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Hoon-style atom manipulation and printing functions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ureader" = callPackage @@ -257257,6 +269976,7 @@ self: { ]; description = "Minimalistic CLI RSS reader"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "urembed" = callPackage @@ -257277,6 +269997,7 @@ self: { ]; description = "Ur/Web static content generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uri" = callPackage @@ -257288,6 +270009,8 @@ self: { libraryHaskellDepends = [ base parsec safe utf8-string ]; description = "Library for working with URIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uri-bytestring" = callPackage @@ -257346,6 +270069,8 @@ self: { ]; description = "Read and write URIs (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uri-encode" = callPackage @@ -257383,6 +270108,8 @@ self: { ]; description = "A uri encoder to make your strings less readable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uri-enumerator" = callPackage @@ -257399,6 +270126,7 @@ self: { ]; description = "Read and write URIs (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uri-enumerator-file" = callPackage @@ -257417,6 +270145,7 @@ self: { ]; description = "uri-enumerator backend for the file scheme (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uri-parse" = callPackage @@ -257433,6 +270162,8 @@ self: { testHaskellDepends = [ base data-default hspec lens ]; description = "A simple library for parsing and generating URIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uri-template" = callPackage @@ -257447,6 +270178,8 @@ self: { executableHaskellDepends = [ base ]; description = "URI template library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uri-templater" = callPackage @@ -257470,6 +270203,8 @@ self: { ]; description = "Parsing & Quasiquoting for RFC 6570 URI Templates"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "url" = callPackage @@ -257504,6 +270239,7 @@ self: { ]; description = "Memory efficient url type and parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "url-decoders" = callPackage @@ -257526,6 +270262,8 @@ self: { benchmarkHaskellDepends = [ criterion http-types rerebase ]; description = "Decoders for URL-encoding (aka Percent-encoding)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "url-generic" = callPackage @@ -257539,6 +270277,8 @@ self: { libraryHaskellDepends = [ base mtl syb ]; description = "Parse/format generic key/value URLs from record data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urlcheck" = callPackage @@ -257556,6 +270296,8 @@ self: { ]; description = "Parallel link checker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urldecode" = callPackage @@ -257569,6 +270311,8 @@ self: { executableHaskellDepends = [ base network ]; description = "Decode percent-encoded strings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urldisp-happstack" = callPackage @@ -257580,6 +270324,8 @@ self: { libraryHaskellDepends = [ base bytestring happstack-server mtl ]; description = "Simple, declarative, expressive URL routing -- on happstack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urlencoded" = callPackage @@ -257595,6 +270341,8 @@ self: { testHaskellDepends = [ base network network-uri QuickCheck ]; description = "Generate or process x-www-urlencoded data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urlpath" = callPackage @@ -257614,6 +270362,7 @@ self: { ]; description = "Painfully simple URL deployment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "urn" = callPackage @@ -257626,6 +270375,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Universal Resource Names"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urn-random" = callPackage @@ -257642,6 +270393,8 @@ self: { ]; description = "A package for updatable discrete distributions"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "urxml" = callPackage @@ -257659,6 +270412,8 @@ self: { ]; description = "XML parser-printer supporting Ur/Web syntax extensions"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "usa-holidays" = callPackage @@ -257685,6 +270440,7 @@ self: { ]; description = "Communicate with USB devices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "usb-enumerator" = callPackage @@ -257701,6 +270457,7 @@ self: { ]; description = "Iteratee enumerators for the usb package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "usb-hid" = callPackage @@ -257714,6 +270471,7 @@ self: { libraryHaskellDepends = [ attoparsec base bytestring usb ]; description = "Parser and request Library for USB HIDs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "usb-id-database" = callPackage @@ -257733,6 +270491,7 @@ self: { ]; description = "A database of USB identifiers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "usb-iteratee" = callPackage @@ -257749,6 +270508,7 @@ self: { ]; description = "Iteratee enumerators for the usb package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "usb-safe" = callPackage @@ -257765,6 +270525,7 @@ self: { ]; description = "Type-safe communication with USB devices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "useragents" = callPackage @@ -257828,6 +270589,8 @@ self: { ]; description = "A mysql-haskell backend for the users library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "users-persistent" = callPackage @@ -257848,6 +270611,8 @@ self: { ]; description = "A persistent backend for the users package"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "users-postgresql-simple" = callPackage @@ -257909,6 +270674,8 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "UTF-8"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "utf8-conversions" = callPackage @@ -257963,6 +270730,8 @@ self: { libraryHaskellDepends = [ base utf8-string ]; description = "Variants of Prelude and System.IO with UTF8 text I/O operations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "utf8-string" = callPackage @@ -257992,6 +270761,8 @@ self: { benchmarkHaskellDepends = [ base criterion ]; description = "Constant-space UTF8 validator for ByteStrings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "util" = callPackage @@ -258018,6 +270789,7 @@ self: { libraryHaskellDepends = [ base basic control lifted-base-tf util ]; description = "Exceptional utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "util-logict" = callPackage @@ -258031,6 +270803,8 @@ self: { benchmarkHaskellDepends = [ base gauge logict ]; description = "See README for more info"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "util-plus" = callPackage @@ -258047,6 +270821,8 @@ self: { testHaskellDepends = [ base containers HTF QuickCheck ]; description = "A collection of commonly used utils"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "util-primitive" = callPackage @@ -258060,6 +270836,8 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "Primitive memory-related utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "util-primitive-control" = callPackage @@ -258076,6 +270854,7 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Utilities for stateful primitive types and types based on them"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "util-universe" = callPackage @@ -258094,6 +270873,8 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Utilities for universal types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "utility-ht" = callPackage @@ -258121,6 +270902,8 @@ self: { libraryHaskellDepends = [ ansi-terminal base ]; description = "Utilities for compiler construction: core functionality"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uu-cco-examples" = callPackage @@ -258134,6 +270917,7 @@ self: { executableHaskellDepends = [ base uu-cco uuagc uuagc-cabal ]; description = "Utilities for compiler construction: example programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uu-cco-hut-parsing" = callPackage @@ -258145,6 +270929,7 @@ self: { libraryHaskellDepends = [ base uu-cco uulib ]; description = "Utilities for compiler construction: Feedback wrapper around parser in uulib"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uu-cco-uu-parsinglib" = callPackage @@ -258156,6 +270941,7 @@ self: { libraryHaskellDepends = [ base ListLike uu-cco uu-parsinglib ]; description = "Utilities for compiler construction: Feedback wrapper around parser in uu-parsinglib"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uu-interleaved" = callPackage @@ -258253,6 +271039,8 @@ self: { ]; description = "Attribute Grammar System of Universiteit Utrecht"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uuagc-cabal" = callPackage @@ -258329,6 +271117,8 @@ self: { libraryHaskellDepends = [ aeson base text uuid ]; description = "Aeson types for UUID instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uuid-bytes" = callPackage @@ -258349,6 +271139,7 @@ self: { ]; description = "UUID parsing using byteverse packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "uuid-crypto" = callPackage @@ -258367,6 +271158,7 @@ self: { ]; description = "Reversable and secure encoding of object ids as uuids"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uuid-le" = callPackage @@ -258393,6 +271185,8 @@ self: { ]; description = "Orphan instances for the UUID datatype"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uuid-quasi" = callPackage @@ -258470,6 +271264,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Fast unboxed arrays with a flexible interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uvector-algorithms" = callPackage @@ -258481,6 +271277,7 @@ self: { libraryHaskellDepends = [ base uvector ]; description = "Efficient algorithms for uvector unboxed arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "uxadt" = callPackage @@ -258492,6 +271289,8 @@ self: { libraryHaskellDepends = [ base json MissingH mtl ]; description = "Cross-language extensible representation for algebraic data type instances"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "uzbl-with-source" = callPackage @@ -258519,6 +271318,7 @@ self: { ]; description = "interface to Video For Linux Two (V4L2)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "v4l2-examples" = callPackage @@ -258532,6 +271332,7 @@ self: { executableHaskellDepends = [ base GLUT v4l2 ]; description = "video for linux two examples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vabal" = callPackage @@ -258553,6 +271354,7 @@ self: { testHaskellDepends = [ base process ]; description = "the cabal companion"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "vabal-lib" = callPackage @@ -258570,6 +271372,8 @@ self: { testHaskellDepends = [ base Cabal containers ]; description = "Core algorithms and datatypes used by vabal"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vacuum" = callPackage @@ -258581,6 +271385,8 @@ self: { libraryHaskellDepends = [ array base containers ghc-prim ]; description = "Graph representation of the GHC heap"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vacuum-cairo" = callPackage @@ -258597,6 +271403,7 @@ self: { ]; description = "Visualize live Haskell data structures using vacuum, graphviz and cairo"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vacuum-graphviz" = callPackage @@ -258608,6 +271415,7 @@ self: { libraryHaskellDepends = [ base filepath graphviz vacuum ]; description = "A library for transforming vacuum graphs into GraphViz output"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "vacuum-opengl" = callPackage @@ -258627,6 +271435,7 @@ self: { ]; description = "Visualize live Haskell data structures using vacuum, graphviz and OpenGL"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "vacuum-ubigraph" = callPackage @@ -258638,6 +271447,7 @@ self: { libraryHaskellDepends = [ base containers hubigraph vacuum ]; description = "Visualize Haskell data structures using vacuum and Ubigraph"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vado" = callPackage @@ -258683,6 +271493,8 @@ self: { libraryHaskellDepends = [ base containers MonadRandom ]; description = "Valid operator/module characters"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "validate" = callPackage @@ -258742,6 +271554,8 @@ self: { testHaskellDepends = [ base ]; description = "Type-level constraints on strings and other input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "validation" = callPackage @@ -258795,6 +271609,8 @@ self: { ]; description = "A nice way to define field validations in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "validationt" = callPackage @@ -259005,6 +271821,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A library for generating values without having to thread state"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vampire" = callPackage @@ -259027,6 +271845,8 @@ self: { ]; description = "Analyze and visualize expression trees"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "var" = callPackage @@ -259044,6 +271864,8 @@ self: { benchmarkHaskellDepends = [ array base criterion deepseq ]; description = "Mutable variables and tuples"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "var-monad" = callPackage @@ -259073,6 +271895,8 @@ self: { ]; description = "Process mpileup output to identify significant differences"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "variable-precision" = callPackage @@ -259089,6 +271913,7 @@ self: { ]; description = "variable-precision floating point"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "variables" = callPackage @@ -259101,6 +271926,8 @@ self: { testHaskellDepends = [ base hspec mtl QuickCheck stm ]; description = "Monads with variables, without deep magic"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "variadic" = callPackage @@ -259118,6 +271945,8 @@ self: { benchmarkHaskellDepends = [ base criterion mmorph mtl ]; description = "Abstractions for working with variadic functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "variation" = callPackage @@ -259132,6 +271961,8 @@ self: { ]; description = "nominal value with possible variations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "varying" = callPackage @@ -259205,6 +272036,8 @@ self: { ]; description = "Utility library for spawning a HashiCorp Vault process"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vault-trans" = callPackage @@ -259221,6 +272054,8 @@ self: { ]; description = "A monad transformer for vault-tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vaultaire-common" = callPackage @@ -259244,6 +272079,8 @@ self: { ]; description = "Common types and instances for Vaultaire"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vcache" = callPackage @@ -259260,6 +272097,8 @@ self: { ]; description = "semi-transparent persistence for Haskell using LMDB, STM"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vcache-trie" = callPackage @@ -259275,6 +272114,7 @@ self: { ]; description = "patricia tries modeled above VCache"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vcard" = callPackage @@ -259288,6 +272128,7 @@ self: { ]; description = "A library for parsing/printing vCards from/to various formats"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; }) {}; "vcatt" = callPackage @@ -259302,6 +272143,8 @@ self: { executableHaskellDepends = [ base shelly text ]; description = "Recursively check that a directory is under version control"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vcd" = callPackage @@ -259329,6 +272172,8 @@ self: { ]; description = "A package to parse VCF files inspired in similar python libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vcs-revision" = callPackage @@ -259374,6 +272219,7 @@ self: { ]; description = "GUI library for source code management systems"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "vcswrapper" = callPackage @@ -259397,6 +272243,8 @@ self: { ]; description = "Wrapper for source code management systems"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vec" = callPackage @@ -259463,6 +272311,8 @@ self: { libraryHaskellDepends = [ base random ]; description = "A low-dimensional linear algebra library, operating on the Floating typeclass"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vect-floating-accelerate" = callPackage @@ -259476,6 +272326,7 @@ self: { libraryHaskellDepends = [ accelerate base vect-floating ]; description = "Accelerate instances for vect-floating types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vect-opengl" = callPackage @@ -259487,6 +272338,8 @@ self: { libraryHaskellDepends = [ base OpenGL vect ]; description = "OpenGL support for the `vect' low-dimensional linear algebra library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector" = callPackage @@ -259610,6 +272463,8 @@ self: { testHaskellDepends = [ base directory QuickCheck random ]; description = "ByteStrings as type synonyms of Storable Vectors of Word8s"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-circular" = callPackage @@ -259647,6 +272502,8 @@ self: { ]; description = "Vector clocks for versioning message flows"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-conduit" = callPackage @@ -259665,6 +272522,8 @@ self: { ]; description = "Conduit utilities for vectors"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-doublezip" = callPackage @@ -259690,6 +272549,7 @@ self: { doHaddock = false; description = "Storable vectors with cpu-independent representation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "vector-extras" = callPackage @@ -259735,6 +272595,8 @@ self: { ]; description = "A binding to the fftw library for one-dimensional vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fftw;}; "vector-functorlazy" = callPackage @@ -259749,6 +272611,8 @@ self: { ]; description = "vectors that perform the fmap operation in constant time"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-heterogenous" = callPackage @@ -259760,6 +272624,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "A type-safe library for vectors whose elements can be of any type, or any type satisfying some constraints"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-instances" = callPackage @@ -259788,6 +272654,7 @@ self: { ]; description = "Instances of the Data.Collections classes for Data.Vector.*"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vector-mmap" = callPackage @@ -259815,6 +272682,8 @@ self: { libraryHaskellDepends = [ base mersenne-random-pure64 vector ]; description = "Generate vectors filled with high quality pseudorandom numbers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-read-instances" = callPackage @@ -259826,6 +272695,8 @@ self: { libraryHaskellDepends = [ base vector ]; description = "(deprecated) Read instances for 'Data.Vector'"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-rotcev" = callPackage @@ -259889,6 +272760,8 @@ self: { testHaskellDepends = [ base doctest ]; description = "vector-space operations for finite maps using Data.Map"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-space-opengl" = callPackage @@ -259906,6 +272779,8 @@ self: { ]; description = "Instances of vector-space classes for OpenGL types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-space-points" = callPackage @@ -259919,6 +272794,8 @@ self: { libraryHaskellDepends = [ base vector-space ]; description = "A type for points, as distinct from vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-split" = callPackage @@ -259946,6 +272823,8 @@ self: { libraryHaskellDepends = [ base primitive vector ]; description = "Statically checked sizes on Data.Vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-strategies" = callPackage @@ -259972,6 +272851,7 @@ self: { ]; description = "Text implementation based on unboxed char vector"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "vector-th-unbox" = callPackage @@ -260056,6 +272936,7 @@ self: { ]; description = "ASCII platform-adventure game"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "verbalexpressions" = callPackage @@ -260067,6 +272948,8 @@ self: { libraryHaskellDepends = [ base regex-pcre ]; description = "Regular expressions made easy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "verbosity" = callPackage @@ -260099,6 +272982,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Validation framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "verdict-json" = callPackage @@ -260119,6 +273004,7 @@ self: { ]; description = "JSON instances and JSON Schema for verdict"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "verifiable-expressions" = callPackage @@ -260156,6 +273042,8 @@ self: { ]; description = "A new Haskeleton package"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "verilog" = callPackage @@ -260168,6 +273056,8 @@ self: { libraryToolDepends = [ alex happy ]; description = "Verilog preprocessor, parser, and AST"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "verismith" = callPackage @@ -260204,6 +273094,8 @@ self: { benchmarkHaskellDepends = [ base criterion lens ]; description = "Random verilog generation and simulator testing"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "versioning" = callPackage @@ -260216,6 +273108,8 @@ self: { testHaskellDepends = [ aeson base bytestring hspec ]; description = "Type-safe data versioning"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "versioning-servant" = callPackage @@ -260236,6 +273130,7 @@ self: { ]; description = "Servant combinators for the versioning library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "versions" = callPackage @@ -260297,6 +273192,7 @@ self: { ]; description = "types for ingesting vflow data with aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vformat" = callPackage @@ -260374,6 +273270,7 @@ self: { ]; description = "VFR waypoints, as published in the AIP (ERSA)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vgrep" = callPackage @@ -260430,6 +273327,8 @@ self: { ]; description = "Provides functions to inspect and manipulate virtual hard disk (VHD) files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vhdl" = callPackage @@ -260441,6 +273340,8 @@ self: { libraryHaskellDepends = [ base mtl pretty regex-posix ]; description = "VHDL AST and pretty printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vicinity" = callPackage @@ -260456,6 +273357,8 @@ self: { base containers doctest QuickCheck quickcheck-classes ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "viewprof" = callPackage @@ -260474,6 +273377,8 @@ self: { ]; description = "Text-based interactive GHC .prof viewer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "views" = callPackage @@ -260485,6 +273390,8 @@ self: { libraryHaskellDepends = [ base mtl ]; description = "Views allow you to run a State monad on part of a state"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vigilance" = callPackage @@ -260525,6 +273432,7 @@ self: { ]; description = "An extensible dead-man's switch system"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "vimeta" = callPackage @@ -260580,6 +273488,8 @@ self: { ]; description = "An MPD client with vim-like key bindings"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ncurses;}; "vintage-basic" = callPackage @@ -260600,6 +273510,8 @@ self: { testHaskellDepends = [ base ]; description = "Interpreter for microcomputer-era BASIC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vinyl" = callPackage @@ -260676,6 +273588,8 @@ self: { testHaskellDepends = [ base hlint ]; description = "Provide json instances automagically to vinyl types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vinyl-loeb" = callPackage @@ -260698,6 +273612,8 @@ self: { libraryHaskellDepends = [ base vinyl ]; description = "Syntax sugar for vinyl records using overloaded labels"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vinyl-operational" = callPackage @@ -260712,6 +273628,7 @@ self: { ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vinyl-plus" = callPackage @@ -260731,6 +273648,8 @@ self: { testHaskellDepends = [ base doctest vinyl ]; description = "Vinyl records utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vinyl-utils" = callPackage @@ -260742,6 +273661,8 @@ self: { libraryHaskellDepends = [ base contravariant transformers vinyl ]; description = "Utilities for vinyl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vinyl-vectors" = callPackage @@ -260760,6 +273681,8 @@ self: { ]; description = "Vectors for vinyl vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "virthualenv" = callPackage @@ -260779,6 +273702,8 @@ self: { ]; description = "Virtual Haskell Environment builder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "visibility" = callPackage @@ -260790,6 +273715,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Simple computation of visibility polygons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vision" = callPackage @@ -260811,6 +273738,7 @@ self: { ]; description = "An XMMS2 client"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "visual-graphrewrite" = callPackage @@ -260838,6 +273766,7 @@ self: { ]; description = "Visualize the graph-rewrite steps of a Haskell program"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "visual-prof" = callPackage @@ -260856,6 +273785,8 @@ self: { ]; description = "Create a visual profile of a program's source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "visualize-cbn" = callPackage @@ -260875,6 +273806,8 @@ self: { ]; description = "Visualize CBN reduction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vitrea" = callPackage @@ -260886,6 +273819,8 @@ self: { libraryHaskellDepends = [ base mtl profunctors ]; description = "Profunctor optics via the profunctor representation theorem"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vivid" = callPackage @@ -260954,6 +273889,8 @@ self: { ]; description = "Amazon Route53 DNS service plugin for the aws package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vk-posix-pty" = callPackage @@ -260992,6 +273929,7 @@ self: { libraryHaskellDepends = [ base random vector vector-fftw ]; description = "Phase vocoder"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "vocoder-audio" = callPackage @@ -261010,6 +273948,7 @@ self: { ]; description = "Phase vocoder for conduit-audio"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "vocoder-conduit" = callPackage @@ -261031,6 +273970,7 @@ self: { ]; description = "Phase vocoder for Conduit"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "vocoder-dunai" = callPackage @@ -261052,6 +273992,7 @@ self: { ]; description = "Phase vocoder for Dunai and Rhine"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "voicebase" = callPackage @@ -261076,6 +274017,7 @@ self: { testHaskellDepends = [ aeson base hspec roundtrip-aeson ]; description = "Upload audio files to voicebase to get a transcription"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "void" = callPackage @@ -261112,6 +274054,8 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Vowpal Wabbit utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "voyeur" = callPackage @@ -261123,6 +274067,8 @@ self: { libraryHaskellDepends = [ base bytestring process utf8-string ]; description = "Haskell bindings for libvoyeur"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vp-tree" = callPackage @@ -261163,6 +274109,8 @@ self: { testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Priority queue based on vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vrpn" = callPackage @@ -261223,6 +274171,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the VTE library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) vte;}; "vtegtk3" = callPackage @@ -261240,6 +274190,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the VTE library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) vte;}; "vty" = callPackage @@ -261297,6 +274249,8 @@ self: { ]; description = "Examples programs using the vty library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vty-menu" = callPackage @@ -261310,6 +274264,8 @@ self: { libraryHaskellDepends = [ base vty ]; description = "A lib for displaying a menu and getting a selection using VTY"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vty-ui" = callPackage @@ -261331,6 +274287,8 @@ self: { executableHaskellDepends = [ base QuickCheck random text vty ]; description = "An interactive terminal user interface library for Vty"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vty-ui-extras" = callPackage @@ -261342,6 +274300,7 @@ self: { libraryHaskellDepends = [ base regex-base regex-pcre vty vty-ui ]; description = "Extra vty-ui functionality not included in the core library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "vulkan" = callPackage @@ -261428,6 +274387,7 @@ self: { ]; description = "JSON wrangling"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wacom-daemon" = callPackage @@ -261451,6 +274411,8 @@ self: { ]; description = "Manage Wacom tablet settings profiles, including Intuos Pro ring modes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "waddle" = callPackage @@ -261473,6 +274435,8 @@ self: { ]; description = "DOOM WAD file utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wahsp" = callPackage @@ -261493,6 +274457,7 @@ self: { ]; description = "A haskell binding of the Web Audio API ala blank-canvas"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai" = callPackage @@ -261612,6 +274577,7 @@ self: { ]; description = "Command line runner for Wai apps (using Warp) with TLS, CGI, socket activation & graceful shutdown"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "wai-conduit" = callPackage @@ -261695,6 +274661,7 @@ self: { testHaskellDepends = [ base hspec stm ]; description = "A web server for the development of WAI compliant web applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "wai-digestive-functors" = callPackage @@ -261845,6 +274812,8 @@ self: { ]; description = "Git http-backend CGI App of WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-graceful" = callPackage @@ -261856,6 +274825,8 @@ self: { libraryHaskellDepends = [ base http-types mtl resourcet unix wai ]; description = "Graceful shutdown for WAI applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-handler-devel" = callPackage @@ -261876,6 +274847,8 @@ self: { executableHaskellDepends = [ cmdargs ]; description = "WAI server that automatically reloads code after modification. (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-handler-fastcgi" = callPackage @@ -261888,6 +274861,8 @@ self: { librarySystemDepends = [ fcgi ]; description = "Wai handler to fastcgi"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) fcgi;}; "wai-handler-hal" = callPackage @@ -261932,6 +274907,8 @@ self: { libraryHaskellDepends = [ base bytestring wai wai-extra ]; description = "Wai handler to SCGI (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-handler-snap" = callPackage @@ -261948,6 +274925,7 @@ self: { ]; description = "Web Application Interface handler using snap-server. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai-handler-webkit" = callPackage @@ -261960,6 +274938,8 @@ self: { libraryPkgconfigDepends = [ QtWebKit ]; description = "Turn WAI applications into standalone GUIs using QtWebkit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {QtWebKit = null;}; "wai-hastache" = callPackage @@ -261998,6 +274978,8 @@ self: { ]; description = "hmac authentication tools for WAI apps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-http2-extra" = callPackage @@ -262054,6 +275036,8 @@ self: { ]; description = "Lenses for WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-lite" = callPackage @@ -262069,6 +275053,8 @@ self: { ]; description = "DEPCRECATED (use package \"simple\" instead) A minimalist web framework for WAI web applications"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-log" = callPackage @@ -262125,6 +275111,8 @@ self: { ]; description = "Buffer requets before logging them"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-logger-prefork" = callPackage @@ -262141,6 +275129,8 @@ self: { ]; description = "A logging system for preforked WAI apps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-make-assets" = callPackage @@ -262170,6 +275160,8 @@ self: { ]; description = "Compiling and serving assets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-auth" = callPackage @@ -262255,6 +275247,7 @@ self: { ]; description = "Caching middleware for WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai-middleware-cache-redis" = callPackage @@ -262273,6 +275266,7 @@ self: { ]; description = "Redis backend for wai-middleware-cache"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai-middleware-caching" = callPackage @@ -262335,6 +275329,8 @@ self: { ]; description = "Wai error catching middleware"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-clacks" = callPackage @@ -262376,6 +275372,7 @@ self: { ]; description = "Wai Middleware for Consul"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "wai-middleware-content-type" = callPackage @@ -262408,6 +275405,7 @@ self: { ]; description = "Route to different middlewares based on the incoming Accept header"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai-middleware-crowd" = callPackage @@ -262439,6 +275437,8 @@ self: { ]; description = "Middleware and utilities for using Atlassian Crowd authentication"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-delegate" = callPackage @@ -262465,6 +275465,8 @@ self: { ]; description = "WAI middleware that delegates handling of requests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-etag" = callPackage @@ -262482,6 +275484,8 @@ self: { ]; description = "WAI ETag middleware for static files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-gunzip" = callPackage @@ -262508,6 +275512,8 @@ self: { libraryHaskellDepends = [ base bytestring http-types wai ]; description = "cors and addHeaders for WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-hmac" = callPackage @@ -262550,6 +275556,8 @@ self: { ]; description = "WAI HMAC Authentication Middleware Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-json-errors" = callPackage @@ -262608,6 +275616,8 @@ self: { ]; description = "WAI middleware for preprocessing static files"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-prometheus" = callPackage @@ -262641,6 +275651,7 @@ self: { ]; description = "Middleware that communicates to Rollbar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai-middleware-route" = callPackage @@ -262661,6 +275672,7 @@ self: { ]; description = "Wai dispatch middleware"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai-middleware-slack-verify" = callPackage @@ -262727,6 +275739,8 @@ self: { ]; description = "WAI middleware that serves requests to static files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-static-embedded" = callPackage @@ -262786,6 +275800,8 @@ self: { ]; description = "WAI middleware for authenticating webhook payloads from Travis CI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-middleware-validation" = callPackage @@ -262877,6 +275893,8 @@ self: { ]; description = "Redis backend for rate limiting as WAI middleware"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-request-spec" = callPackage @@ -262895,6 +275913,8 @@ self: { ]; description = "Declarative request parsing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-responsible" = callPackage @@ -262906,6 +275926,8 @@ self: { libraryHaskellDepends = [ base bytestring http-types wai ]; description = "Response interface for WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-route" = callPackage @@ -262939,6 +275961,8 @@ self: { libraryHaskellDepends = [ base text wai ]; description = "Provides basic routing on URL paths for WAI"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-routes" = callPackage @@ -262963,6 +275987,8 @@ self: { ]; description = "Typesafe URLs for Wai applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-routing" = callPackage @@ -262989,6 +276015,8 @@ self: { ]; description = "Declarative routing for WAI"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-saml2" = callPackage @@ -263029,6 +276057,8 @@ self: { wai-extra ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-session" = callPackage @@ -263063,6 +276093,8 @@ self: { ]; description = "An alternative session middleware for WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-session-clientsession" = callPackage @@ -263100,6 +276132,8 @@ self: { ]; description = "MySQL backed Wai session store"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-session-postgresql" = callPackage @@ -263122,6 +276156,8 @@ self: { ]; description = "PostgreSQL backed Wai session store"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-session-redis" = callPackage @@ -263147,6 +276183,8 @@ self: { ]; description = "Simple Redis backed wai-session backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-session-tokyocabinet" = callPackage @@ -263195,6 +276233,8 @@ self: { ]; description = "A simple cache for serving static files in a WAI middleware"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-static-pages" = callPackage @@ -263238,6 +276278,7 @@ self: { ]; description = "Thrift transport layer for Wai"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "wai-throttler" = callPackage @@ -263253,6 +276294,8 @@ self: { ]; description = "Wai middleware for request throttling"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-transformers" = callPackage @@ -263332,6 +276375,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "A wrapping library for waitfree computation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "waitra" = callPackage @@ -263356,6 +276401,8 @@ self: { ]; description = "A very simple Wai router"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wakame" = callPackage @@ -263406,6 +276453,7 @@ self: { ]; description = "A generator of comics based on some ascertainable data about the requester"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wallpaper" = callPackage @@ -263427,6 +276475,8 @@ self: { testHaskellDepends = [ base ]; description = "A library and executable for creating wallpaper, frieze, and rosette patterns"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "warc" = callPackage @@ -263455,6 +276505,8 @@ self: { ]; description = "A parser for the Web Archive (WARC) format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "warp" = callPackage @@ -263504,6 +276556,8 @@ self: { executableHaskellDepends = [ base ]; description = "Dynamic configurable warp HTTP server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "warp-grpc" = callPackage @@ -263521,6 +276575,8 @@ self: { ]; description = "A minimal gRPC server on top of Warp"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "warp-static" = callPackage @@ -263541,6 +276597,8 @@ self: { ]; description = "Static file server based on Warp and wai-app-static (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "warp-systemd" = callPackage @@ -263552,6 +276610,8 @@ self: { libraryHaskellDepends = [ base network systemd unix wai warp ]; description = "Socket activation and other systemd integration for the Warp web server (WAI)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "warp-tls" = callPackage @@ -263605,6 +276665,7 @@ self: { ]; description = "Warp and Wai Library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "wasm" = callPackage @@ -263633,6 +276694,8 @@ self: { testToolDepends = [ alex happy ]; description = "WebAssembly Language Toolkit and Interpreter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "watchdog" = callPackage @@ -263646,6 +276709,8 @@ self: { libraryHaskellDepends = [ base mtl time ]; description = "Simple control structure to re-try an action with exponential backoff"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "watcher" = callPackage @@ -263662,6 +276727,8 @@ self: { ]; description = "Opinionated filesystem watcher"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "watchit" = callPackage @@ -263690,6 +276757,8 @@ self: { ]; description = "File change watching utility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wavconvert" = callPackage @@ -263740,6 +276809,8 @@ self: { ]; description = "Wavefront OBJ loader"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wavefront-obj" = callPackage @@ -263758,6 +276829,8 @@ self: { testHaskellDepends = [ base hspec linear ]; description = "Wavefront .obj file loader"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wavesurfer" = callPackage @@ -263774,6 +276847,7 @@ self: { ]; description = "Parse WaveSurfer files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wavy" = callPackage @@ -263794,6 +276868,7 @@ self: { ]; description = "Process WAVE files in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wcwidth" = callPackage @@ -263829,6 +276904,8 @@ self: { libraryHaskellDepends = [ base containers ]; description = "Mutable bag backed by weak pointers to each item"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "weather-api" = callPackage @@ -263845,6 +276922,8 @@ self: { ]; description = "Weather API implemented in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-browser-in-haskell" = callPackage @@ -263868,6 +276947,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Simple functions for CSS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-encodings" = callPackage @@ -263885,6 +276966,8 @@ self: { ]; description = "Encapsulate multiple web encoding in a single package. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-fpco" = callPackage @@ -263938,6 +277021,7 @@ self: { ]; description = "Bindings for the Mongrel2 web server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "web-output" = callPackage @@ -263956,6 +277040,8 @@ self: { ]; description = "Library to present content to an user via their browser"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-page" = callPackage @@ -263975,6 +277061,7 @@ self: { ]; description = "Monoidally construct web pages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "web-plugins" = callPackage @@ -264011,6 +277098,8 @@ self: { ]; description = "Send messages using Web Push protocol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-rep" = callPackage @@ -264040,6 +277129,7 @@ self: { ]; description = "representations of a web page"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "web-routes" = callPackage @@ -264132,6 +277222,8 @@ self: { libraryHaskellDepends = [ base path-pieces template-haskell text ]; description = "Define data types and parse/build functions for web-routes via a quasi-quoted DSL (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-routes-regular" = callPackage @@ -264143,6 +277235,7 @@ self: { libraryHaskellDepends = [ base parsec regular text web-routes ]; description = "portable, type-safe URL routing"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "web-routes-th" = callPackage @@ -264170,6 +277263,8 @@ self: { libraryHaskellDepends = [ base transformers web-routes ]; description = "Extends web-routes with some transformers instances for RouteT"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-routes-wai" = callPackage @@ -264204,6 +277299,7 @@ self: { benchmarkHaskellDepends = [ base criterion text ]; description = "simple routing library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "web3" = callPackage @@ -264243,6 +277339,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Web3 API for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "webapi" = callPackage @@ -264269,6 +277366,7 @@ self: { ]; description = "WAI based library for web api"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "webapp" = callPackage @@ -264291,6 +277389,8 @@ self: { ]; description = "Haskell web app framework based on WAI & Warp"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webauthn" = callPackage @@ -264350,6 +277450,8 @@ self: { executableHaskellDepends = [ base optparse-applicative ]; description = "Turn an optparse-applicative program into a CGI program!"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webcrank" = callPackage @@ -264377,6 +277479,8 @@ self: { ]; description = "Webmachine inspired toolkit for building http applications and services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webcrank-dispatch" = callPackage @@ -264392,6 +277496,8 @@ self: { ]; description = "A simple request dispatcher"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webcrank-wai" = callPackage @@ -264409,6 +277515,7 @@ self: { ]; description = "Build a WAI Application from Webcrank Resources"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "webdriver" = callPackage @@ -264453,6 +277560,8 @@ self: { ]; description = "Webdriver actions to assist with testing a webpage which uses Angular.Js"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webdriver-snoy" = callPackage @@ -264479,6 +277588,8 @@ self: { testHaskellDepends = [ base parallel text ]; description = "a Haskell client for the Selenium WebDriver protocol (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webdriver-w3c" = callPackage @@ -264514,6 +277625,7 @@ self: { ]; description = "Bindings to the WebDriver API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "webex-teams-api" = callPackage @@ -264613,6 +277725,8 @@ self: { ]; description = "WebFinger client library"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webgear-server" = callPackage @@ -264680,6 +277794,8 @@ self: { ]; description = "webfont generator"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webkit" = callPackage @@ -264713,6 +277829,8 @@ self: { libraryPkgconfigDepends = [ webkit ]; description = "JavaScriptCore FFI from webkitgtk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {webkit = null;}; "webkit2gtk3-javascriptcore" = callPackage @@ -264786,6 +277904,8 @@ self: { ]; description = "Types and functions for working with Webmentions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webp" = callPackage @@ -264847,6 +277967,7 @@ self: { ]; description = "HTTP server library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "webshow" = callPackage @@ -264866,6 +277987,8 @@ self: { ]; description = "Show programming language printed values in a web UI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "websnap" = callPackage @@ -264941,6 +278064,8 @@ self: { ]; description = "Simple streaming RPC mechanism using WebSockets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "websockets-simple" = callPackage @@ -265011,6 +278136,8 @@ self: { ]; description = "Functional reactive web framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wedding-announcement" = callPackage @@ -265096,6 +278223,8 @@ self: { ]; description = "A school-timetable problem-solver"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "weigh" = callPackage @@ -265122,6 +278251,7 @@ self: { libraryHaskellDepends = [ base mtl semiring-num transformers ]; description = "Writer monad which uses semiring constraint"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "weighted-regexp" = callPackage @@ -265136,6 +278266,8 @@ self: { libraryToolDepends = [ happy ]; description = "Weighted Regular Expression Matcher"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "weighted-search" = callPackage @@ -265166,6 +278298,8 @@ self: { ]; description = "Haskell web framework (because Scotty had trouble yodeling)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wembley" = callPackage @@ -265207,6 +278341,8 @@ self: { ]; description = "A game engine for playing werewolf within an arbitrary chat client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "werewolf-slack" = callPackage @@ -265226,6 +278362,7 @@ self: { ]; description = "A chat interface for playing werewolf in Slack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "what4" = callPackage @@ -265263,6 +278400,7 @@ self: { ]; description = "Solver-agnostic symbolic values support for issuing queries"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wheb-mongo" = callPackage @@ -265274,6 +278412,7 @@ self: { libraryHaskellDepends = [ base bson mongoDB mtl text Wheb ]; description = "MongoDB plugin for Wheb"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wheb-redis" = callPackage @@ -265285,6 +278424,7 @@ self: { libraryHaskellDepends = [ base bytestring hedis mtl text Wheb ]; description = "Redis connection for Wheb"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wheb-strapped" = callPackage @@ -265296,6 +278436,7 @@ self: { libraryHaskellDepends = [ base mtl StrappedTemplates text Wheb ]; description = "Strapped templates for Wheb"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "which" = callPackage @@ -265318,6 +278459,8 @@ self: { libraryHaskellDepends = [ base indents parsec ]; description = "Parser for the While language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "whim" = callPackage @@ -265336,6 +278479,8 @@ self: { ]; description = "A Haskell window manager"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "whiskers" = callPackage @@ -265347,6 +278492,8 @@ self: { libraryHaskellDepends = [ base parsec template-haskell ]; description = "Mustache templates with Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "whitespace" = callPackage @@ -265361,6 +278508,7 @@ self: { executableHaskellDepends = [ haskell98 random ]; description = "Whitespace, an esoteric programming language"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "whois" = callPackage @@ -265374,6 +278522,8 @@ self: { libraryHaskellDepends = [ base network network-uri split ]; description = "WHOIS client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wholepixels" = callPackage @@ -265408,6 +278558,8 @@ self: { libraryToolDepends = [ alex happy ]; description = "Haskell support for the Why3 input format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wide-word" = callPackage @@ -265427,6 +278579,8 @@ self: { ]; description = "Data types for large but fixed width signed and unsigned integers"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wide-word-instances" = callPackage @@ -265438,6 +278592,7 @@ self: { libraryHaskellDepends = [ base binary serialise wide-word ]; description = "Instances for wide-word"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wigner-symbols" = callPackage @@ -265505,6 +278660,7 @@ self: { ]; description = "Wikipedia EPUB E-Book construction from Firefox history"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wild-bind" = callPackage @@ -265641,6 +278797,8 @@ self: { librarySystemDepends = [ dnsapi ]; description = "Domain Name Service (DNS) lookup via the /dnsapi.dll standard library"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {dnsapi = null;}; "windowslive" = callPackage @@ -265658,6 +278816,7 @@ self: { ]; description = "Implements Windows Live Web Authentication and Delegated Authentication"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "winerror" = callPackage @@ -265669,6 +278828,8 @@ self: { doHaddock = false; description = "Error handling for foreign calls to the Windows API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "winery" = callPackage @@ -265722,6 +278883,7 @@ self: { librarySystemDepends = [ kernel32 ws2_32 ]; description = "I/O library for Windows"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {kernel32 = null; ws2_32 = null;}; "wire-streams" = callPackage @@ -265764,6 +278926,8 @@ self: { ]; description = "Functional reactive programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wiring" = callPackage @@ -265780,6 +278944,8 @@ self: { ]; description = "Wiring, promotion and demotion of types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wiringPi" = callPackage @@ -265952,6 +279118,8 @@ self: { executableHaskellDepends = [ base bytestring network unix ]; description = "A network server to show bottlenecks of GHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wizard" = callPackage @@ -265998,6 +279166,8 @@ self: { ]; description = "Parsec parsers and types for geographic data in well-known text (WKT) format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wkt-geom" = callPackage @@ -266021,6 +279191,8 @@ self: { ]; description = "A parser of WKT, WKB and eWKB"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wl-pprint" = callPackage @@ -266064,6 +279236,7 @@ self: { ]; description = "ANSI Terminal support with wl-pprint-extras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wl-pprint-console" = callPackage @@ -266098,6 +279271,8 @@ self: { ]; description = "A free monad based on the Wadler/Leijen pretty printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wl-pprint-terminfo" = callPackage @@ -266115,6 +279290,7 @@ self: { ]; description = "A color pretty printer with terminfo support"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wl-pprint-text" = callPackage @@ -266144,6 +279320,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell bindings for the wlc library"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {wlc = null;}; "wobsurv" = callPackage @@ -266179,6 +279356,7 @@ self: { ]; description = "A simple and highly performant HTTP file server"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "woe" = callPackage @@ -266190,6 +279368,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Convenient typeclass for defining arbitrary-index enums"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "woffex" = callPackage @@ -266205,6 +279385,8 @@ self: { ]; description = "Web Open Font Format (WOFF) unpacker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wol" = callPackage @@ -266219,6 +279401,8 @@ self: { executableHaskellDepends = [ base ]; description = "Send a Wake on LAN Magic Packet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wolf" = callPackage @@ -266241,6 +279425,7 @@ self: { executableHaskellDepends = [ base optparse-generic ]; description = "Amazon Simple Workflow Service Wrapper"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "woot" = callPackage @@ -266355,6 +279540,8 @@ self: { ]; description = "Reading word2vec binary models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "word8" = callPackage @@ -266446,6 +279633,8 @@ self: { unordered-containers ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wordlist" = callPackage @@ -266464,6 +279653,8 @@ self: { ]; description = "Command-line tool to get random words"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wordn" = callPackage @@ -266506,6 +279697,8 @@ self: { ]; description = "Dictionary-based password generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wordpress-auth" = callPackage @@ -266524,6 +279717,8 @@ self: { ]; description = "Validate Wordpress Cookies & Nonces; Build Wordpress Hashes & Salts"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "words" = callPackage @@ -266550,6 +279745,8 @@ self: { executableHaskellDepends = [ base containers fclabels ]; description = "A word search solver library and executable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wordsetdiff" = callPackage @@ -266582,6 +279779,8 @@ self: { executableHaskellDepends = [ base text ]; description = "A library for parsing a chat-based work hour reporting scheme"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "workdays" = callPackage @@ -266594,6 +279793,8 @@ self: { testHaskellDepends = [ base containers doctest hspec ]; description = "Workday calculations"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "workflow-extra" = callPackage @@ -266616,6 +279817,7 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "Utilities (e.g. Googling the clipboard contents) for the `workflow` pacakge"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "workflow-osx" = callPackage @@ -266635,6 +279837,8 @@ self: { executableHaskellDepends = [ base ]; description = "a \"Desktop Workflow\" monad with Objective-C bindings"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "workflow-pure" = callPackage @@ -266657,6 +279861,7 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq ]; description = "manipulate `workflow-types:Workflow`'s"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "workflow-types" = callPackage @@ -266675,6 +279880,7 @@ self: { executableHaskellDepends = [ base ]; description = "Automate keyboard\\/mouse\\/clipboard\\/application interaction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "workflow-windows" = callPackage @@ -266689,6 +279895,8 @@ self: { testHaskellDepends = [ base doctest hspec QuickCheck ]; description = "Automate keyboard/mouse/clipboard/application interaction"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "world-peace" = callPackage @@ -266731,6 +279939,8 @@ self: { ]; description = "Subscribe to a wiki's RSS feed and archive external links"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wrap" = callPackage @@ -266773,6 +279983,7 @@ self: { ]; description = "Lazy wrapper to HaXML, HXT, TagSoup via custom XML tree structure"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "wrecker" = callPackage @@ -266811,6 +280022,7 @@ self: { ]; description = "An HTTP Performance Benchmarker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wrecker-ui" = callPackage @@ -266843,6 +280055,7 @@ self: { ]; description = "A web interface for Wrecker, the HTTP Performance Benchmarker"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wreq" = callPackage @@ -266934,6 +280147,8 @@ self: { ]; description = "An easy-to-use HTTP client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wreq-sb" = callPackage @@ -266971,6 +280186,8 @@ self: { ]; description = "An easy-to-use HTTP client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wreq-stringless" = callPackage @@ -266999,6 +280216,7 @@ self: { ]; description = "Colour space transformations and metrics"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "write-buffer-core" = callPackage @@ -267059,6 +280277,7 @@ self: { ]; description = "WriteT and RWST monad transformers (Reexport with all dependencies)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "writer-cps-lens" = callPackage @@ -267075,6 +280294,8 @@ self: { ]; description = "Lens instances for the stricter CPS WriterT and RWST"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "writer-cps-monads-tf" = callPackage @@ -267090,6 +280311,8 @@ self: { ]; description = "MonadWriter orphan instances for writer-cps-transformers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "writer-cps-morph" = callPackage @@ -267103,6 +280326,8 @@ self: { libraryHaskellDepends = [ base mmorph writer-cps-transformers ]; description = "MFunctor instance for CPS style WriterT and RWST"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "writer-cps-mtl" = callPackage @@ -267165,6 +280390,7 @@ self: { ]; description = "A simple CLI utility for interacting with a websocket"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ws-chans" = callPackage @@ -267206,6 +280432,8 @@ self: { ]; description = "WSDL parsing in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wsedit" = callPackage @@ -267223,6 +280451,8 @@ self: { ]; description = "A small tool to list, add and remove webseeds from a torrent file"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wshterm" = callPackage @@ -267262,6 +280492,8 @@ self: { executableHaskellDepends = [ base ]; description = "WSJT-X UDP protocol"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wss-client" = callPackage @@ -267280,6 +280512,7 @@ self: { testHaskellDepends = [ base bytestring envy hspec skews text ]; description = "A-little-higher-level WebSocket client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wstunnel" = callPackage @@ -267319,6 +280552,8 @@ self: { libraryHaskellDepends = [ base old-locale time transformers ]; description = "Wojcik Tool Kit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wtk-gtk" = callPackage @@ -267334,6 +280569,7 @@ self: { ]; description = "GTK tools within Wojcik Tool Kit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wu-wei" = callPackage @@ -267349,6 +280585,7 @@ self: { ]; description = "Unimportant Unix adminstration tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wumpus-basic" = callPackage @@ -267364,6 +280601,7 @@ self: { ]; description = "Basic objects and system code built on Wumpus-Core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wumpus-core" = callPackage @@ -267377,6 +280615,8 @@ self: { libraryHaskellDepends = [ base containers time vector-space ]; description = "Pure Haskell PostScript and SVG generation"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wumpus-drawing" = callPackage @@ -267392,6 +280632,7 @@ self: { ]; description = "High-level drawing objects built on Wumpus-Basic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wumpus-microprint" = callPackage @@ -267407,6 +280648,7 @@ self: { ]; description = "Microprints - \"greek-text\" pictures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wumpus-tree" = callPackage @@ -267423,6 +280665,7 @@ self: { ]; description = "Drawing trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wuss" = callPackage @@ -267464,6 +280707,7 @@ self: { executableHaskellDepends = [ base directory random wx wxcore ]; description = "Try to avoid the asteroids with your space ship"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wxFruit" = callPackage @@ -267478,6 +280722,7 @@ self: { executableHaskellDepends = [ base wx wxcore Yampa ]; description = "An implementation of Fruit using wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wxSimpleCanvas" = callPackage @@ -267489,6 +280734,7 @@ self: { libraryHaskellDepends = [ base cubicbezier wx wxcore ]; description = "Simple zoomable canvas for wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wxc" = callPackage @@ -267551,6 +280797,8 @@ self: { ]; description = "helper tool for building wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wxhnotepad" = callPackage @@ -267565,6 +280813,7 @@ self: { executableHaskellDepends = [ base wx wxcore ]; description = "An example of how to implement a basic notepad with wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wxturtle" = callPackage @@ -267580,6 +280829,7 @@ self: { ]; description = "turtle like LOGO with wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wybor" = callPackage @@ -267619,6 +280869,7 @@ self: { ]; description = "An autoresponder for Dragon Go Server"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "x-dsp" = callPackage @@ -267635,6 +280886,8 @@ self: { ]; description = "A embedded DSL for manipulating DSP languages in Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "x11-xim" = callPackage @@ -267868,6 +281121,8 @@ self: { ]; description = "XChat"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xcp" = callPackage @@ -267883,6 +281138,8 @@ self: { ]; description = "Partial implementation of the XCP protocol with ethernet as transport layer"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xdcc" = callPackage @@ -267908,6 +281165,7 @@ self: { ]; description = "A wget-like utility for retrieving files from XDCC bots on IRC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "xdg-basedir" = callPackage @@ -268004,6 +281262,8 @@ self: { libraryHaskellDepends = [ base bytestring cereal mtl network ]; description = "Xenstore client access"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xfconf" = callPackage @@ -268024,6 +281284,8 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "FFI bindings to xfconf"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {libxfconf = null;}; "xformat" = callPackage @@ -268036,6 +281298,8 @@ self: { testHaskellDepends = [ base ]; description = "Extensible, type-safe formatting with scanf- and printf-like functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xgboost-haskell" = callPackage @@ -268067,6 +281331,8 @@ self: { ]; description = "Replaces/Enhances Text.Regex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xhb" = callPackage @@ -268083,6 +281349,8 @@ self: { ]; description = "X Haskell Bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xhb-atom-cache" = callPackage @@ -268098,6 +281366,7 @@ self: { ]; description = "Atom cache for XHB"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "xhb-ewmh" = callPackage @@ -268114,6 +281383,7 @@ self: { ]; description = "EWMH utilities for XHB"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "xhtml_3000_2_2_1" = callPackage @@ -268156,6 +281426,8 @@ self: { executableHaskellDepends = [ base directory process ]; description = "The Lava system for Xilinx FPGA design with layout combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xine" = callPackage @@ -268170,6 +281442,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings to xine-lib"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {libxine = null; xine = null;}; "xing-api" = callPackage @@ -268193,6 +281467,8 @@ self: { ]; description = "Wrapper for the XING API, v1"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xinput-conduit" = callPackage @@ -268232,6 +281508,8 @@ self: { benchmarkHaskellDepends = [ base random time vector ]; description = "Haskell bindings for libxkbcommon"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libxkbcommon;}; "xkcd" = callPackage @@ -268251,6 +281529,8 @@ self: { ]; description = "Downloads the most recent xkcd comic"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xleb" = callPackage @@ -268266,6 +281546,8 @@ self: { libraryHaskellDepends = [ base containers mtl xml ]; description = "A simple monadic language for parsing XML structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xls" = callPackage @@ -268287,6 +281569,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "Parse Microsoft Excel xls files (BIFF/Excel 97-2004)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xlsior" = callPackage @@ -268310,6 +281594,8 @@ self: { ]; description = "Streaming Excel file generation and parsing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xlsx" = callPackage @@ -268372,6 +281658,8 @@ self: { ]; description = "Simple and incomplete Excel file templater"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml" = callPackage @@ -268417,6 +281705,7 @@ self: { ]; description = "Parse XML catalog files (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xml-conduit" = callPackage @@ -268460,6 +281749,8 @@ self: { ]; description = "Historical cursors & decoding on top of xml-conduit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-conduit-parse" = callPackage @@ -268503,6 +281794,8 @@ self: { ]; description = "jQuery-style CSS selectors for xml-conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-conduit-stylist" = callPackage @@ -268521,6 +281814,8 @@ self: { ]; description = "Bridge between xml-conduit/html-conduit and stylist"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-conduit-writer" = callPackage @@ -268560,6 +281855,7 @@ self: { ]; description = "Pure-Haskell utilities for dealing with XML with the enumerator package. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xml-enumerator-combinators" = callPackage @@ -268577,6 +281873,7 @@ self: { ]; description = "Parser combinators for xml-enumerator and compatible XML parsers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xml-extractors" = callPackage @@ -268637,6 +281934,8 @@ self: { ]; description = "Optics for xml-conduit and html-conduit"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-html-qq" = callPackage @@ -268732,6 +282031,7 @@ self: { ]; description = "Monadic extensions to the xml package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xml-optics" = callPackage @@ -268757,6 +282057,8 @@ self: { libraryHaskellDepends = [ base HaXml parsec ]; description = "Parsing XML with Parsec"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-picklers" = callPackage @@ -268785,6 +282087,7 @@ self: { libraryHaskellDepends = [ base bytestring papillon simple-pipe ]; description = "XML parser which uses simple-pipe"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xml-prettify" = callPackage @@ -268799,6 +282102,8 @@ self: { executableHaskellDepends = [ base cmdargs unix ]; description = "Pretty print XML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-push" = callPackage @@ -268819,6 +282124,7 @@ self: { ]; description = "Push XML from/to client to/from server over XMPP or HTTP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xml-query" = callPackage @@ -268830,6 +282136,8 @@ self: { libraryHaskellDepends = [ base-prelude free text ]; description = "A parser-agnostic declarative API for querying XML-documents"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-query-xml-conduit" = callPackage @@ -268846,6 +282154,7 @@ self: { ]; description = "A binding for the \"xml-query\" and \"xml-conduit\" libraries"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "xml-query-xml-types" = callPackage @@ -268869,6 +282178,7 @@ self: { ]; description = "An interpreter of \"xml-query\" queries for the \"xml-types\" documents"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "xml-to-json" = callPackage @@ -268925,6 +282235,7 @@ self: { ]; description = "Typed XML encoding for an xml-conduit backend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xml-tydom-core" = callPackage @@ -268936,6 +282247,8 @@ self: { libraryHaskellDepends = [ base containers mtl QuickCheck text ]; description = "Typed XML encoding (core library)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-types" = callPackage @@ -268987,6 +282300,8 @@ self: { ]; description = "translate xml to json"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml2x" = callPackage @@ -269005,6 +282320,7 @@ self: { ]; description = "Convert BLAST output in XML format to CSV or HTML"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "xmlbf" = callPackage @@ -269136,6 +282452,7 @@ self: { ]; description = "Show tv channels in the terminal"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "xmms2-client" = callPackage @@ -269152,6 +282469,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "An XMMS2 client library"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "xmms2-client-glib" = callPackage @@ -269164,6 +282482,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "An XMMS2 client library — GLib integration"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "xmobar" = callPackage @@ -269259,6 +282578,8 @@ self: { ]; description = "A tiling window manager"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xmonad-contrib" = callPackage @@ -269297,6 +282618,7 @@ self: { ]; description = "Third party extensions for xmonad"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xmonad-contrib-gpl" = callPackage @@ -269308,6 +282630,8 @@ self: { libraryHaskellDepends = [ base mtl xmonad xmonad-contrib ]; description = "Third party extensions for xmonad"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xmonad-dbus" = callPackage @@ -269322,6 +282646,8 @@ self: { executableHaskellDepends = [ base dbus utf8-string ]; testHaskellDepends = [ base dbus utf8-string ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xmonad-entryhelper" = callPackage @@ -269354,6 +282680,8 @@ self: { ]; description = "Module for evaluation Haskell expressions in the running xmonad instance"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xmonad-extras" = callPackage @@ -269434,6 +282762,8 @@ self: { testHaskellDepends = [ base hspec xmonad ]; description = "Custom xmonad, which builds with stack or cabal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xmonad-volume" = callPackage @@ -269482,6 +282812,8 @@ self: { ]; description = "A library to automatically put named windows into the DynamicLog"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xmpipe" = callPackage @@ -269498,6 +282830,7 @@ self: { ]; description = "XMPP implementation using simple-PIPE"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xor" = callPackage @@ -269518,6 +282851,8 @@ self: { ]; description = "Efficient XOR masking"; license = lib.licenses.gpl2Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xorshift" = callPackage @@ -269547,6 +282882,8 @@ self: { ]; description = "Simple implementation of xorshift+ PRNG"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xosd" = callPackage @@ -269576,6 +282913,7 @@ self: { ]; description = "text builder for xournal file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xournal-convert" = callPackage @@ -269597,6 +282935,7 @@ self: { executableHaskellDepends = [ base cmdargs ]; description = "convert utility for xoj files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xournal-parser" = callPackage @@ -269616,6 +282955,7 @@ self: { ]; description = "Xournal file parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xournal-render" = callPackage @@ -269633,6 +282973,7 @@ self: { ]; description = "Xournal file renderer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xournal-types" = callPackage @@ -269650,6 +282991,8 @@ self: { ]; description = "Data types for programs for xournal file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xpathdsv" = callPackage @@ -269711,6 +283054,8 @@ self: { ]; testToolDepends = [ hspec-discover ]; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xsact" = callPackage @@ -269728,6 +283073,8 @@ self: { ]; description = "Cluster EST sequences"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xsd" = callPackage @@ -269744,6 +283091,8 @@ self: { ]; description = "XML Schema data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xsha1" = callPackage @@ -269767,6 +283116,8 @@ self: { librarySystemDepends = [ xslt ]; description = "Binding to libxslt"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {xslt = null;}; "xss-sanitize" = callPackage @@ -269799,6 +283150,7 @@ self: { libraryHaskellDepends = [ base wx wxcore ]; description = "eXtended & Typed Controls for wxHaskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xtest" = callPackage @@ -269843,6 +283195,8 @@ self: { ]; description = "A Haskell implementation of the xxHash algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xxhash-ffi" = callPackage @@ -269879,6 +283233,8 @@ self: { ]; description = "#plaimi's all-encompassing bot"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yabi" = callPackage @@ -269912,6 +283268,8 @@ self: { executableHaskellDepends = [ base containers mtl parsec ]; description = "Yet Another Brainfuck Interpreter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yackage" = callPackage @@ -269935,6 +283293,8 @@ self: { ]; description = "Personal Hackage replacement for testing new packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yahoo-finance-api" = callPackage @@ -269956,6 +283316,8 @@ self: { ]; description = "Read quotes from Yahoo Finance API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yahoo-finance-conduit" = callPackage @@ -269971,6 +283333,8 @@ self: { ]; description = "Streaming aproach to the yahoo finance api"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yahoo-prices" = callPackage @@ -269988,6 +283352,8 @@ self: { doHaddock = false; description = "A wrapper around Yahoo API for downloading market data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yahoo-web-search" = callPackage @@ -269999,6 +283365,8 @@ self: { libraryHaskellDepends = [ base HTTP network xml ]; description = "Yahoo Web Search Services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yajl" = callPackage @@ -270012,6 +283380,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Bindings for YAJL, an event-based JSON implementation"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) yajl;}; "yajl-enumerator" = callPackage @@ -270027,6 +283397,7 @@ self: { ]; description = "Enumerator-based interface to YAJL, an event-based JSON implementation"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yak" = callPackage @@ -270054,6 +283425,8 @@ self: { libraryHaskellDepends = [ base categories transformers ]; description = "Lenses with a southern twang"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yam" = callPackage @@ -270087,6 +283460,7 @@ self: { ]; description = "A wrapper of servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yam-app" = callPackage @@ -270126,6 +283500,8 @@ self: { ]; description = "Yam Configuation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yam-datasource" = callPackage @@ -270143,6 +283519,7 @@ self: { ]; description = "Yam DataSource Middleware"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yam-job" = callPackage @@ -270168,6 +283545,7 @@ self: { ]; description = "Yam Logger"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yam-redis" = callPackage @@ -270184,6 +283562,7 @@ self: { ]; description = "Yam Redis Middleware"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yam-servant" = callPackage @@ -270200,6 +283579,8 @@ self: { servant-swagger-ui swagger2 text wai wai-extra warp yam-app yam-job ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yam-transaction" = callPackage @@ -270220,6 +283601,7 @@ self: { ]; description = "Yam transaction"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yam-transaction-odbc" = callPackage @@ -270232,6 +283614,7 @@ self: { base containers persistent-odbc yam-app ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yam-transaction-postgresql" = callPackage @@ -270275,6 +283658,7 @@ self: { ]; description = "Yam Web"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yamemo" = callPackage @@ -270394,6 +283778,8 @@ self: { testHaskellDepends = [ base hspec microlens-platform rio ]; description = "Extra functionality for pretty printing Yaml documents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yaml-rpc" = callPackage @@ -270412,6 +283798,8 @@ self: { ]; description = "Simple library for network (HTTP REST-like) YAML RPC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yaml-rpc-scotty" = callPackage @@ -270428,6 +283816,7 @@ self: { ]; description = "Scotty server backend for yaml-rpc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yaml-rpc-snap" = callPackage @@ -270444,6 +283833,7 @@ self: { ]; description = "Snap server backend for yaml-rpc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yaml-union" = callPackage @@ -270497,6 +283887,7 @@ self: { ]; description = "Flexible declarative YAML parsing toolkit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yaml2owl" = callPackage @@ -270584,6 +283975,8 @@ self: { ]; description = "Connects GLFW-b (GLFW 3+) with the Yampa FRP library"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yampa-gloss" = callPackage @@ -270597,6 +283990,8 @@ self: { libraryHaskellDepends = [ base gloss Yampa ]; description = "A GLOSS backend for Yampa"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yampa-glut" = callPackage @@ -270614,6 +284009,8 @@ self: { ]; description = "Connects Yampa and GLUT"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yampa-sdl2" = callPackage @@ -270632,6 +284029,8 @@ self: { ]; description = "Yampa and SDL2 made easy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yampa-test" = callPackage @@ -270663,6 +284062,8 @@ self: { executableHaskellDepends = [ base gloss random Yampa ]; description = "2048 game clone using Yampa/Gloss"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yandex-translate" = callPackage @@ -270680,6 +284081,8 @@ self: { ]; description = "Bindings to Yandex translate API"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yaop" = callPackage @@ -270693,6 +284096,8 @@ self: { libraryHaskellDepends = [ base mtl template-haskell ]; description = "Yet another option parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yap" = callPackage @@ -270704,6 +284109,8 @@ self: { libraryHaskellDepends = [ base ]; description = "yet another prelude - a simplistic refactoring with algebraic classes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yapb" = callPackage @@ -270799,6 +284206,8 @@ self: { ]; description = "Yet another array library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yarr-image-io" = callPackage @@ -270811,6 +284220,7 @@ self: { librarySystemDepends = [ libdevil ]; description = "Image IO for Yarr library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libdevil;}; "yasi" = callPackage @@ -270868,6 +284278,7 @@ self: { executableHaskellDepends = [ base Cabal directory process ]; description = "yet another visual editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yaya" = callPackage @@ -270914,6 +284325,8 @@ self: { ]; description = "Test suites for `yaya`"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yaya-unsafe" = callPackage @@ -270945,6 +284358,8 @@ self: { ]; description = "Test suites for `yaya-unsafe`"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ycextra" = callPackage @@ -270959,6 +284374,7 @@ self: { ]; description = "Additional utilities to work with Yhc Core"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yeamer" = callPackage @@ -270994,6 +284410,7 @@ self: { ]; description = "Yesod-based server for interactive presentation slides"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yeganesh" = callPackage @@ -271037,6 +284454,8 @@ self: { ]; description = "A Yeller Client For Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yes-precure5-command" = callPackage @@ -271069,6 +284488,7 @@ self: { libraryHaskellDepends = [ base yeshql-core yeshql-hdbc ]; description = "YesQL-style SQL database abstraction (legacy compatibility wrapper)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yeshql-core" = callPackage @@ -271108,6 +284528,8 @@ self: { ]; description = "YesQL-style SQL database abstraction (HDBC backend)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yeshql-postgresql-simple" = callPackage @@ -271129,6 +284551,8 @@ self: { ]; description = "YesQL-style SQL database abstraction (postgresql-simple backend)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod" = callPackage @@ -271181,6 +284605,8 @@ self: { ]; description = "Angular JS integratoin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-angular-ui" = callPackage @@ -271200,6 +284626,8 @@ self: { ]; description = "Angular Helpers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-articles" = callPackage @@ -271222,6 +284650,7 @@ self: { ]; description = "Automatically generate article previews for a yesod site"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-auth" = callPackage @@ -271272,6 +284701,8 @@ self: { ]; description = "An account authentication plugin for Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-account-fork" = callPackage @@ -271296,6 +284727,8 @@ self: { ]; description = "An account authentication plugin for Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-basic" = callPackage @@ -271329,6 +284762,8 @@ self: { ]; description = "BCrypt salted and hashed passwords in a database as auth for yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-bcryptdb" = callPackage @@ -271345,6 +284780,8 @@ self: { ]; description = "Authentication plugin for Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-deskcom" = callPackage @@ -271366,6 +284803,8 @@ self: { ]; description = "Desk.com remote authentication support for Yesod apps."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-fb" = callPackage @@ -271426,6 +284865,8 @@ self: { ]; description = "An account authentication plugin for yesod with encrypted token transfer"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-kerberos" = callPackage @@ -271443,6 +284884,8 @@ self: { ]; description = "Kerberos Authentication for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-ldap" = callPackage @@ -271459,6 +284902,7 @@ self: { ]; description = "LDAP Authentication for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-auth-ldap-mediocre" = callPackage @@ -271474,6 +284918,8 @@ self: { ]; description = "Very simlple LDAP auth for yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-ldap-native" = callPackage @@ -271491,6 +284937,8 @@ self: { testHaskellDepends = [ base ]; description = "Yesod LDAP authentication plugin"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-lti13" = callPackage @@ -271513,6 +284961,7 @@ self: { ]; description = "A yesod-auth plugin for LTI 1.3"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-auth-nopassword" = callPackage @@ -271529,6 +284978,8 @@ self: { ]; description = "A plugin for Yesod to provide email-only authentication"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-oauth" = callPackage @@ -271582,6 +285033,8 @@ self: { ]; description = "Provides PAM authentication module"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-smbclient" = callPackage @@ -271598,6 +285051,8 @@ self: { ]; description = "Authentication plugin for Yesod using smbclient"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-auth-zendesk" = callPackage @@ -271616,6 +285071,8 @@ self: { ]; description = "Zendesk remote authentication support for Yesod apps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-bin" = callPackage @@ -271659,6 +285116,8 @@ self: { ]; description = "Bootstrap widgets for yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-colonnade" = callPackage @@ -271677,6 +285136,7 @@ self: { ]; description = "Helper functions for using yesod with colonnade"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-comments" = callPackage @@ -271695,6 +285155,8 @@ self: { ]; description = "A generic comments interface for a Yesod application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-content-pdf" = callPackage @@ -271716,6 +285178,8 @@ self: { ]; description = "PDF Content Type for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-continuations" = callPackage @@ -271734,6 +285198,7 @@ self: { ]; description = "Continuations for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-core" = callPackage @@ -271788,6 +285253,8 @@ self: { ]; description = "Generic administrative CRUD operations as a Yesod subsite"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-crud-persist" = callPackage @@ -271806,6 +285273,8 @@ self: { ]; description = "Flexible CRUD subsite usable with Yesod and Persistent"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-csp" = callPackage @@ -271853,6 +285322,8 @@ self: { ]; description = "Yesod plugin for DataTables (jQuery grid plugin)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-default" = callPackage @@ -271890,6 +285361,8 @@ self: { ]; description = "DSL for generating Yesod subsite to manage an RDBMS;"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-elements" = callPackage @@ -271941,6 +285414,7 @@ self: { executableSystemDepends = [ sqlite ]; description = "Example programs using the Yesod Web Framework. (deprecated)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) sqlite;}; "yesod-fast-devel" = callPackage @@ -271962,6 +285436,8 @@ self: { ]; description = "Fast live-reloading for yesod applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-fay" = callPackage @@ -272018,6 +285494,8 @@ self: { ]; description = "Automatic filter generator for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-form" = callPackage @@ -272149,6 +285627,8 @@ self: { ]; description = "Various rich-text WYSIWYG editors for Yesod forms"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-gitrepo" = callPackage @@ -272180,6 +285660,8 @@ self: { testHaskellDepends = [ base yesod-core ]; description = "A subsite for displaying git information"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-goodies" = callPackage @@ -272196,6 +285678,8 @@ self: { ]; description = "A collection of various small helpers useful in any yesod application"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-ip" = callPackage @@ -272214,6 +285698,7 @@ self: { ]; description = "Code for using the ip package with yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-job-queue" = callPackage @@ -272235,6 +285720,8 @@ self: { testHaskellDepends = [ base ]; description = "Background jobs library for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-json" = callPackage @@ -272274,6 +285761,8 @@ self: { libraryHaskellDepends = [ base text yesod-core ]; description = "A typeclass which simplifies creating link widgets throughout your site"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-lucid" = callPackage @@ -272285,6 +285774,8 @@ self: { libraryHaskellDepends = [ base lucid monads-tf text yesod-core ]; description = "Lucid support for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-mangopay" = callPackage @@ -272304,6 +285795,7 @@ self: { ]; description = "Yesod library for MangoPay API access"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-markdown" = callPackage @@ -272389,6 +285881,8 @@ self: { libraryHaskellDepends = [ base template-haskell yesod ]; description = "Pagination for Yesod sites"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-pagination" = callPackage @@ -272407,6 +285901,8 @@ self: { ]; description = "Pagination in Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-paginator" = callPackage @@ -272443,6 +285939,7 @@ self: { ]; description = "Yesod plugin to use PayPal with the paypal-rest-client library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-persistent" = callPackage @@ -272555,6 +286052,7 @@ self: { ]; description = "Meta package for Yesod (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-pnotify" = callPackage @@ -272575,6 +286073,8 @@ self: { ]; description = "Yet another getMessage/setMessage using pnotify jquery plugins"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-pure" = callPackage @@ -272586,6 +286086,8 @@ self: { libraryHaskellDepends = [ base fast-logger text yesod yesod-core ]; description = "Yesod in pure Haskell: no Template Haskell or QuasiQuotes (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-purescript" = callPackage @@ -272605,6 +286107,7 @@ self: { ]; description = "PureScript integration for Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-raml" = callPackage @@ -272628,6 +286131,8 @@ self: { ]; description = "RAML style route definitions for Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-raml-bin" = callPackage @@ -272650,6 +286155,7 @@ self: { ]; description = "The raml helper executable"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-raml-docs" = callPackage @@ -272666,6 +286172,7 @@ self: { ]; description = "A html documentation generator library for RAML"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-raml-mock" = callPackage @@ -272689,6 +286196,7 @@ self: { ]; description = "A mock-handler generator library from RAML"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-recaptcha" = callPackage @@ -272707,6 +286215,8 @@ self: { ]; description = "Dead simple support for reCAPTCHA on Yesod applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-recaptcha2" = callPackage @@ -272743,6 +286253,8 @@ self: { ]; description = "Efficient routing for Yesod. (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-routes-flow" = callPackage @@ -272759,6 +286271,8 @@ self: { ]; description = "Generate Flow routes for Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-routes-typescript" = callPackage @@ -272775,6 +286289,7 @@ self: { ]; description = "generate TypeScript routes for Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-rst" = callPackage @@ -272791,6 +286306,8 @@ self: { ]; description = "Tools for using reStructuredText (RST) in a yesod application"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-s3" = callPackage @@ -272807,6 +286324,8 @@ self: { ]; description = "Simple Helper Library for using Amazon's Simple Storage Service (S3) with Yesod"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-sass" = callPackage @@ -272823,6 +286342,8 @@ self: { ]; description = "A simple quasiquoter to include sass code in yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-session-redis" = callPackage @@ -272840,6 +286361,7 @@ self: { ]; description = "Redis-Powered Sessions for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-sitemap" = callPackage @@ -272914,6 +286436,8 @@ self: { ]; description = "Yesod generators for embedding AngularJs code into yesod-static at compile time"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-static-remote" = callPackage @@ -272930,6 +286454,8 @@ self: { ]; testHaskellDepends = [ base yesod-static ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-table" = callPackage @@ -272999,6 +286525,8 @@ self: { ]; description = "Utility functions for testing JSON web services written in Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-text-markdown" = callPackage @@ -273031,6 +286559,8 @@ self: { ]; description = "Provides main functions using warp-tls for yesod projects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-transloadit" = callPackage @@ -273075,6 +286605,8 @@ self: { ]; description = "Simple CRUD classes for easy view creation for Yesod"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yesod-websockets" = callPackage @@ -273122,6 +286654,8 @@ self: { testHaskellDepends = [ base ]; description = "Initial project template from stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yet-another-logger" = callPackage @@ -273168,6 +286702,8 @@ self: { testHaskellDepends = [ base cryptonite hspec QuickCheck ]; description = "Executable specifications of composable cryptographic protocols"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yhccore" = callPackage @@ -273179,6 +286715,8 @@ self: { libraryHaskellDepends = [ base containers mtl pretty uniplate ]; description = "Yhc's Internal Core language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yhseq" = callPackage @@ -273197,6 +286735,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Calculation of YH sequence system"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yi" = callPackage @@ -273237,6 +286777,8 @@ self: { ]; description = "Add-ons to Yi, the Haskell-Scriptable Editor"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yi-core" = callPackage @@ -273523,6 +287065,8 @@ self: { libraryHaskellDepends = [ base yi ]; description = "Monokai colour theme for the Yi text editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yi-rope" = callPackage @@ -273573,6 +287117,8 @@ self: { libraryHaskellDepends = [ base yi ]; description = "Solarized colour theme for the Yi text editor"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yi-spolsky" = callPackage @@ -273584,6 +287130,8 @@ self: { libraryHaskellDepends = [ base yi ]; description = "Spolsky colour theme for the Yi text editor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yi-vty" = callPackage @@ -273607,6 +287155,8 @@ self: { libraryHaskellDepends = [ base parsec process ]; description = "Haskell programming interface to Yices SMT solver"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yices-easy" = callPackage @@ -273679,6 +287229,7 @@ self: { executableHaskellDepends = [ hsConfigure ]; description = "CUI FTP client like 'ftp', 'ncftp'"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "yjftp-libs" = callPackage @@ -273692,6 +287243,7 @@ self: { libraryHaskellDepends = [ base directory ftphs mtl process unix ]; description = "CUI FTP client like 'ftp', 'ncftp'"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "yjsvg" = callPackage @@ -273754,6 +287306,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Parser combinators for young padawans"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yoga" = callPackage @@ -273786,6 +287340,7 @@ self: { ]; description = "Generic Programming with Disbanded Data Types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "york-lava" = callPackage @@ -273797,6 +287352,7 @@ self: { libraryHaskellDepends = [ base containers haskell98 ]; description = "A library for digital circuit description"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "youtube" = callPackage @@ -273837,6 +287393,7 @@ self: { ]; description = "A YQL engine to execute Open Data Tables"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "yst" = callPackage @@ -273859,6 +287416,8 @@ self: { ]; description = "Builds a static website from templates and data in YAML or CSV files"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ytl" = callPackage @@ -273887,6 +287446,7 @@ self: { testHaskellDepends = [ base MonadRandom random yu-utils ]; description = "Auth module for Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yu-core" = callPackage @@ -273899,6 +287459,7 @@ self: { testHaskellDepends = [ base blaze-markup hspec yu-utils ]; description = "The core of Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yu-launch" = callPackage @@ -273914,6 +287475,7 @@ self: { ]; description = "The launcher for Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yu-tool" = callPackage @@ -273931,6 +287493,7 @@ self: { ]; description = "Tool for Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yu-utils" = callPackage @@ -273954,6 +287517,7 @@ self: { ]; description = "Utils for Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yuiGrid" = callPackage @@ -273989,6 +287553,7 @@ self: { ]; description = "A transcendental HTML parser gently wrapping the HXT library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yx" = callPackage @@ -274039,6 +287604,8 @@ self: { ]; description = "Utilities for reading and writing Alteryx .yxdb files"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "z3" = callPackage @@ -274068,6 +287635,8 @@ self: { testHaskellDepends = [ base containers hspec z3 ]; description = "High-level assertion encoding to Z3 solver"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "z85" = callPackage @@ -274091,6 +287660,8 @@ self: { ]; description = "Implementation of the z85 binary codec"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zabt" = callPackage @@ -274103,6 +287674,8 @@ self: { testHaskellDepends = [ base tasty tasty-hspec ]; description = "Simple-minded abstract binding trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zalgo" = callPackage @@ -274132,6 +287705,8 @@ self: { ]; description = "A tool for checking how much work is done on group projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zasni-gerna" = callPackage @@ -274143,6 +287718,7 @@ self: { libraryHaskellDepends = [ base papillon ]; description = "lojban parser (zasni gerna)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "zbar" = callPackage @@ -274250,6 +287826,8 @@ self: { ]; description = "Zendesk API for Haskell programming language"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zenhack-prelude" = callPackage @@ -274263,6 +287841,8 @@ self: { libraryHaskellDepends = [ base ]; description = "@zenhack's personal custom prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zeno" = callPackage @@ -274282,6 +287862,8 @@ self: { ]; description = "An automated proof system for Haskell programs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zeolite-lang" = callPackage @@ -274340,6 +287922,7 @@ self: { testToolDepends = [ purescript ]; description = "Zephyr, tree-shaking for the PureScript language"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "zero" = callPackage @@ -274372,6 +287955,7 @@ self: { ]; description = "Post to 0bin services"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zeromq-haskell" = callPackage @@ -274390,6 +287974,8 @@ self: { ]; description = "Bindings to ZeroMQ 2.1.x"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) zeromq;}; "zeromq3-conduit" = callPackage @@ -274406,6 +287992,7 @@ self: { ]; description = "Conduit bindings for zeromq3-haskell"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "zeromq3-haskell" = callPackage @@ -274428,6 +288015,7 @@ self: { ]; description = "Bindings to ZeroMQ 3.x"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) zeromq;}; "zeromq4-clone-pattern" = callPackage @@ -274472,6 +288060,8 @@ self: { testHaskellDepends = [ base ]; description = "Conduit wrapper around zeromq4-haskell"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zeromq4-haskell" = callPackage @@ -274554,6 +288144,7 @@ self: { ]; description = "ZeroTH - remove unnecessary TH dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "zettelkast" = callPackage @@ -274578,6 +288169,8 @@ self: { testHaskellDepends = [ base ]; description = "Command-line utility for working with zettelkast files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zifter" = callPackage @@ -274601,6 +288194,8 @@ self: { ]; description = "zifter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zifter-cabal" = callPackage @@ -274616,6 +288211,7 @@ self: { ]; description = "zifter-cabal"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zifter-git" = callPackage @@ -274627,6 +288223,7 @@ self: { libraryHaskellDepends = [ base path process zifter ]; description = "zifter-git"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zifter-google-java-format" = callPackage @@ -274642,6 +288239,7 @@ self: { ]; description = "zifter-google-java-format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zifter-hindent" = callPackage @@ -274657,6 +288255,7 @@ self: { ]; description = "zifter-hindent"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zifter-hlint" = callPackage @@ -274671,6 +288270,7 @@ self: { ]; description = "zifter-hlint"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zifter-stack" = callPackage @@ -274690,6 +288290,7 @@ self: { ]; description = "zifter-stack"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zigbee-znet25" = callPackage @@ -274706,6 +288307,8 @@ self: { testHaskellDepends = [ base bytestring mtl QuickCheck random ]; description = "XBee ZNet 2.5 (ZigBee) wireless modem communications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zim-parser" = callPackage @@ -274849,6 +288452,8 @@ self: { ]; description = "Working with zip archives via conduits"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zip-stream" = callPackage @@ -274885,6 +288490,8 @@ self: { libraryHaskellDepends = [ base directory mtl process ]; description = "Create simple list editor interfaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zipkin" = callPackage @@ -274900,6 +288507,8 @@ self: { ]; description = "Zipkin-style request tracing monad"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zipper" = callPackage @@ -274911,6 +288520,7 @@ self: { libraryHaskellDepends = [ base multirec ]; description = "Generic zipper for families of recursive datatypes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "zipper-extra" = callPackage @@ -274953,6 +288563,7 @@ self: { libraryHaskellDepends = [ base mtl yall ]; description = "A simple lens-based, generic, heterogenous, type-checked zipper library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ziptastic-client" = callPackage @@ -274974,6 +288585,7 @@ self: { ]; description = "A type-safe client for the Ziptastic API for doing forward and reverse geocoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ziptastic-core" = callPackage @@ -274993,6 +288605,8 @@ self: { ]; description = "Core Servant specification for the Ziptastic API for doing forward and reverse geocoding"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zlib" = callPackage @@ -275053,6 +288667,7 @@ self: { ]; description = "Enumerator interface for zlib compression"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zlib-lens" = callPackage @@ -275086,6 +288701,8 @@ self: { ]; description = "Language independent, reproducible, absolute types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zmcat" = callPackage @@ -275100,6 +288717,7 @@ self: { executableHaskellDepends = [ base bytestring ]; description = "Command-line tool for ZeroMQ"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "zmidi-core" = callPackage @@ -275128,6 +288746,8 @@ self: { ]; description = "Representing MIDI a simple score"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zmqat" = callPackage @@ -275157,6 +288777,8 @@ self: { libraryHaskellDepends = [ base time ]; description = "ZoneInfo library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zoom" = callPackage @@ -275175,6 +288797,8 @@ self: { ]; description = "A rake/thor-like task runner written in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zoom-cache" = callPackage @@ -275206,6 +288830,7 @@ self: { ]; description = "A streamable, seekable, zoomable cache file format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "zoom-cache-pcm" = callPackage @@ -275222,6 +288847,7 @@ self: { ]; description = "Library for zoom-cache PCM audio codecs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "zoom-cache-sndfile" = callPackage @@ -275241,6 +288867,7 @@ self: { ]; description = "Tools for generating zoom-cache-pcm files"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {}; "zoom-refs" = callPackage @@ -275252,6 +288879,8 @@ self: { libraryHaskellDepends = [ base lens stm ]; description = "Zoom (~ Functor) and pairing (~ Applicative) for mutable references"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zoovisitor" = callPackage @@ -275265,6 +288894,7 @@ self: { testHaskellDepends = [ base hspec ]; description = "A haskell binding to Apache Zookeeper C library(mt) using Haskell Z project"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) zookeeper_mt;}; "zot" = callPackage @@ -275330,6 +288960,8 @@ self: { ]; description = "Zero-Suppressed and Reduced Decision Diagrams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zsh-battery" = callPackage @@ -275343,6 +288975,8 @@ self: { executableHaskellDepends = [ base directory filepath mtl ]; description = "Ascii bars representing battery status"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zstd" = callPackage @@ -275377,6 +289011,8 @@ self: { testHaskellDepends = [ base containers mtl multiset ]; description = "Automated theorem prover for the Zsyntax biochemical calculus"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ztail" = callPackage @@ -275418,6 +289054,8 @@ self: { ]; description = "Creating and extracting arbitrary archives"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zuramaru" = callPackage @@ -275456,6 +289094,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "A lisp processor, An inline-lisp, in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "zuul" = callPackage @@ -275508,6 +289147,8 @@ self: { ]; description = "Password strength estimation based on zxcvbn"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zxcvbn-hs" = callPackage From 7ae5e45f9a9c5f3f25f3dbc8aa7212210d6d409f Mon Sep 17 00:00:00 2001 From: Dmitry Ivankov Date: Sat, 8 May 2021 18:37:10 +0200 Subject: [PATCH 073/163] haskellPackages.Frames-streamly: fix build - use relude_1_0_0_1 to satisfy bounds - add missing file example_data/acs100k.csv [upstream issue](https://github.com/adamConnerSax/Frames-streamly/issues/1) https://hydra.nixos.org/build/142525099/nixlog/1 ZHF: #122042 --- .../development/haskell-modules/configuration-common.nix | 9 +++++++++ .../configuration-hackage2nix/broken.yaml | 1 - 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 0f2aa45b4bc..4c93e6fa77a 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1870,4 +1870,13 @@ self: super: { ShellCheck = self.ShellCheck_0_7_1; }; + Frames-streamly = overrideCabal (super.Frames-streamly.override { relude = super.relude_1_0_0_1; }) (drv: { + # https://github.com/adamConnerSax/Frames-streamly/issues/1 + patchPhase = '' +cat > example_data/acs100k.csv < Date: Sun, 9 May 2021 16:41:36 +0200 Subject: [PATCH 074/163] haskell.packages.ghcHEAD: use llvm 10 As per GHC's documentation: https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/backends/llvm/installing#llvm-support This configuration file is probably outdated in major other ways. We should most likely copy over stuff from the GHC 9.0.x config file and adjust new specifics, but I don't have the time at the moment. --- pkgs/development/haskell-modules/configuration-ghc-head.nix | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-ghc-head.nix b/pkgs/development/haskell-modules/configuration-ghc-head.nix index cbfd4b84b2f..2b136c6bf83 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-head.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-head.nix @@ -11,8 +11,7 @@ with haskellLib; self: super: { - # This compiler version needs llvm 6.x. - llvmPackages = pkgs.llvmPackages_6; + llvmPackages = pkgs.llvmPackages_10; # Disable GHC 8.7.x core libraries. array = null; From 6b491e513bf6bcfe723ded1a27248503e00113b1 Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Sun, 9 May 2021 23:25:09 +0200 Subject: [PATCH 075/163] haskellPackages.large-hashable: unbreak Compilation failures are related to GHC updates and other issues which have been resolved on the package's development repository, but not yet released. Fetching two patches resolves the problems which is probably a midterm solution since the repository hasn't seen any activity this year yet. --- .../haskell-modules/configuration-common.nix | 19 +++++++++++++++++++ .../configuration-hackage2nix/broken.yaml | 1 - .../configuration-hackage2nix/main.yaml | 1 + .../haskell-modules/hackage-packages.nix | 5 +---- 4 files changed, 21 insertions(+), 5 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 4c93e6fa77a..7cad4d339f4 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1879,4 +1879,23 @@ cat > example_data/acs100k.csv <= 8.8 + (pkgs.fetchpatch { + url = "https://github.com/factisresearch/large-hashable/commit/ee7afe4bd181cf15a324c7f4823f7a348e4a0e6b.patch"; + sha256 = "1ha77v0bc6prxacxhpdfgcsgw8348gvhl9y81smigifgjbinphxv"; + excludes = [ + ".travis.yml" + "stack**" + ]; + }) + # Fix cpp invocation + (pkgs.fetchpatch { + url = "https://github.com/factisresearch/large-hashable/commit/7b7c2ed6ac6e096478e8ee00160fa9d220df853a.patch"; + sha256 = "1sf9h3k8jbbgfshzrclaawlwx7k2frb09z2a64f93jhvk6ci6vgx"; + }) + ]; + } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index f59c6a2f340..803bea92a18 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -2600,7 +2600,6 @@ broken-packages: - language-vhdl - language-webidl - lapack-ffi - - large-hashable - Lastik - latest-npm-version - latex-formulae-image diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 7019f200999..e8d904052cd 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -220,6 +220,7 @@ package-maintainers: - gitit - yarn-lock - yarn2nix + - large-hashable poscat: - hinit bdesham: diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index a7f5d975a6c..23ac0354ddf 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -6447,8 +6447,6 @@ self: { ]; description = "A streamly layer for Frames I/O"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "Frank" = callPackage @@ -158217,8 +158215,7 @@ self: { ]; description = "Efficiently hash (large) Haskell values"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; + maintainers = with lib.maintainers; [ sternenseemann ]; }) {}; "largeword" = callPackage From e9a31d983b1d3881a47a9f3e6a01000358c794e2 Mon Sep 17 00:00:00 2001 From: Tom Sydney Kerckhove Date: Mon, 10 May 2021 10:23:27 +0200 Subject: [PATCH 076/163] haskellPackages.bson: unbreak Co-authored-by: sterni --- pkgs/development/haskell-modules/configuration-common.nix | 6 ++++++ .../haskell-modules/configuration-hackage2nix/broken.yaml | 1 - pkgs/development/haskell-modules/hackage-packages.nix | 2 -- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 7cad4d339f4..f50f09ab629 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1898,4 +1898,10 @@ EOT }) ]; + # BSON defaults to requiring network instead of network-bsd which is + # required nowadays: https://github.com/mongodb-haskell/bson/issues/26 + bson = appendConfigureFlag (super.bson.override { + network = self.network-bsd; + }) "-f-_old_network"; + } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 803bea92a18..d462477e87d 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -426,7 +426,6 @@ broken-packages: - brotli - browscap - bsd-sysctl - - bson - bsparse - btree-concurrent - buffer diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 23ac0354ddf..1fe4f0c6c04 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -45847,8 +45847,6 @@ self: { ]; description = "BSON documents are JSON-like objects with a standard binary encoding"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "bson-generic" = callPackage From 62bbd50331279335a6dd289101c0026681fb7521 Mon Sep 17 00:00:00 2001 From: sternenseemann <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Mon, 10 May 2021 13:39:49 +0200 Subject: [PATCH 077/163] haskellPackages.large-hashable: mark as broken on aarch64 See linked issue. --- pkgs/development/haskell-modules/configuration-arm.nix | 3 +++ 1 file changed, 3 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-arm.nix b/pkgs/development/haskell-modules/configuration-arm.nix index af4893afe54..233d962d365 100644 --- a/pkgs/development/haskell-modules/configuration-arm.nix +++ b/pkgs/development/haskell-modules/configuration-arm.nix @@ -66,6 +66,9 @@ self: super: { # https://github.com/ekmett/half/issues/35 half = dontCheck super.half; + # https://github.com/factisresearch/large-hashable/issues/17 + large-hashable = markBroken super.large-hashable; + } // lib.optionalAttrs pkgs.stdenv.hostPlatform.isAarch32 { # AARCH32-SPECIFIC OVERRIDES From 91be397a437fe84832330f94e916cf81656c171c Mon Sep 17 00:00:00 2001 From: misuzu Date: Mon, 10 May 2021 16:04:03 +0300 Subject: [PATCH 078/163] sofia_sip: fix darwin build --- pkgs/development/libraries/sofia-sip/default.nix | 6 +++--- pkgs/top-level/all-packages.nix | 4 +++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/pkgs/development/libraries/sofia-sip/default.nix b/pkgs/development/libraries/sofia-sip/default.nix index 593bd87a982..c9db54fd59c 100644 --- a/pkgs/development/libraries/sofia-sip/default.nix +++ b/pkgs/development/libraries/sofia-sip/default.nix @@ -1,4 +1,4 @@ -{ lib, stdenv, fetchFromGitHub, glib, openssl, pkg-config, autoreconfHook }: +{ lib, stdenv, fetchFromGitHub, glib, openssl, pkg-config, autoreconfHook, SystemConfiguration }: stdenv.mkDerivation rec { pname = "sofia-sip"; @@ -11,13 +11,13 @@ stdenv.mkDerivation rec { sha256 = "sha256-qMgZpLo/BHGJbJ0DDN8COHAhU3ujWgVK9oZOnnMwKas="; }; - buildInputs = [ glib openssl ]; + buildInputs = [ glib openssl ] ++ lib.optional stdenv.isDarwin SystemConfiguration; nativeBuildInputs = [ autoreconfHook pkg-config ]; meta = with lib; { description = "Open-source SIP User-Agent library, compliant with the IETF RFC3261 specification"; homepage = "https://github.com/freeswitch/sofia-sip"; - platforms = platforms.linux; + platforms = platforms.unix; license = licenses.lgpl2; }; } diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index d8e77bcf6d4..989efa60160 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -17593,7 +17593,9 @@ in socket_wrapper = callPackage ../development/libraries/socket_wrapper { }; - sofia_sip = callPackage ../development/libraries/sofia-sip { }; + sofia_sip = callPackage ../development/libraries/sofia-sip { + inherit (darwin.apple_sdk.frameworks) SystemConfiguration; + }; soil = callPackage ../development/libraries/soil { inherit (darwin.apple_sdk.frameworks) Carbon; From 0aa521e3a00e6954f6b66ad1ace829691efd5164 Mon Sep 17 00:00:00 2001 From: Cyril Cohen Date: Mon, 10 May 2021 15:30:05 +0200 Subject: [PATCH 079/163] coqPackages.mathcomp-zify: init at 1.0.0+1.12+8.13 --- .../coq-modules/mathcomp-zify/default.nix | 22 +++++++++++++++++++ pkgs/top-level/coq-packages.nix | 1 + 2 files changed, 23 insertions(+) create mode 100644 pkgs/development/coq-modules/mathcomp-zify/default.nix diff --git a/pkgs/development/coq-modules/mathcomp-zify/default.nix b/pkgs/development/coq-modules/mathcomp-zify/default.nix new file mode 100644 index 00000000000..65af999d08f --- /dev/null +++ b/pkgs/development/coq-modules/mathcomp-zify/default.nix @@ -0,0 +1,22 @@ +{ lib, mkCoqDerivation, coq, mathcomp-algebra, version ? null }: + +with lib; mkCoqDerivation rec { + pname = "mathcomp-zify"; + repo = "mczify"; + owner = "math-comp"; + inherit version; + + defaultVersion = with versions; + switch [ coq.coq-version mathcomp-algebra.version ] [ + { cases = [ (isEq "8.13") (isEq "1.12") ]; out = "1.0.0+1.12+8.13"; } + ] null; + + release."1.0.0+1.12+8.13".sha256 = "1j533vx6lacr89bj1bf15l1a0s7rvrx4l00wyjv99aczkfbz6h6k"; + + propagatedBuildInputs = [ mathcomp-algebra ]; + + meta = { + description = "Micromega tactics for Mathematical Components"; + maintainers = with maintainers; [ cohencyril ]; + }; +} diff --git a/pkgs/top-level/coq-packages.nix b/pkgs/top-level/coq-packages.nix index 9884553c9e0..2efd2c1849b 100644 --- a/pkgs/top-level/coq-packages.nix +++ b/pkgs/top-level/coq-packages.nix @@ -60,6 +60,7 @@ let mathcomp-finmap = callPackage ../development/coq-modules/mathcomp-finmap {}; mathcomp-bigenough = callPackage ../development/coq-modules/mathcomp-bigenough {}; mathcomp-real-closed = callPackage ../development/coq-modules/mathcomp-real-closed {}; + mathcomp-zify = callPackage ../development/coq-modules/mathcomp-zify {}; metalib = callPackage ../development/coq-modules/metalib { }; multinomials = callPackage ../development/coq-modules/multinomials {}; odd-order = callPackage ../development/coq-modules/odd-order { }; From 021813a495894c4b560251791ec675e94b600036 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Mon, 10 May 2021 22:01:49 +0800 Subject: [PATCH 080/163] vimPlugins: update --- pkgs/misc/vim-plugins/generated.nix | 62 +++++++++++++++++------------ 1 file changed, 37 insertions(+), 25 deletions(-) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index 8e327273502..62307010d61 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -461,12 +461,12 @@ let coc-clap = buildVimPluginFrom2Nix { pname = "coc-clap"; - version = "2021-03-04"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "vn-ki"; repo = "coc-clap"; - rev = "57116d2f999dfa025fac579835fd23e1a6341fa2"; - sha256 = "0m2khf11krkqmbykfx21yq9ydglz6dldw4xml5nkyqm93n37xn1s"; + rev = "8622be2674f3197bec8a0c4cfd177eb8455f45e6"; + sha256 = "063azqsibg25iv2c9smn4k6933frrwarqz640b14c041sgi6h8cx"; }; meta.homepage = "https://github.com/vn-ki/coc-clap/"; }; @@ -537,8 +537,8 @@ let src = fetchFromGitHub { owner = "neoclide"; repo = "coc.nvim"; - rev = "a3966628cb090ed9a102e7b9c78f9fb90abffd21"; - sha256 = "1pa28arwyfgvf6c1vbcqnlwiz54lqlw8lqv89nz8880wpmwr3njk"; + rev = "6cc7432fa00d8a7351cee54f7b800e992057315a"; + sha256 = "048mvb82ni7m3ch5i32q54qnsh3rl28yw1q7fcsapklnknaaq3qh"; }; meta.homepage = "https://github.com/neoclide/coc.nvim/"; }; @@ -1172,12 +1172,12 @@ let deoplete-nvim = buildVimPluginFrom2Nix { pname = "deoplete-nvim"; - version = "2021-05-02"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "Shougo"; repo = "deoplete.nvim"; - rev = "9d8f0dfc9e0a2f60b42e9d7b96eb485087c0178d"; - sha256 = "17nq09731rcgccasximg3qknvfzi0ca9lsrwvhjbzc5wagwrribq"; + rev = "4e7a08aaa7827184bd492f19aa38fc67aac0f0c8"; + sha256 = "00b0v1wk4wccd4c5xkqn0yvilp3z14r66983kyblpivqfdwy9gs5"; }; meta.homepage = "https://github.com/Shougo/deoplete.nvim/"; }; @@ -1775,12 +1775,12 @@ let gruvbox-nvim = buildVimPluginFrom2Nix { pname = "gruvbox-nvim"; - version = "2021-05-05"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "npxbr"; repo = "gruvbox.nvim"; - rev = "9e0e0a00360c87c76d293464430662dbdf298d99"; - sha256 = "0d0yrqh4rw1ijslvip2h3c6kmpzfza9iw3dizgjl2kbl8jx958a1"; + rev = "c26c456a6b36cac79e01f6cf7eebb8cc9231ab16"; + sha256 = "0kpgkdwkz27xl56yicf8b8zhqg84657s14xl0blh802cm275hz92"; }; meta.homepage = "https://github.com/npxbr/gruvbox.nvim/"; }; @@ -1845,6 +1845,18 @@ let meta.homepage = "https://github.com/mpickering/hlint-refactor-vim/"; }; + hologram-nvim = buildVimPluginFrom2Nix { + pname = "hologram-nvim"; + version = "2021-05-01"; + src = fetchFromGitHub { + owner = "edluffy"; + repo = "hologram.nvim"; + rev = "31108af1a9a4fc842656c6a319ce3decc3baf8e8"; + sha256 = "0kgbcggx5kr0h95f2gwpfr1h3wbv73pis8dkmjgmr6gpj70zsk7v"; + }; + meta.homepage = "https://github.com/edluffy/hologram.nvim/"; + }; + hoon-vim = buildVimPluginFrom2Nix { pname = "hoon-vim"; version = "2020-11-09"; @@ -2208,12 +2220,12 @@ let lazygit-nvim = buildVimPluginFrom2Nix { pname = "lazygit-nvim"; - version = "2021-03-25"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "kdheepak"; repo = "lazygit.nvim"; - rev = "fb5ab7d26ac414a7e7bfff6b89f69e2dd2fd3884"; - sha256 = "1nn6zhjqfk88jmavl9y8li4y08v3wb2m2kskq9yf36hadw29im30"; + rev = "acc383d1eab516318816f43e3e380fead8249acb"; + sha256 = "0w777was4z7yk3z6fn55phqzxmsbzbz0v4959h52yi91pdbb4qfc"; }; meta.homepage = "https://github.com/kdheepak/lazygit.nvim/"; }; @@ -3160,8 +3172,8 @@ let src = fetchFromGitHub { owner = "kevinhwang91"; repo = "nvim-bqf"; - rev = "ac3b0f70843840918389191f575f2404cad3304f"; - sha256 = "0jxj9v8sxnmvvirwzj171dd43w2kg6g3dri1pya20x8plka8rgs6"; + rev = "ffbad27affde968cff2db0af9654431377fee8c7"; + sha256 = "0vlismqzm24h24shc0m49qvxyv03mnd68ahzlwa314ybvs2s10wj"; }; meta.homepage = "https://github.com/kevinhwang91/nvim-bqf/"; }; @@ -4021,12 +4033,12 @@ let rust-tools-nvim = buildVimPluginFrom2Nix { pname = "rust-tools-nvim"; - version = "2021-05-06"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "simrat39"; repo = "rust-tools.nvim"; - rev = "2e615d4a039d2fc580479a5e512330527d151d3f"; - sha256 = "0hc0iv5p3ys98w8sv4569jh5x20vqqyysgff5nrgysl0amw6rgwd"; + rev = "2de94fc88d6382e5f0b61f1c619c8919fd45aea3"; + sha256 = "14fg0qs1y2xszpdsnp8gcynqj9fx5c47ckbpgr48hv5df8xncasf"; }; meta.homepage = "https://github.com/simrat39/rust-tools.nvim/"; }; @@ -6292,12 +6304,12 @@ let vim-grepper = buildVimPluginFrom2Nix { pname = "vim-grepper"; - version = "2020-07-12"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "mhinz"; repo = "vim-grepper"; - rev = "e9004ce564891412cfe433cfbb97295cccd06b39"; - sha256 = "1cs72x3wv4i11x7ch3gna1sxqn5zj3bd34smchfd00g4mf201lhs"; + rev = "b80004c050501122d58f82712b21d0b7c8dfc019"; + sha256 = "049552dvsk14hx4h9rp9g65xkf13n42z304lzxca69j5q6k1qrdl"; }; meta.homepage = "https://github.com/mhinz/vim-grepper/"; }; @@ -9081,12 +9093,12 @@ let wildfire-vim = buildVimPluginFrom2Nix { pname = "wildfire-vim"; - version = "2021-05-09"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "gcmt"; repo = "wildfire.vim"; - rev = "2f6b7d7861cc4c9ff95338f150159e1ccee64d82"; - sha256 = "1ppc7pqy7wbaac0cd9ng5hil1f7argsd5dvg3896z5iqpf5xhmrl"; + rev = "fa91b732fd1c5acd23b7b32d5fbbc884eedafc8d"; + sha256 = "15gikqmpaf5c6687kgc5ib57pw7gyvxaihdv5549s7p2xkkbcl24"; }; meta.homepage = "https://github.com/gcmt/wildfire.vim/"; }; From 21cc6fe587827ec499f128c992ffda393dc07b50 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Mon, 10 May 2021 22:09:25 +0800 Subject: [PATCH 081/163] vimPlugins.hologram-nvim: init at 2021-05-01 --- pkgs/misc/vim-plugins/vim-plugin-names | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/misc/vim-plugins/vim-plugin-names b/pkgs/misc/vim-plugins/vim-plugin-names index c1a880959a7..1b172a92f34 100644 --- a/pkgs/misc/vim-plugins/vim-plugin-names +++ b/pkgs/misc/vim-plugins/vim-plugin-names @@ -106,6 +106,7 @@ eagletmt/ghcmod-vim eagletmt/neco-ghc easymotion/vim-easymotion editorconfig/editorconfig-vim +edluffy/hologram.nvim@main edwinb/idris2-vim ehamberg/vim-cute-python eigenfoo/stan-vim From 9bf3ecbe66d1dd15c1afb3313436944f63a916e4 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Mon, 10 May 2021 22:11:05 +0800 Subject: [PATCH 082/163] vimPlugins.specs-nvim: init at 2021-05-05 --- pkgs/misc/vim-plugins/generated.nix | 12 ++++++++++++ pkgs/misc/vim-plugins/vim-plugin-names | 1 + 2 files changed, 13 insertions(+) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index 62307010d61..b3805d4cfc8 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -4283,6 +4283,18 @@ let meta.homepage = "https://github.com/chrisgeo/sparkup/"; }; + specs-nvim = buildVimPluginFrom2Nix { + pname = "specs-nvim"; + version = "2021-05-05"; + src = fetchFromGitHub { + owner = "edluffy"; + repo = "specs.nvim"; + rev = "a62319a224b73b70af47a48ba076d7ec67b08526"; + sha256 = "1hs7qp3fr451ziddv08nyygnxx1n6y32fr0y97s9zjc7j13d3nc3"; + }; + meta.homepage = "https://github.com/edluffy/specs.nvim/"; + }; + splice-vim = buildVimPluginFrom2Nix { pname = "splice-vim"; version = "2020-01-15"; diff --git a/pkgs/misc/vim-plugins/vim-plugin-names b/pkgs/misc/vim-plugins/vim-plugin-names index 1b172a92f34..c647a6bfd5c 100644 --- a/pkgs/misc/vim-plugins/vim-plugin-names +++ b/pkgs/misc/vim-plugins/vim-plugin-names @@ -107,6 +107,7 @@ eagletmt/neco-ghc easymotion/vim-easymotion editorconfig/editorconfig-vim edluffy/hologram.nvim@main +edluffy/specs.nvim@main edwinb/idris2-vim ehamberg/vim-cute-python eigenfoo/stan-vim From 653fa52a0cab2b8f716c1db4c02c3d96296be314 Mon Sep 17 00:00:00 2001 From: Sascha Grunert Date: Mon, 10 May 2021 16:46:39 +0200 Subject: [PATCH 083/163] runc: 1.0.0-rc93 -> 1.0.0-rc94 Signed-off-by: Sascha Grunert --- pkgs/applications/virtualization/runc/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/virtualization/runc/default.nix b/pkgs/applications/virtualization/runc/default.nix index 152cbf6199b..1f720d58f51 100644 --- a/pkgs/applications/virtualization/runc/default.nix +++ b/pkgs/applications/virtualization/runc/default.nix @@ -16,13 +16,13 @@ buildGoPackage rec { pname = "runc"; - version = "1.0.0-rc93"; + version = "1.0.0-rc94"; src = fetchFromGitHub { owner = "opencontainers"; repo = "runc"; rev = "v${version}"; - sha256 = "008d5wkznic80n5q1vwx727qn5ifalc7cydq68hc1gk9wrhna4v4"; + sha256 = "sha256-53P48jNSfC6ELpZNI30yAf7kofUsrJpNY96u0UT+ITg="; }; goPackagePath = "github.com/opencontainers/runc"; From 0cfa5cc54f43ccec1a6e62865c7f429b9a0f6374 Mon Sep 17 00:00:00 2001 From: Guillaume Girol Date: Mon, 10 May 2021 14:49:33 +0000 Subject: [PATCH 084/163] pdfpc: fix build by using older vala (#122372) --- pkgs/top-level/all-packages.nix | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index e59e1caeee3..63ed9cf041b 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -25427,6 +25427,8 @@ in pdfgrep = callPackage ../tools/typesetting/pdfgrep { }; pdfpc = callPackage ../applications/misc/pdfpc { + # https://github.com/pdfpc/pdfpc/issues/594 + vala = vala_0_50; inherit (gst_all_1) gstreamer gst-plugins-base gst-plugins-good gst-libav; }; From d515fcf049c00b51bb181a7058b4cb63636469a5 Mon Sep 17 00:00:00 2001 From: Martin Weinelt Date: Mon, 10 May 2021 17:37:30 +0200 Subject: [PATCH 085/163] Revert "python3Packages.pyjwt: disable failing test for 1.7.1" This reverts commit b56bd9afccf63152eb59f891863458049aa4a8e3. --- pkgs/development/python-modules/pyjwt/default.nix | 5 ----- 1 file changed, 5 deletions(-) diff --git a/pkgs/development/python-modules/pyjwt/default.nix b/pkgs/development/python-modules/pyjwt/default.nix index 104dadbd396..4617869988f 100644 --- a/pkgs/development/python-modules/pyjwt/default.nix +++ b/pkgs/development/python-modules/pyjwt/default.nix @@ -29,11 +29,6 @@ buildPythonPackage rec { pytestCheckHook ]; - disabledTests = lib.optionals (lib.versionOlder version "2.0") [ - # ecdsa changed internal behavior, required if one does 1.7.1 overriding - "ec_verify_should_return_false_if_signature_invalid" - ]; - pythonImportsCheck = [ "jwt" ]; meta = with lib; { From b70ae7c2788b5816f516c6515792d5767046ac52 Mon Sep 17 00:00:00 2001 From: Martin Weinelt Date: Mon, 10 May 2021 17:50:08 +0200 Subject: [PATCH 086/163] home-assistant: fix build by disabling test in pyjwt override FAILED tests/contrib/test_algorithms.py::TestEcdsaAlgorithms::test_ec_verify_should_return_false_if_signature_invalid --- pkgs/servers/home-assistant/default.nix | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index f535477827c..22b61c09334 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -38,8 +38,17 @@ let }) # Pinned due to API changes in pyjwt>=2.0 - (mkOverride "pyjwt" "1.7.1" - "15hflax5qkw1v6nssk1r0wkj83jgghskcmn875m3wgvpzdvajncd") + (self: super: { + pyjwt = super.pyjwt.overridePythonAttrs (oldAttrs: rec { + version = "1.7.1"; + src = oldAttrs.src.override { + sha256 = "15hflax5qkw1v6nssk1r0wkj83jgghskcmn875m3wgvpzdvajncd"; + }; + disabledTests = [ + "test_ec_verify_should_return_false_if_signature_invalid" + ]; + }); + }) # Pinned due to bug in ring-doorbell 0.7.0 # https://github.com/tchellomello/python-ring-doorbell/issues/240 From 8f7b450a0de635e58b976169e1b0a524fc8c4faf Mon Sep 17 00:00:00 2001 From: Stig Palmquist Date: Mon, 10 May 2021 17:53:19 +0200 Subject: [PATCH 087/163] perlPackages.MojoliciousPluginSyslog: init at 0.04 --- pkgs/top-level/perl-packages.nix | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/pkgs/top-level/perl-packages.nix b/pkgs/top-level/perl-packages.nix index 10a6de27deb..3c9a2791770 100644 --- a/pkgs/top-level/perl-packages.nix +++ b/pkgs/top-level/perl-packages.nix @@ -13769,6 +13769,22 @@ let }; }; + MojoliciousPluginSyslog = buildPerlPackage { + pname = "Mojolicious-Plugin-Syslog"; + version = "0.04"; + src = fetchurl { + url = "mirror://cpan/authors/id/J/JH/JHTHORSEN/Mojolicious-Plugin-Syslog-0.04.tar.gz"; + sha256 = "807d06b88304675a2bb9181bab123a0e16d3cf2f6a5753a168090ed88085a492"; + }; + propagatedBuildInputs = [ Mojolicious ]; + meta = { + homepage = "https://github.com/jhthorsen/mojolicious-plugin-syslog"; + description = "A plugin for enabling a Mojolicious app to log to syslog"; + license = lib.licenses.artistic2; + maintainers = [ maintainers.sgo ]; + }; + }; + MojoliciousPluginTextExceptions = buildPerlPackage { pname = "Mojolicious-Plugin-TextExceptions"; version = "0.02"; From 3fde66cd0cccfcd02ca6a9d205477ec3bf4da32e Mon Sep 17 00:00:00 2001 From: Michael Raskin <7c6f434c@mail.ru> Date: Mon, 10 May 2021 18:10:49 +0200 Subject: [PATCH 088/163] lispPackages.quicklisp: distinfo 2021-02-28 -> 2021-04-11, quicklispPackages: regenerate, lispPackages.nyxt: 2021-03-27 -> 2021-05-06, use upstream Makefile --- .../lisp-modules/lisp-packages.nix | 22 +++++++++---- .../_3bmd-ext-code-blocks.nix | 14 ++++---- .../quicklisp-to-nix-output/_3bmd.nix | 14 ++++---- .../quicklisp-to-nix-output/alexandria.nix | 14 ++++---- .../quicklisp-to-nix-output/cffi-grovel.nix | 14 ++++---- .../cffi-toolchain.nix | 14 ++++---- .../cffi-uffi-compat.nix | 14 ++++---- .../quicklisp-to-nix-output/cffi.nix | 14 ++++---- .../quicklisp-to-nix-output/chanl.nix | 14 ++++---- .../cl-change-case.nix | 14 ++++---- .../quicklisp-to-nix-output/cl-colors2.nix | 14 ++++---- .../cl-gobject-introspection.nix | 32 +++++++++++++++++++ .../quicklisp-to-nix-output/cl-postgres.nix | 14 ++++---- .../cl-typesetting.nix | 14 ++++---- .../quicklisp-to-nix-output/cl-webkit2.nix | 14 ++++---- .../quicklisp-to-nix-output/cl_plus_ssl.nix | 14 ++++---- .../clack-handler-hunchentoot.nix | 14 ++++---- .../quicklisp-to-nix-output/clack-socket.nix | 14 ++++---- .../quicklisp-to-nix-output/clack-test.nix | 14 ++++---- .../clack-v1-compat.nix | 14 ++++---- .../quicklisp-to-nix-output/clack.nix | 22 +++++++------ .../quicklisp-to-nix-output/closer-mop.nix | 14 ++++---- .../quicklisp-to-nix-output/dexador.nix | 14 ++++---- .../file-attributes.nix | 14 ++++---- .../quicklisp-to-nix-output/ironclad.nix | 14 ++++---- .../quicklisp-to-nix-output/marshal.nix | 14 ++++---- .../quicklisp-to-nix-output/mgl-pax.nix | 14 ++++---- .../quicklisp-to-nix-output/plump.nix | 14 ++++---- .../quicklisp-to-nix-output/postmodern.nix | 14 ++++---- .../quicklisp-to-nix-output/quri.nix | 14 ++++---- .../quicklisp-to-nix-output/s-sql.nix | 14 ++++---- .../quicklisp-to-nix-output/serapeum.nix | 14 ++++---- .../quicklisp-to-nix-output/simple-date.nix | 14 ++++---- .../quicklisp-to-nix-output/str.nix | 14 ++++---- .../quicklisp-to-nix-output/stumpwm.nix | 14 ++++---- .../quicklisp-to-nix-output/trivia.nix | 14 ++++---- .../trivia_dot_balland2006.nix | 14 ++++---- .../trivia_dot_level0.nix | 14 ++++---- .../trivia_dot_level1.nix | 14 ++++---- .../trivia_dot_level2.nix | 14 ++++---- .../trivia_dot_quasiquote.nix | 14 ++++---- .../trivia_dot_trivial.nix | 14 ++++---- .../trivial-features.nix | 14 ++++---- .../utilities_dot_print-items.nix | 14 ++++---- .../quicklisp-to-nix-overrides.nix | 1 + .../lisp-modules/quicklisp-to-nix-systems.txt | 1 + .../lisp-modules/quicklisp-to-nix.nix | 16 ++++++++++ pkgs/development/lisp-modules/shell.nix | 2 +- 48 files changed, 366 insertions(+), 304 deletions(-) create mode 100644 pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-gobject-introspection.nix diff --git a/pkgs/development/lisp-modules/lisp-packages.nix b/pkgs/development/lisp-modules/lisp-packages.nix index 927254f52ae..82a86404ca5 100644 --- a/pkgs/development/lisp-modules/lisp-packages.nix +++ b/pkgs/development/lisp-modules/lisp-packages.nix @@ -24,8 +24,8 @@ let lispPackages = rec { quicklispdist = pkgs.fetchurl { # Will usually be replaced with a fresh version anyway, but needs to be # a valid distinfo.txt - url = "https://beta.quicklisp.org/dist/quicklisp/2021-02-28/distinfo.txt"; - sha256 = "sha256:1apc0s07fmm386rj866dbrhrkq3lrbgbd79kwcyp91ix7sza8z3z"; + url = "https://beta.quicklisp.org/dist/quicklisp/2021-04-11/distinfo.txt"; + sha256 = "sha256:1z7a7m9cm7iv4m9ajvyqphsw30s3qwb0l8g8ayfmkvmvhlj79g86"; }; buildPhase = "true; "; postInstall = '' @@ -124,7 +124,7 @@ let lispPackages = rec { }; nyxt = pkgs.lispPackages.buildLispPackage rec { baseName = "nyxt"; - version = "2021-03-27"; + version = "2021-05-06"; description = "Browser"; @@ -132,6 +132,14 @@ let lispPackages = rec { overrides = x: { postInstall = '' echo "Building nyxt binary" + ( + source "$out/lib/common-lisp-settings"/*-shell-config.sh + cd "$out/lib/common-lisp"/*/ + makeFlags="''${makeFlags:-}" + make LISP=common-lisp.sh NYXT_INTERNAL_QUICKLISP=false PREFIX="$out" $makeFlags all + make LISP=common-lisp.sh NYXT_INTERNAL_QUICKLISP=false PREFIX="$out" $makeFlags install + cp nyxt "$out/bin/nyxt" + ) NIX_LISP_PRELAUNCH_HOOK=' nix_lisp_build_system nyxt/gtk-application \ "(asdf/system:component-entry-point (asdf:find-system :nyxt/gtk-application))" \ @@ -181,13 +189,15 @@ let lispPackages = rec { fset cl-cffi-gtk cl-webkit2 + cl-gobject-introspection ]; src = pkgs.fetchFromGitHub { owner = "atlas-engineer"; repo = "nyxt"; - rev = "8ef171fd1eb62d168defe4a2d7115393230314d1"; - sha256 = "sha256:1dz55mdmj68kmllih7ab70nmp0mwzqp9lh3im7kcjfmc1r64irdv"; - # date = 2021-03-27T09:10:00+00:00; + rev = "940a5f9a19770771cf29f8fa7505e99c3a242b67"; + sha256 = "sha256:0d5mawka26gwi9nb45x1n33vgskwyn46jrvfz7nzmm2jfaq4ipn6"; + # Version 2 pre-release 7 + # date = "2021-05-06T11:30:27Z"; }; packageName = "nyxt"; diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd-ext-code-blocks.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd-ext-code-blocks.nix index 4fb5488b7a8..c8855a7f24b 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd-ext-code-blocks.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd-ext-code-blocks.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "_3bmd-ext-code-blocks"; - version = "3bmd-20201220-git"; + version = "3bmd-20210411-git"; description = "extension to 3bmd implementing github style ``` delimited code blocks, with support for syntax highlighting using colorize, pygments, or chroma"; deps = [ args."_3bmd" args."alexandria" args."colorize" args."esrap" args."html-encode" args."split-sequence" args."trivial-with-current-source-form" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/3bmd/2020-12-20/3bmd-20201220-git.tgz"; - sha256 = "0hcx8p8la3fmwhj8ddqik7bwrn9rvf5mcv6m77glimwckh51na71"; + url = "http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz"; + sha256 = "1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp"; }; packageName = "3bmd-ext-code-blocks"; @@ -20,9 +20,9 @@ rec { } /* (SYSTEM 3bmd-ext-code-blocks DESCRIPTION extension to 3bmd implementing github style ``` delimited code blocks, with support for syntax highlighting using colorize, pygments, or chroma - SHA256 0hcx8p8la3fmwhj8ddqik7bwrn9rvf5mcv6m77glimwckh51na71 URL - http://beta.quicklisp.org/archive/3bmd/2020-12-20/3bmd-20201220-git.tgz MD5 - 67b6e5fa51d18817e7110e4fef6517ac NAME 3bmd-ext-code-blocks FILENAME + SHA256 1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp URL + http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz MD5 + 09f9290aa1708aeb469fb5154ab1a397 NAME 3bmd-ext-code-blocks FILENAME _3bmd-ext-code-blocks DEPS ((NAME 3bmd FILENAME _3bmd) (NAME alexandria FILENAME alexandria) (NAME colorize FILENAME colorize) (NAME esrap FILENAME esrap) @@ -33,7 +33,7 @@ rec { DEPENDENCIES (3bmd alexandria colorize esrap html-encode split-sequence trivial-with-current-source-form) - VERSION 3bmd-20201220-git SIBLINGS + VERSION 3bmd-20210411-git SIBLINGS (3bmd-ext-definition-lists 3bmd-ext-math 3bmd-ext-tables 3bmd-ext-wiki-links 3bmd-youtube-tests 3bmd-youtube 3bmd) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd.nix index 8d8299a7030..630316bc857 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "_3bmd"; - version = "20201220-git"; + version = "20210411-git"; description = "markdown processor in CL using esrap parser."; deps = [ args."alexandria" args."esrap" args."split-sequence" args."trivial-with-current-source-form" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/3bmd/2020-12-20/3bmd-20201220-git.tgz"; - sha256 = "0hcx8p8la3fmwhj8ddqik7bwrn9rvf5mcv6m77glimwckh51na71"; + url = "http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz"; + sha256 = "1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp"; }; packageName = "3bmd"; @@ -19,16 +19,16 @@ rec { overrides = x: x; } /* (SYSTEM 3bmd DESCRIPTION markdown processor in CL using esrap parser. SHA256 - 0hcx8p8la3fmwhj8ddqik7bwrn9rvf5mcv6m77glimwckh51na71 URL - http://beta.quicklisp.org/archive/3bmd/2020-12-20/3bmd-20201220-git.tgz MD5 - 67b6e5fa51d18817e7110e4fef6517ac NAME 3bmd FILENAME _3bmd DEPS + 1gwl3r8cffr8yldi0x7zdzbmngqhli2d19wsky5cf8h80m30k4vp URL + http://beta.quicklisp.org/archive/3bmd/2021-04-11/3bmd-20210411-git.tgz MD5 + 09f9290aa1708aeb469fb5154ab1a397 NAME 3bmd FILENAME _3bmd DEPS ((NAME alexandria FILENAME alexandria) (NAME esrap FILENAME esrap) (NAME split-sequence FILENAME split-sequence) (NAME trivial-with-current-source-form FILENAME trivial-with-current-source-form)) DEPENDENCIES (alexandria esrap split-sequence trivial-with-current-source-form) VERSION - 20201220-git SIBLINGS + 20210411-git SIBLINGS (3bmd-ext-code-blocks 3bmd-ext-definition-lists 3bmd-ext-math 3bmd-ext-tables 3bmd-ext-wiki-links 3bmd-youtube-tests 3bmd-youtube) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/alexandria.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/alexandria.nix index f58416bffee..324831796ef 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/alexandria.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/alexandria.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "alexandria"; - version = "20200925-git"; + version = "20210411-git"; description = "Alexandria is a collection of portable public domain utilities."; deps = [ ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/alexandria/2020-09-25/alexandria-20200925-git.tgz"; - sha256 = "1cpvnzfs807ah07hrk8kplim6ryzqs4r35ym03cpky5xdl8c89fl"; + url = "http://beta.quicklisp.org/archive/alexandria/2021-04-11/alexandria-20210411-git.tgz"; + sha256 = "0bd4axr1z1q6khvpyf5xvgybdajs1dc7my6g0rdzhhxbibfcf3yh"; }; packageName = "alexandria"; @@ -20,8 +20,8 @@ rec { } /* (SYSTEM alexandria DESCRIPTION Alexandria is a collection of portable public domain utilities. SHA256 - 1cpvnzfs807ah07hrk8kplim6ryzqs4r35ym03cpky5xdl8c89fl URL - http://beta.quicklisp.org/archive/alexandria/2020-09-25/alexandria-20200925-git.tgz - MD5 59c8237a854de6f4f93328cd5747cd14 NAME alexandria FILENAME alexandria - DEPS NIL DEPENDENCIES NIL VERSION 20200925-git SIBLINGS (alexandria-tests) + 0bd4axr1z1q6khvpyf5xvgybdajs1dc7my6g0rdzhhxbibfcf3yh URL + http://beta.quicklisp.org/archive/alexandria/2021-04-11/alexandria-20210411-git.tgz + MD5 415c43451862b490577b20ee4fb8e8d7 NAME alexandria FILENAME alexandria + DEPS NIL DEPENDENCIES NIL VERSION 20210411-git SIBLINGS (alexandria-tests) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-grovel.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-grovel.nix index f65c68e0d7f..b33f95934f8 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-grovel.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-grovel.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "cffi-grovel"; - version = "cffi_0.23.0"; + version = "cffi_0.24.1"; description = "The CFFI Groveller"; deps = [ args."alexandria" args."babel" args."cffi" args."cffi-toolchain" args."trivial-features" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz"; - sha256 = "1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck"; + url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz"; + sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh"; }; packageName = "cffi-grovel"; @@ -19,13 +19,13 @@ rec { overrides = x: x; } /* (SYSTEM cffi-grovel DESCRIPTION The CFFI Groveller SHA256 - 1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck URL - http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz MD5 - a43e3c440fc4f20494e6d2347887c963 NAME cffi-grovel FILENAME cffi-grovel DEPS + 1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL + http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5 + c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi-grovel FILENAME cffi-grovel DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME cffi FILENAME cffi) (NAME cffi-toolchain FILENAME cffi-toolchain) (NAME trivial-features FILENAME trivial-features)) DEPENDENCIES (alexandria babel cffi cffi-toolchain trivial-features) - VERSION cffi_0.23.0 SIBLINGS + VERSION cffi_0.24.1 SIBLINGS (cffi-examples cffi-libffi cffi-tests cffi-toolchain cffi-uffi-compat cffi) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-toolchain.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-toolchain.nix index af7c96639d6..b326d625f4d 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-toolchain.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-toolchain.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "cffi-toolchain"; - version = "cffi_0.23.0"; + version = "cffi_0.24.1"; description = "The CFFI toolchain"; deps = [ args."alexandria" args."babel" args."cffi" args."trivial-features" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz"; - sha256 = "1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck"; + url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz"; + sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh"; }; packageName = "cffi-toolchain"; @@ -19,14 +19,14 @@ rec { overrides = x: x; } /* (SYSTEM cffi-toolchain DESCRIPTION The CFFI toolchain SHA256 - 1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck URL - http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz MD5 - a43e3c440fc4f20494e6d2347887c963 NAME cffi-toolchain FILENAME + 1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL + http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5 + c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi-toolchain FILENAME cffi-toolchain DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME cffi FILENAME cffi) (NAME trivial-features FILENAME trivial-features)) - DEPENDENCIES (alexandria babel cffi trivial-features) VERSION cffi_0.23.0 + DEPENDENCIES (alexandria babel cffi trivial-features) VERSION cffi_0.24.1 SIBLINGS (cffi-examples cffi-grovel cffi-libffi cffi-tests cffi-uffi-compat cffi) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-uffi-compat.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-uffi-compat.nix index ec452750457..822b7a81166 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-uffi-compat.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-uffi-compat.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "cffi-uffi-compat"; - version = "cffi_0.23.0"; + version = "cffi_0.24.1"; description = "UFFI Compatibility Layer for CFFI"; deps = [ args."alexandria" args."babel" args."cffi" args."trivial-features" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz"; - sha256 = "1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck"; + url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz"; + sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh"; }; packageName = "cffi-uffi-compat"; @@ -19,14 +19,14 @@ rec { overrides = x: x; } /* (SYSTEM cffi-uffi-compat DESCRIPTION UFFI Compatibility Layer for CFFI - SHA256 1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck URL - http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz MD5 - a43e3c440fc4f20494e6d2347887c963 NAME cffi-uffi-compat FILENAME + SHA256 1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL + http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5 + c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi-uffi-compat FILENAME cffi-uffi-compat DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME cffi FILENAME cffi) (NAME trivial-features FILENAME trivial-features)) - DEPENDENCIES (alexandria babel cffi trivial-features) VERSION cffi_0.23.0 + DEPENDENCIES (alexandria babel cffi trivial-features) VERSION cffi_0.24.1 SIBLINGS (cffi-examples cffi-grovel cffi-libffi cffi-tests cffi-toolchain cffi) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi.nix index 103f233fa41..0738ea5909f 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "cffi"; - version = "cffi_0.23.0"; + version = "cffi_0.24.1"; parasites = [ "cffi/c2ffi" "cffi/c2ffi-generator" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."babel" args."cl-json" args."cl-ppcre" args."trivial-features" args."uiop" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz"; - sha256 = "1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck"; + url = "http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz"; + sha256 = "1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh"; }; packageName = "cffi"; @@ -21,15 +21,15 @@ rec { overrides = x: x; } /* (SYSTEM cffi DESCRIPTION The Common Foreign Function Interface SHA256 - 1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck URL - http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz MD5 - a43e3c440fc4f20494e6d2347887c963 NAME cffi FILENAME cffi DEPS + 1ir8a4rrnilj9f8rv1hh6fhkg2wp8z8zcf9hiijcix50pabxq8qh URL + http://beta.quicklisp.org/archive/cffi/2021-04-11/cffi_0.24.1.tgz MD5 + c3df5c460e00e5af8b8bd2cd03a4b5cc NAME cffi FILENAME cffi DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME cl-json FILENAME cl-json) (NAME cl-ppcre FILENAME cl-ppcre) (NAME trivial-features FILENAME trivial-features) (NAME uiop FILENAME uiop)) DEPENDENCIES (alexandria babel cl-json cl-ppcre trivial-features uiop) - VERSION cffi_0.23.0 SIBLINGS + VERSION cffi_0.24.1 SIBLINGS (cffi-examples cffi-grovel cffi-libffi cffi-tests cffi-toolchain cffi-uffi-compat) PARASITES (cffi/c2ffi cffi/c2ffi-generator)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/chanl.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/chanl.nix index b6940af5986..8e32a0b1abf 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/chanl.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/chanl.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "chanl"; - version = "20210124-git"; + version = "20210411-git"; parasites = [ "chanl/examples" "chanl/tests" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."bordeaux-threads" args."fiveam" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/chanl/2021-01-24/chanl-20210124-git.tgz"; - sha256 = "1lb0k5nh51f8hskpm1pma5ds4lk1zpbk9czpw9bk8hdykr178mzc"; + url = "http://beta.quicklisp.org/archive/chanl/2021-04-11/chanl-20210411-git.tgz"; + sha256 = "1c1yiw616q5hv6vzyg1y4kg68v94p37s5jrq387rwadfnnf46rgi"; }; packageName = "chanl"; @@ -22,11 +22,11 @@ rec { } /* (SYSTEM chanl DESCRIPTION Communicating Sequential Process support for Common Lisp SHA256 - 1lb0k5nh51f8hskpm1pma5ds4lk1zpbk9czpw9bk8hdykr178mzc URL - http://beta.quicklisp.org/archive/chanl/2021-01-24/chanl-20210124-git.tgz - MD5 2f9e2d16caa2febff4f5beb6226b7ccf NAME chanl FILENAME chanl DEPS + 1c1yiw616q5hv6vzyg1y4kg68v94p37s5jrq387rwadfnnf46rgi URL + http://beta.quicklisp.org/archive/chanl/2021-04-11/chanl-20210411-git.tgz + MD5 efaa5705b5feaa718290d25a95e2a684 NAME chanl FILENAME chanl DEPS ((NAME alexandria FILENAME alexandria) (NAME bordeaux-threads FILENAME bordeaux-threads) (NAME fiveam FILENAME fiveam)) - DEPENDENCIES (alexandria bordeaux-threads fiveam) VERSION 20210124-git + DEPENDENCIES (alexandria bordeaux-threads fiveam) VERSION 20210411-git SIBLINGS NIL PARASITES (chanl/examples chanl/tests)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-change-case.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-change-case.nix index eb967399371..99ff56f9b15 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-change-case.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-change-case.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "cl-change-case"; - version = "20210228-git"; + version = "20210411-git"; parasites = [ "cl-change-case/test" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."cl-ppcre" args."cl-ppcre-unicode" args."cl-unicode" args."fiveam" args."flexi-streams" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cl-change-case/2021-02-28/cl-change-case-20210228-git.tgz"; - sha256 = "15x8zxwa3pxs02fh0qxmbvz6vi59x6ha09p5hs4rgd6axs0k4pmi"; + url = "http://beta.quicklisp.org/archive/cl-change-case/2021-04-11/cl-change-case-20210411-git.tgz"; + sha256 = "14s26b907h1nsnwdqbj6j4c9bvc4rc2l8ry2q1j7ibjfzqvhp4mj"; }; packageName = "cl-change-case"; @@ -22,13 +22,13 @@ rec { } /* (SYSTEM cl-change-case DESCRIPTION Convert strings between camelCase, param-case, PascalCase and more SHA256 - 15x8zxwa3pxs02fh0qxmbvz6vi59x6ha09p5hs4rgd6axs0k4pmi URL - http://beta.quicklisp.org/archive/cl-change-case/2021-02-28/cl-change-case-20210228-git.tgz - MD5 8fec07f0634a739134dc4fcec807fe16 NAME cl-change-case FILENAME + 14s26b907h1nsnwdqbj6j4c9bvc4rc2l8ry2q1j7ibjfzqvhp4mj URL + http://beta.quicklisp.org/archive/cl-change-case/2021-04-11/cl-change-case-20210411-git.tgz + MD5 df72a3d71a6c65e149704688aec859b9 NAME cl-change-case FILENAME cl-change-case DEPS ((NAME cl-ppcre FILENAME cl-ppcre) (NAME cl-ppcre-unicode FILENAME cl-ppcre-unicode) (NAME cl-unicode FILENAME cl-unicode) (NAME fiveam FILENAME fiveam) (NAME flexi-streams FILENAME flexi-streams)) DEPENDENCIES (cl-ppcre cl-ppcre-unicode cl-unicode fiveam flexi-streams) - VERSION 20210228-git SIBLINGS NIL PARASITES (cl-change-case/test)) */ + VERSION 20210411-git SIBLINGS NIL PARASITES (cl-change-case/test)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-colors2.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-colors2.nix index 5a8bea30a59..5fac77896b6 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-colors2.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-colors2.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "cl-colors2"; - version = "20200218-git"; + version = "20210411-git"; parasites = [ "cl-colors2/tests" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."cl-ppcre" args."clunit2" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cl-colors2/2020-02-18/cl-colors2-20200218-git.tgz"; - sha256 = "0rpf8j232qv254zhkvkz3ja20al1kswvcqhvvv0r2ag6dks56j29"; + url = "http://beta.quicklisp.org/archive/cl-colors2/2021-04-11/cl-colors2-20210411-git.tgz"; + sha256 = "14kdi214x8rxil27wfbx0csgi7g8dg5wsifpsrdrqph0p7ps8snk"; }; packageName = "cl-colors2"; @@ -21,11 +21,11 @@ rec { overrides = x: x; } /* (SYSTEM cl-colors2 DESCRIPTION Simple color library for Common Lisp SHA256 - 0rpf8j232qv254zhkvkz3ja20al1kswvcqhvvv0r2ag6dks56j29 URL - http://beta.quicklisp.org/archive/cl-colors2/2020-02-18/cl-colors2-20200218-git.tgz - MD5 054283564f17af46a09e259ff509b656 NAME cl-colors2 FILENAME cl-colors2 + 14kdi214x8rxil27wfbx0csgi7g8dg5wsifpsrdrqph0p7ps8snk URL + http://beta.quicklisp.org/archive/cl-colors2/2021-04-11/cl-colors2-20210411-git.tgz + MD5 e6b54e76e7d1cfcff45955dbd4752f1d NAME cl-colors2 FILENAME cl-colors2 DEPS ((NAME alexandria FILENAME alexandria) (NAME cl-ppcre FILENAME cl-ppcre) (NAME clunit2 FILENAME clunit2)) - DEPENDENCIES (alexandria cl-ppcre clunit2) VERSION 20200218-git SIBLINGS + DEPENDENCIES (alexandria cl-ppcre clunit2) VERSION 20210411-git SIBLINGS NIL PARASITES (cl-colors2/tests)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-gobject-introspection.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-gobject-introspection.nix new file mode 100644 index 00000000000..15b16ef84c1 --- /dev/null +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-gobject-introspection.nix @@ -0,0 +1,32 @@ +/* Generated file. */ +args @ { fetchurl, ... }: +rec { + baseName = "cl-gobject-introspection"; + version = "20210124-git"; + + description = "Binding to GObjectIntrospection"; + + deps = [ args."alexandria" args."babel" args."cffi" args."iterate" args."trivial-features" args."trivial-garbage" ]; + + src = fetchurl { + url = "http://beta.quicklisp.org/archive/cl-gobject-introspection/2021-01-24/cl-gobject-introspection-20210124-git.tgz"; + sha256 = "1hrc451d9xdp3pfmwalw32r3iqfvw6ccy665kl5560lihwmk59w0"; + }; + + packageName = "cl-gobject-introspection"; + + asdFilesToKeep = ["cl-gobject-introspection.asd"]; + overrides = x: x; +} +/* (SYSTEM cl-gobject-introspection DESCRIPTION Binding to GObjectIntrospection + SHA256 1hrc451d9xdp3pfmwalw32r3iqfvw6ccy665kl5560lihwmk59w0 URL + http://beta.quicklisp.org/archive/cl-gobject-introspection/2021-01-24/cl-gobject-introspection-20210124-git.tgz + MD5 ad760b820c86142c0a1309af29541680 NAME cl-gobject-introspection FILENAME + cl-gobject-introspection DEPS + ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) + (NAME cffi FILENAME cffi) (NAME iterate FILENAME iterate) + (NAME trivial-features FILENAME trivial-features) + (NAME trivial-garbage FILENAME trivial-garbage)) + DEPENDENCIES + (alexandria babel cffi iterate trivial-features trivial-garbage) VERSION + 20210124-git SIBLINGS (cl-gobject-introspection-test) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-postgres.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-postgres.nix index 95f5d037381..5e78f8e98c4 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-postgres.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-postgres.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "cl-postgres"; - version = "postmodern-20210124-git"; + version = "postmodern-20210411-git"; parasites = [ "cl-postgres/simple-date-tests" "cl-postgres/tests" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."bordeaux-threads" args."cl-base64" args."cl-ppcre" args."fiveam" args."ironclad" args."md5" args."simple-date" args."simple-date_slash_postgres-glue" args."split-sequence" args."uax-15" args."usocket" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz"; - sha256 = "1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc"; + url = "http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz"; + sha256 = "0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw"; }; packageName = "cl-postgres"; @@ -21,9 +21,9 @@ rec { overrides = x: x; } /* (SYSTEM cl-postgres DESCRIPTION Low-level client library for PostgreSQL - SHA256 1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc URL - http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz - MD5 05c2c5f4d2354a5fa69a32b7b96f8ff8 NAME cl-postgres FILENAME cl-postgres + SHA256 0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw URL + http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz + MD5 8a75a05ba9e371f672f2620d40724cb2 NAME cl-postgres FILENAME cl-postgres DEPS ((NAME alexandria FILENAME alexandria) (NAME bordeaux-threads FILENAME bordeaux-threads) @@ -36,5 +36,5 @@ rec { DEPENDENCIES (alexandria bordeaux-threads cl-base64 cl-ppcre fiveam ironclad md5 simple-date simple-date/postgres-glue split-sequence uax-15 usocket) - VERSION postmodern-20210124-git SIBLINGS (postmodern s-sql simple-date) + VERSION postmodern-20210411-git SIBLINGS (postmodern s-sql simple-date) PARASITES (cl-postgres/simple-date-tests cl-postgres/tests)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-typesetting.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-typesetting.nix index 82beff70579..0284b2dfd22 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-typesetting.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-typesetting.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "cl-typesetting"; - version = "20210228-git"; + version = "20210411-git"; description = "Common Lisp Typesetting system"; deps = [ args."cl-pdf" args."iterate" args."zpb-ttf" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cl-typesetting/2021-02-28/cl-typesetting-20210228-git.tgz"; - sha256 = "13rmzyzp0glq35jq3qdlmrsdssa6csqp5g455li4wi7kq8clrwnp"; + url = "http://beta.quicklisp.org/archive/cl-typesetting/2021-04-11/cl-typesetting-20210411-git.tgz"; + sha256 = "1102n049hhg0kqnfvdfcisjq5l9yfvbw090nq0q8vd2bc688ng41"; }; packageName = "cl-typesetting"; @@ -19,11 +19,11 @@ rec { overrides = x: x; } /* (SYSTEM cl-typesetting DESCRIPTION Common Lisp Typesetting system SHA256 - 13rmzyzp0glq35jq3qdlmrsdssa6csqp5g455li4wi7kq8clrwnp URL - http://beta.quicklisp.org/archive/cl-typesetting/2021-02-28/cl-typesetting-20210228-git.tgz - MD5 949e7de37838d63f4c6b6e7dd88befeb NAME cl-typesetting FILENAME + 1102n049hhg0kqnfvdfcisjq5l9yfvbw090nq0q8vd2bc688ng41 URL + http://beta.quicklisp.org/archive/cl-typesetting/2021-04-11/cl-typesetting-20210411-git.tgz + MD5 f3fc7a47efb99cf849cb5eeede96dbaf NAME cl-typesetting FILENAME cl-typesetting DEPS ((NAME cl-pdf FILENAME cl-pdf) (NAME iterate FILENAME iterate) (NAME zpb-ttf FILENAME zpb-ttf)) - DEPENDENCIES (cl-pdf iterate zpb-ttf) VERSION 20210228-git SIBLINGS + DEPENDENCIES (cl-pdf iterate zpb-ttf) VERSION 20210411-git SIBLINGS (xml-render cl-pdf-doc) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-webkit2.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-webkit2.nix index 56275d72740..84005b13b20 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-webkit2.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-webkit2.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "cl-webkit2"; - version = "cl-webkit-20210228-git"; + version = "cl-webkit-20210411-git"; description = "An FFI binding to WebKit2GTK+"; deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk" args."cl-cffi-gtk-cairo" args."cl-cffi-gtk-gdk" args."cl-cffi-gtk-gdk-pixbuf" args."cl-cffi-gtk-gio" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."cl-cffi-gtk-pango" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cl-webkit/2021-02-28/cl-webkit-20210228-git.tgz"; - sha256 = "1r6i64g37palar4hij6c5m240xbn2dwzwaashv015nhjwmra1ms1"; + url = "http://beta.quicklisp.org/archive/cl-webkit/2021-04-11/cl-webkit-20210411-git.tgz"; + sha256 = "10cky5v67s9mx2j96k0z01qbqfyc8w6a8byaamm7al5qkw997brh"; }; packageName = "cl-webkit2"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM cl-webkit2 DESCRIPTION An FFI binding to WebKit2GTK+ SHA256 - 1r6i64g37palar4hij6c5m240xbn2dwzwaashv015nhjwmra1ms1 URL - http://beta.quicklisp.org/archive/cl-webkit/2021-02-28/cl-webkit-20210228-git.tgz - MD5 49f38c18ac292122628356762270e5ff NAME cl-webkit2 FILENAME cl-webkit2 + 10cky5v67s9mx2j96k0z01qbqfyc8w6a8byaamm7al5qkw997brh URL + http://beta.quicklisp.org/archive/cl-webkit/2021-04-11/cl-webkit-20210411-git.tgz + MD5 01b52f031fd8742ac9d422e4fcd2a225 NAME cl-webkit2 FILENAME cl-webkit2 DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME bordeaux-threads FILENAME bordeaux-threads) @@ -41,4 +41,4 @@ rec { cl-cffi-gtk-gdk cl-cffi-gtk-gdk-pixbuf cl-cffi-gtk-gio cl-cffi-gtk-glib cl-cffi-gtk-gobject cl-cffi-gtk-pango closer-mop iterate trivial-features trivial-garbage) - VERSION cl-webkit-20210228-git SIBLINGS NIL PARASITES NIL) */ + VERSION cl-webkit-20210411-git SIBLINGS NIL PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl_plus_ssl.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl_plus_ssl.nix index 6811c62ad2e..55eb8934945 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl_plus_ssl.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/cl_plus_ssl.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "cl_plus_ssl"; - version = "cl+ssl-20210228-git"; + version = "cl+ssl-20210411-git"; description = "Common Lisp interface to OpenSSL."; deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."flexi-streams" args."split-sequence" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."uiop" args."usocket" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cl+ssl/2021-02-28/cl+ssl-20210228-git.tgz"; - sha256 = "1njppcg5fm8l0lhf7nf8nfyaz9vsr922y0vfxqdp9hp7qfid8yll"; + url = "http://beta.quicklisp.org/archive/cl+ssl/2021-04-11/cl+ssl-20210411-git.tgz"; + sha256 = "1rc13lc5wwzlkn7yhl3bwl6cmxxldmbfnz52nz5b83v4wlw2zbcw"; }; packageName = "cl+ssl"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM cl+ssl DESCRIPTION Common Lisp interface to OpenSSL. SHA256 - 1njppcg5fm8l0lhf7nf8nfyaz9vsr922y0vfxqdp9hp7qfid8yll URL - http://beta.quicklisp.org/archive/cl+ssl/2021-02-28/cl+ssl-20210228-git.tgz - MD5 01b61fd8ee6ad8d3c1c695ba56d510b6 NAME cl+ssl FILENAME cl_plus_ssl DEPS + 1rc13lc5wwzlkn7yhl3bwl6cmxxldmbfnz52nz5b83v4wlw2zbcw URL + http://beta.quicklisp.org/archive/cl+ssl/2021-04-11/cl+ssl-20210411-git.tgz + MD5 9ef5b60ac4c8ad4f435a3ef6234897d0 NAME cl+ssl FILENAME cl_plus_ssl DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME bordeaux-threads FILENAME bordeaux-threads) (NAME cffi FILENAME cffi) (NAME flexi-streams FILENAME flexi-streams) @@ -33,4 +33,4 @@ rec { DEPENDENCIES (alexandria babel bordeaux-threads cffi flexi-streams split-sequence trivial-features trivial-garbage trivial-gray-streams uiop usocket) - VERSION cl+ssl-20210228-git SIBLINGS (cl+ssl.test) PARASITES NIL) */ + VERSION cl+ssl-20210411-git SIBLINGS (cl+ssl.test) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-handler-hunchentoot.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-handler-hunchentoot.nix index ff3679a2639..3c18fd91195 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-handler-hunchentoot.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-handler-hunchentoot.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "clack-handler-hunchentoot"; - version = "clack-20191007-git"; + version = "clack-20210411-git"; description = "Clack handler for Hunchentoot."; deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."chunga" args."cl_plus_ssl" args."cl-base64" args."cl-fad" args."cl-ppcre" args."clack-socket" args."flexi-streams" args."hunchentoot" args."md5" args."rfc2388" args."split-sequence" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."usocket" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz"; - sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w"; + url = "http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz"; + sha256 = "0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf"; }; packageName = "clack-handler-hunchentoot"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM clack-handler-hunchentoot DESCRIPTION Clack handler for Hunchentoot. - SHA256 004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w URL - http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz - MD5 25741855fa1e989d373ac06ddfabf351 NAME clack-handler-hunchentoot + SHA256 0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf URL + http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz + MD5 c47deb6287b72fc9033055914787f3a5 NAME clack-handler-hunchentoot FILENAME clack-handler-hunchentoot DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME bordeaux-threads FILENAME bordeaux-threads) @@ -43,7 +43,7 @@ rec { cl-ppcre clack-socket flexi-streams hunchentoot md5 rfc2388 split-sequence trivial-backtrace trivial-features trivial-garbage trivial-gray-streams usocket) - VERSION clack-20191007-git SIBLINGS + VERSION clack-20210411-git SIBLINGS (clack-handler-fcgi clack-handler-toot clack-handler-wookie clack-socket clack-test clack-v1-compat clack t-clack-handler-fcgi t-clack-handler-hunchentoot t-clack-handler-toot t-clack-handler-wookie diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-socket.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-socket.nix index e597bb66d60..2fe47652ebb 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-socket.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-socket.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "clack-socket"; - version = "clack-20191007-git"; + version = "clack-20210411-git"; description = "System lacks description"; deps = [ ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz"; - sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w"; + url = "http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz"; + sha256 = "0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf"; }; packageName = "clack-socket"; @@ -19,10 +19,10 @@ rec { overrides = x: x; } /* (SYSTEM clack-socket DESCRIPTION System lacks description SHA256 - 004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w URL - http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz - MD5 25741855fa1e989d373ac06ddfabf351 NAME clack-socket FILENAME - clack-socket DEPS NIL DEPENDENCIES NIL VERSION clack-20191007-git SIBLINGS + 0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf URL + http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz + MD5 c47deb6287b72fc9033055914787f3a5 NAME clack-socket FILENAME + clack-socket DEPS NIL DEPENDENCIES NIL VERSION clack-20210411-git SIBLINGS (clack-handler-fcgi clack-handler-hunchentoot clack-handler-toot clack-handler-wookie clack-test clack-v1-compat clack t-clack-handler-fcgi t-clack-handler-hunchentoot t-clack-handler-toot t-clack-handler-wookie diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-test.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-test.nix index d014ccc2111..ab2794fbdd1 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-test.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-test.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "clack-test"; - version = "clack-20191007-git"; + version = "clack-20210411-git"; description = "Testing Clack Applications."; deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chipz" args."chunga" args."cl_plus_ssl" args."cl-annot" args."cl-base64" args."cl-cookie" args."cl-fad" args."cl-ppcre" args."cl-reexport" args."cl-syntax" args."cl-syntax-annot" args."cl-utilities" args."clack" args."clack-handler-hunchentoot" args."clack-socket" args."dexador" args."dissect" args."fast-http" args."fast-io" args."flexi-streams" args."http-body" args."hunchentoot" args."ironclad" args."jonathan" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."local-time" args."md5" args."named-readtables" args."proc-parse" args."quri" args."rfc2388" args."rove" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."trivial-mimes" args."trivial-types" args."usocket" args."xsubseq" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz"; - sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w"; + url = "http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz"; + sha256 = "0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf"; }; packageName = "clack-test"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM clack-test DESCRIPTION Testing Clack Applications. SHA256 - 004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w URL - http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz - MD5 25741855fa1e989d373ac06ddfabf351 NAME clack-test FILENAME clack-test + 0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf URL + http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz + MD5 c47deb6287b72fc9033055914787f3a5 NAME clack-test FILENAME clack-test DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME bordeaux-threads FILENAME bordeaux-threads) @@ -68,7 +68,7 @@ rec { proc-parse quri rfc2388 rove smart-buffer split-sequence static-vectors trivial-backtrace trivial-features trivial-garbage trivial-gray-streams trivial-mimes trivial-types usocket xsubseq) - VERSION clack-20191007-git SIBLINGS + VERSION clack-20210411-git SIBLINGS (clack-handler-fcgi clack-handler-hunchentoot clack-handler-toot clack-handler-wookie clack-socket clack-v1-compat clack t-clack-handler-fcgi t-clack-handler-hunchentoot t-clack-handler-toot diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-v1-compat.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-v1-compat.nix index 6d90a5ef1f0..f93b8e1c9d6 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-v1-compat.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-v1-compat.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "clack-v1-compat"; - version = "clack-20191007-git"; + version = "clack-20210411-git"; description = "System lacks description"; deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chipz" args."chunga" args."circular-streams" args."cl_plus_ssl" args."cl-annot" args."cl-base64" args."cl-cookie" args."cl-fad" args."cl-ppcre" args."cl-reexport" args."cl-syntax" args."cl-syntax-annot" args."cl-utilities" args."clack" args."clack-handler-hunchentoot" args."clack-socket" args."clack-test" args."dexador" args."dissect" args."fast-http" args."fast-io" args."flexi-streams" args."http-body" args."hunchentoot" args."ironclad" args."jonathan" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."local-time" args."marshal" args."md5" args."named-readtables" args."proc-parse" args."quri" args."rfc2388" args."rove" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."trivial-mimes" args."trivial-types" args."uiop" args."usocket" args."xsubseq" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz"; - sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w"; + url = "http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz"; + sha256 = "0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf"; }; packageName = "clack-v1-compat"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM clack-v1-compat DESCRIPTION System lacks description SHA256 - 004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w URL - http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz - MD5 25741855fa1e989d373ac06ddfabf351 NAME clack-v1-compat FILENAME + 0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf URL + http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz + MD5 c47deb6287b72fc9033055914787f3a5 NAME clack-v1-compat FILENAME clack-v1-compat DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME bordeaux-threads FILENAME bordeaux-threads) @@ -73,7 +73,7 @@ rec { split-sequence static-vectors trivial-backtrace trivial-features trivial-garbage trivial-gray-streams trivial-mimes trivial-types uiop usocket xsubseq) - VERSION clack-20191007-git SIBLINGS + VERSION clack-20210411-git SIBLINGS (clack-handler-fcgi clack-handler-hunchentoot clack-handler-toot clack-handler-wookie clack-socket clack-test clack t-clack-handler-fcgi t-clack-handler-hunchentoot t-clack-handler-toot t-clack-handler-wookie diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack.nix index 78ffa543ece..95447ca8ad7 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/clack.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "clack"; - version = "20191007-git"; + version = "20210411-git"; description = "Web application environment for Common Lisp"; - deps = [ args."alexandria" args."bordeaux-threads" args."ironclad" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."uiop" ]; + deps = [ args."alexandria" args."bordeaux-threads" args."ironclad" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."split-sequence" args."uiop" args."usocket" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz"; - sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w"; + url = "http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz"; + sha256 = "0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf"; }; packageName = "clack"; @@ -19,19 +19,21 @@ rec { overrides = x: x; } /* (SYSTEM clack DESCRIPTION Web application environment for Common Lisp SHA256 - 004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w URL - http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz - MD5 25741855fa1e989d373ac06ddfabf351 NAME clack FILENAME clack DEPS + 0yai9cx1gha684ljr8k1s5n4mi6mpj2wmvv6b9iw7pw1vhw5m8mf URL + http://beta.quicklisp.org/archive/clack/2021-04-11/clack-20210411-git.tgz + MD5 c47deb6287b72fc9033055914787f3a5 NAME clack FILENAME clack DEPS ((NAME alexandria FILENAME alexandria) (NAME bordeaux-threads FILENAME bordeaux-threads) (NAME ironclad FILENAME ironclad) (NAME lack FILENAME lack) (NAME lack-component FILENAME lack-component) (NAME lack-middleware-backtrace FILENAME lack-middleware-backtrace) - (NAME lack-util FILENAME lack-util) (NAME uiop FILENAME uiop)) + (NAME lack-util FILENAME lack-util) + (NAME split-sequence FILENAME split-sequence) (NAME uiop FILENAME uiop) + (NAME usocket FILENAME usocket)) DEPENDENCIES (alexandria bordeaux-threads ironclad lack lack-component - lack-middleware-backtrace lack-util uiop) - VERSION 20191007-git SIBLINGS + lack-middleware-backtrace lack-util split-sequence uiop usocket) + VERSION 20210411-git SIBLINGS (clack-handler-fcgi clack-handler-hunchentoot clack-handler-toot clack-handler-wookie clack-socket clack-test clack-v1-compat t-clack-handler-fcgi t-clack-handler-hunchentoot t-clack-handler-toot diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/closer-mop.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/closer-mop.nix index ff8e7cc953c..876681846c8 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/closer-mop.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/closer-mop.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "closer-mop"; - version = "20210228-git"; + version = "20210411-git"; description = "Closer to MOP is a compatibility layer that rectifies many of the absent or incorrect CLOS MOP features across a broad range of Common Lisp implementations."; deps = [ ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/closer-mop/2021-02-28/closer-mop-20210228-git.tgz"; - sha256 = "0x3rp2v84zzw5mhcxrgbq2kcb9gs4jn1l9rh4ylsnih89l9lqc6i"; + url = "http://beta.quicklisp.org/archive/closer-mop/2021-04-11/closer-mop-20210411-git.tgz"; + sha256 = "0pynql962m2z7wqnmd51a2xm3wsqvgfxcq9maw2br0zs0icys236"; }; packageName = "closer-mop"; @@ -20,7 +20,7 @@ rec { } /* (SYSTEM closer-mop DESCRIPTION Closer to MOP is a compatibility layer that rectifies many of the absent or incorrect CLOS MOP features across a broad range of Common Lisp implementations. - SHA256 0x3rp2v84zzw5mhcxrgbq2kcb9gs4jn1l9rh4ylsnih89l9lqc6i URL - http://beta.quicklisp.org/archive/closer-mop/2021-02-28/closer-mop-20210228-git.tgz - MD5 49c0004ff21157bc99f227cecf7b6025 NAME closer-mop FILENAME closer-mop - DEPS NIL DEPENDENCIES NIL VERSION 20210228-git SIBLINGS NIL PARASITES NIL) */ + SHA256 0pynql962m2z7wqnmd51a2xm3wsqvgfxcq9maw2br0zs0icys236 URL + http://beta.quicklisp.org/archive/closer-mop/2021-04-11/closer-mop-20210411-git.tgz + MD5 05b05d98ad294f8bd6f9779d04cc848a NAME closer-mop FILENAME closer-mop + DEPS NIL DEPENDENCIES NIL VERSION 20210411-git SIBLINGS NIL PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/dexador.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/dexador.nix index b7b7cf0eadc..b035477eda4 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/dexador.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/dexador.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "dexador"; - version = "20210228-git"; + version = "20210411-git"; description = "Yet another HTTP client for Common Lisp"; deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chipz" args."chunga" args."cl_plus_ssl" args."cl-base64" args."cl-cookie" args."cl-ppcre" args."cl-reexport" args."cl-utilities" args."fast-http" args."fast-io" args."flexi-streams" args."local-time" args."proc-parse" args."quri" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."trivial-mimes" args."usocket" args."xsubseq" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/dexador/2021-02-28/dexador-20210228-git.tgz"; - sha256 = "0glzvi7nbr58izpwr8xzxvlcc78zmgwqaik374rmcy6w89q5ksw7"; + url = "http://beta.quicklisp.org/archive/dexador/2021-04-11/dexador-20210411-git.tgz"; + sha256 = "1px4llzb6x930cq3dmrkzidydqqc8rd2y4s3nlwpsrv4874cxwx1"; }; packageName = "dexador"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM dexador DESCRIPTION Yet another HTTP client for Common Lisp SHA256 - 0glzvi7nbr58izpwr8xzxvlcc78zmgwqaik374rmcy6w89q5ksw7 URL - http://beta.quicklisp.org/archive/dexador/2021-02-28/dexador-20210228-git.tgz - MD5 e3b69c8ceb78d99351e574c40dfd0e12 NAME dexador FILENAME dexador DEPS + 1px4llzb6x930cq3dmrkzidydqqc8rd2y4s3nlwpsrv4874cxwx1 URL + http://beta.quicklisp.org/archive/dexador/2021-04-11/dexador-20210411-git.tgz + MD5 10d59691af3e25e590a2dfff29c91292 NAME dexador FILENAME dexador DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME bordeaux-threads FILENAME bordeaux-threads) (NAME cffi FILENAME cffi) (NAME cffi-grovel FILENAME cffi-grovel) @@ -48,4 +48,4 @@ rec { fast-http fast-io flexi-streams local-time proc-parse quri smart-buffer split-sequence static-vectors trivial-features trivial-garbage trivial-gray-streams trivial-mimes usocket xsubseq) - VERSION 20210228-git SIBLINGS (dexador-test) PARASITES NIL) */ + VERSION 20210411-git SIBLINGS (dexador-test) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/file-attributes.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/file-attributes.nix index c6bb4c1baaf..6af2f0f24fe 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/file-attributes.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/file-attributes.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "file-attributes"; - version = "20200925-git"; + version = "20210411-git"; description = "Access to file attributes (uid, gid, atime, mtime, mod)"; deps = [ args."alexandria" args."babel" args."cffi" args."documentation-utils" args."trivial-features" args."trivial-indent" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/file-attributes/2020-09-25/file-attributes-20200925-git.tgz"; - sha256 = "0wq3gs36zwl8dzknj3c794l60vg1zpf0siwhd7ad9pn81v3mdan7"; + url = "http://beta.quicklisp.org/archive/file-attributes/2021-04-11/file-attributes-20210411-git.tgz"; + sha256 = "0zsqimyzfivr08d6pdg6xxw6cj7q9pjh2wi9c460nh85z7a51yc9"; }; packageName = "file-attributes"; @@ -20,9 +20,9 @@ rec { } /* (SYSTEM file-attributes DESCRIPTION Access to file attributes (uid, gid, atime, mtime, mod) SHA256 - 0wq3gs36zwl8dzknj3c794l60vg1zpf0siwhd7ad9pn81v3mdan7 URL - http://beta.quicklisp.org/archive/file-attributes/2020-09-25/file-attributes-20200925-git.tgz - MD5 368468453cf57ecc29fa75f2a030a738 NAME file-attributes FILENAME + 0zsqimyzfivr08d6pdg6xxw6cj7q9pjh2wi9c460nh85z7a51yc9 URL + http://beta.quicklisp.org/archive/file-attributes/2021-04-11/file-attributes-20210411-git.tgz + MD5 75e0f0e2c280c97fe496545e7105fa01 NAME file-attributes FILENAME file-attributes DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME cffi FILENAME cffi) @@ -31,4 +31,4 @@ rec { (NAME trivial-indent FILENAME trivial-indent)) DEPENDENCIES (alexandria babel cffi documentation-utils trivial-features trivial-indent) - VERSION 20200925-git SIBLINGS NIL PARASITES NIL) */ + VERSION 20210411-git SIBLINGS NIL PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/ironclad.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/ironclad.nix index c511435ac9c..b6f602387e1 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/ironclad.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/ironclad.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "ironclad"; - version = "v0.54"; + version = "v0.55"; parasites = [ "ironclad/tests" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."bordeaux-threads" args."rt" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/ironclad/2021-01-24/ironclad-v0.54.tgz"; - sha256 = "01mpsnjx8cgn3wx2n0dkv8v83z93da9zrxncn58ghbpyq3z1i4w2"; + url = "http://beta.quicklisp.org/archive/ironclad/2021-04-11/ironclad-v0.55.tgz"; + sha256 = "0vdqaad9i3dkz6z2y1iqmh6m77kc9jy49xh9bysgywl0gfdyhnq6"; }; packageName = "ironclad"; @@ -22,10 +22,10 @@ rec { } /* (SYSTEM ironclad DESCRIPTION A cryptographic toolkit written in pure Common Lisp SHA256 - 01mpsnjx8cgn3wx2n0dkv8v83z93da9zrxncn58ghbpyq3z1i4w2 URL - http://beta.quicklisp.org/archive/ironclad/2021-01-24/ironclad-v0.54.tgz - MD5 f99610509e4603aac66d9aa03ede2770 NAME ironclad FILENAME ironclad DEPS + 0vdqaad9i3dkz6z2y1iqmh6m77kc9jy49xh9bysgywl0gfdyhnq6 URL + http://beta.quicklisp.org/archive/ironclad/2021-04-11/ironclad-v0.55.tgz + MD5 c3c4a88e71ef37c9604662071069afcc NAME ironclad FILENAME ironclad DEPS ((NAME alexandria FILENAME alexandria) (NAME bordeaux-threads FILENAME bordeaux-threads) (NAME rt FILENAME rt)) - DEPENDENCIES (alexandria bordeaux-threads rt) VERSION v0.54 SIBLINGS + DEPENDENCIES (alexandria bordeaux-threads rt) VERSION v0.55 SIBLINGS (ironclad-text) PARASITES (ironclad/tests)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/marshal.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/marshal.nix index e9e5ed5f1d1..e935d2b3d99 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/marshal.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/marshal.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "marshal"; - version = "cl-20201016-git"; + version = "cl-20210411-git"; description = "marshal: Simple (de)serialization of Lisp datastructures."; deps = [ ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cl-marshal/2020-10-16/cl-marshal-20201016-git.tgz"; - sha256 = "03j52yhgpc2myypgy07213l20rznxvf6m3sfbzy2wyapcmv7nxnz"; + url = "http://beta.quicklisp.org/archive/cl-marshal/2021-04-11/cl-marshal-20210411-git.tgz"; + sha256 = "0wi4csgl5qxgl0si5mcg19xx4qlmw125qn0w1i2f3dvvrzp20qrp"; }; packageName = "marshal"; @@ -20,8 +20,8 @@ rec { } /* (SYSTEM marshal DESCRIPTION marshal: Simple (de)serialization of Lisp datastructures. SHA256 - 03j52yhgpc2myypgy07213l20rznxvf6m3sfbzy2wyapcmv7nxnz URL - http://beta.quicklisp.org/archive/cl-marshal/2020-10-16/cl-marshal-20201016-git.tgz - MD5 243a2c3a5f1243ffb1639bca32a0aff0 NAME marshal FILENAME marshal DEPS NIL - DEPENDENCIES NIL VERSION cl-20201016-git SIBLINGS (marshal-tests) PARASITES + 0wi4csgl5qxgl0si5mcg19xx4qlmw125qn0w1i2f3dvvrzp20qrp URL + http://beta.quicklisp.org/archive/cl-marshal/2021-04-11/cl-marshal-20210411-git.tgz + MD5 2463314a6bcd1a18bea2690deb6bce55 NAME marshal FILENAME marshal DEPS NIL + DEPENDENCIES NIL VERSION cl-20210411-git SIBLINGS (marshal-tests) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/mgl-pax.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/mgl-pax.nix index 53896192b52..c22acbce4f0 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/mgl-pax.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/mgl-pax.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "mgl-pax"; - version = "20210228-git"; + version = "20210411-git"; parasites = [ "mgl-pax/test" ]; @@ -12,8 +12,8 @@ rec { deps = [ args."_3bmd" args."_3bmd-ext-code-blocks" args."alexandria" args."babel" args."bordeaux-threads" args."cl-fad" args."colorize" args."esrap" args."html-encode" args."ironclad" args."named-readtables" args."pythonic-string-reader" args."split-sequence" args."swank" args."trivial-features" args."trivial-with-current-source-form" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/mgl-pax/2021-02-28/mgl-pax-20210228-git.tgz"; - sha256 = "1dyhbnd69lb6ih89pvg8nn6pwsg25v5xjsfk1i5l1fdib14612cw"; + url = "http://beta.quicklisp.org/archive/mgl-pax/2021-04-11/mgl-pax-20210411-git.tgz"; + sha256 = "0dq5jkb6li0s1gqj6hfhifs6cd4kypavv2kjqg5zgs6zfs82sxh3"; }; packageName = "mgl-pax"; @@ -23,9 +23,9 @@ rec { } /* (SYSTEM mgl-pax DESCRIPTION Exploratory programming tool and documentation generator. - SHA256 1dyhbnd69lb6ih89pvg8nn6pwsg25v5xjsfk1i5l1fdib14612cw URL - http://beta.quicklisp.org/archive/mgl-pax/2021-02-28/mgl-pax-20210228-git.tgz - MD5 a256ce4ee76d669d233ee09830ef7968 NAME mgl-pax FILENAME mgl-pax DEPS + SHA256 0dq5jkb6li0s1gqj6hfhifs6cd4kypavv2kjqg5zgs6zfs82sxh3 URL + http://beta.quicklisp.org/archive/mgl-pax/2021-04-11/mgl-pax-20210411-git.tgz + MD5 44cf1bd71e6c40c256a43a87efa2c2a1 NAME mgl-pax FILENAME mgl-pax DEPS ((NAME 3bmd FILENAME _3bmd) (NAME 3bmd-ext-code-blocks FILENAME _3bmd-ext-code-blocks) (NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) @@ -44,4 +44,4 @@ rec { colorize esrap html-encode ironclad named-readtables pythonic-string-reader split-sequence swank trivial-features trivial-with-current-source-form) - VERSION 20210228-git SIBLINGS NIL PARASITES (mgl-pax/test)) */ + VERSION 20210411-git SIBLINGS NIL PARASITES (mgl-pax/test)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/plump.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/plump.nix index ef0817fbe7c..fa7d1e047d9 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/plump.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/plump.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "plump"; - version = "20210124-git"; + version = "20210411-git"; description = "An XML / XHTML / HTML parser that aims to be as lenient as possible."; deps = [ args."array-utils" args."documentation-utils" args."trivial-indent" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/plump/2021-01-24/plump-20210124-git.tgz"; - sha256 = "0br64xiz4mgmmsvkfmi43k2q16rmc6hbqf976x8cdafs3h266jdm"; + url = "http://beta.quicklisp.org/archive/plump/2021-04-11/plump-20210411-git.tgz"; + sha256 = "05zs9blznfhapz5yiy08968hw64rzdgqgvfgc9r9da45b45pl6dp"; }; packageName = "plump"; @@ -20,11 +20,11 @@ rec { } /* (SYSTEM plump DESCRIPTION An XML / XHTML / HTML parser that aims to be as lenient as possible. SHA256 - 0br64xiz4mgmmsvkfmi43k2q16rmc6hbqf976x8cdafs3h266jdm URL - http://beta.quicklisp.org/archive/plump/2021-01-24/plump-20210124-git.tgz - MD5 44a5d371dd1c3d4afc6b8801926b059a NAME plump FILENAME plump DEPS + 05zs9blznfhapz5yiy08968hw64rzdgqgvfgc9r9da45b45pl6dp URL + http://beta.quicklisp.org/archive/plump/2021-04-11/plump-20210411-git.tgz + MD5 055e30ed07ae793426a48b55c947f9bb NAME plump FILENAME plump DEPS ((NAME array-utils FILENAME array-utils) (NAME documentation-utils FILENAME documentation-utils) (NAME trivial-indent FILENAME trivial-indent)) DEPENDENCIES (array-utils documentation-utils trivial-indent) VERSION - 20210124-git SIBLINGS (plump-dom plump-lexer plump-parser) PARASITES NIL) */ + 20210411-git SIBLINGS (plump-dom plump-lexer plump-parser) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/postmodern.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/postmodern.nix index f530d71eb68..245cb109a32 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/postmodern.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/postmodern.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "postmodern"; - version = "20210124-git"; + version = "20210411-git"; parasites = [ "postmodern/tests" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."bordeaux-threads" args."cl-base64" args."cl-postgres" args."cl-postgres_plus_local-time" args."cl-postgres_slash_tests" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."fiveam" args."flexi-streams" args."global-vars" args."ironclad" args."local-time" args."md5" args."s-sql" args."s-sql_slash_tests" args."simple-date" args."simple-date_slash_postgres-glue" args."split-sequence" args."uax-15" args."usocket" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz"; - sha256 = "1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc"; + url = "http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz"; + sha256 = "0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw"; }; packageName = "postmodern"; @@ -21,9 +21,9 @@ rec { overrides = x: x; } /* (SYSTEM postmodern DESCRIPTION PostgreSQL programming API SHA256 - 1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc URL - http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz - MD5 05c2c5f4d2354a5fa69a32b7b96f8ff8 NAME postmodern FILENAME postmodern + 0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw URL + http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz + MD5 8a75a05ba9e371f672f2620d40724cb2 NAME postmodern FILENAME postmodern DEPS ((NAME alexandria FILENAME alexandria) (NAME bordeaux-threads FILENAME bordeaux-threads) @@ -46,5 +46,5 @@ rec { cl-postgres/tests cl-ppcre cl-unicode closer-mop fiveam flexi-streams global-vars ironclad local-time md5 s-sql s-sql/tests simple-date simple-date/postgres-glue split-sequence uax-15 usocket) - VERSION 20210124-git SIBLINGS (cl-postgres s-sql simple-date) PARASITES + VERSION 20210411-git SIBLINGS (cl-postgres s-sql simple-date) PARASITES (postmodern/tests)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/quri.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/quri.nix index 12ea17a3491..48d98ca2395 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/quri.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/quri.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "quri"; - version = "20210228-git"; + version = "20210411-git"; description = "Yet another URI library for Common Lisp"; deps = [ args."alexandria" args."babel" args."cl-utilities" args."split-sequence" args."trivial-features" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/quri/2021-02-28/quri-20210228-git.tgz"; - sha256 = "03hq6x715kv37c089b73f6j8b0f4ywhxr37wbw9any2jcgrswx0g"; + url = "http://beta.quicklisp.org/archive/quri/2021-04-11/quri-20210411-git.tgz"; + sha256 = "1j4al77bl8awj7755g8zvgvfskdh6gcl3gygbz2fi6lrrk9125d7"; }; packageName = "quri"; @@ -19,13 +19,13 @@ rec { overrides = x: x; } /* (SYSTEM quri DESCRIPTION Yet another URI library for Common Lisp SHA256 - 03hq6x715kv37c089b73f6j8b0f4ywhxr37wbw9any2jcgrswx0g URL - http://beta.quicklisp.org/archive/quri/2021-02-28/quri-20210228-git.tgz MD5 - 67eac028850cc2539c076d31b049f7bd NAME quri FILENAME quri DEPS + 1j4al77bl8awj7755g8zvgvfskdh6gcl3gygbz2fi6lrrk9125d7 URL + http://beta.quicklisp.org/archive/quri/2021-04-11/quri-20210411-git.tgz MD5 + 2727c706f51bef480171c59f6134bba5 NAME quri FILENAME quri DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME cl-utilities FILENAME cl-utilities) (NAME split-sequence FILENAME split-sequence) (NAME trivial-features FILENAME trivial-features)) DEPENDENCIES (alexandria babel cl-utilities split-sequence trivial-features) VERSION - 20210228-git SIBLINGS (quri-test) PARASITES NIL) */ + 20210411-git SIBLINGS (quri-test) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/s-sql.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/s-sql.nix index d6ac95810a4..d91ab87d822 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/s-sql.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/s-sql.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "s-sql"; - version = "postmodern-20210124-git"; + version = "postmodern-20210411-git"; parasites = [ "s-sql/tests" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."bordeaux-threads" args."cl-base64" args."cl-postgres" args."cl-postgres_slash_tests" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."fiveam" args."global-vars" args."ironclad" args."md5" args."postmodern" args."split-sequence" args."uax-15" args."usocket" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz"; - sha256 = "1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc"; + url = "http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz"; + sha256 = "0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw"; }; packageName = "s-sql"; @@ -21,9 +21,9 @@ rec { overrides = x: x; } /* (SYSTEM s-sql DESCRIPTION Lispy DSL for SQL SHA256 - 1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc URL - http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz - MD5 05c2c5f4d2354a5fa69a32b7b96f8ff8 NAME s-sql FILENAME s-sql DEPS + 0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw URL + http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz + MD5 8a75a05ba9e371f672f2620d40724cb2 NAME s-sql FILENAME s-sql DEPS ((NAME alexandria FILENAME alexandria) (NAME bordeaux-threads FILENAME bordeaux-threads) (NAME cl-base64 FILENAME cl-base64) @@ -39,5 +39,5 @@ rec { (alexandria bordeaux-threads cl-base64 cl-postgres cl-postgres/tests cl-ppcre cl-unicode closer-mop fiveam global-vars ironclad md5 postmodern split-sequence uax-15 usocket) - VERSION postmodern-20210124-git SIBLINGS + VERSION postmodern-20210411-git SIBLINGS (cl-postgres postmodern simple-date) PARASITES (s-sql/tests)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/serapeum.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/serapeum.nix index cab4e8c1494..e97a639814e 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/serapeum.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/serapeum.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "serapeum"; - version = "20210228-git"; + version = "20210411-git"; description = "Utilities beyond Alexandria."; deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."closer-mop" args."fare-quasiquote" args."fare-quasiquote-extras" args."fare-quasiquote-optima" args."fare-quasiquote-readtable" args."fare-utils" args."global-vars" args."introspect-environment" args."iterate" args."lisp-namespace" args."named-readtables" args."parse-declarations-1_dot_0" args."parse-number" args."split-sequence" args."string-case" args."trivia" args."trivia_dot_balland2006" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_quasiquote" args."trivia_dot_trivial" args."trivial-cltl2" args."trivial-features" args."trivial-file-size" args."trivial-garbage" args."trivial-macroexpand-all" args."type-i" args."uiop" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/serapeum/2021-02-28/serapeum-20210228-git.tgz"; - sha256 = "1dici8bmvrx5h74disrlvwns8f8jl746i4cyzyclswhv208x2m3x"; + url = "http://beta.quicklisp.org/archive/serapeum/2021-04-11/serapeum-20210411-git.tgz"; + sha256 = "1zz0sjp2dwy7qg7a3h1asvflkl9z2ajwk9zqfqylm0mhl0mv2c01"; }; packageName = "serapeum"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM serapeum DESCRIPTION Utilities beyond Alexandria. SHA256 - 1dici8bmvrx5h74disrlvwns8f8jl746i4cyzyclswhv208x2m3x URL - http://beta.quicklisp.org/archive/serapeum/2021-02-28/serapeum-20210228-git.tgz - MD5 25502093ea13851021422000686a54b7 NAME serapeum FILENAME serapeum DEPS + 1zz0sjp2dwy7qg7a3h1asvflkl9z2ajwk9zqfqylm0mhl0mv2c01 URL + http://beta.quicklisp.org/archive/serapeum/2021-04-11/serapeum-20210411-git.tgz + MD5 091a7c572d48164ba8499bb44a37a85f NAME serapeum FILENAME serapeum DEPS ((NAME alexandria FILENAME alexandria) (NAME babel FILENAME babel) (NAME bordeaux-threads FILENAME bordeaux-threads) (NAME closer-mop FILENAME closer-mop) @@ -60,4 +60,4 @@ rec { trivia.level2 trivia.quasiquote trivia.trivial trivial-cltl2 trivial-features trivial-file-size trivial-garbage trivial-macroexpand-all type-i uiop) - VERSION 20210228-git SIBLINGS NIL PARASITES NIL) */ + VERSION 20210411-git SIBLINGS NIL PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/simple-date.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/simple-date.nix index d861d72cccd..efe7f6a9eee 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/simple-date.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/simple-date.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "simple-date"; - version = "postmodern-20210124-git"; + version = "postmodern-20210411-git"; parasites = [ "simple-date/tests" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."fiveam" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz"; - sha256 = "1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc"; + url = "http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz"; + sha256 = "0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw"; }; packageName = "simple-date"; @@ -22,9 +22,9 @@ rec { } /* (SYSTEM simple-date DESCRIPTION Simple date library that can be used with postmodern SHA256 - 1fl103fga5iq2gf1p15xvbrmmjrcv2bbi3lz1zv32j6smy5aymhc URL - http://beta.quicklisp.org/archive/postmodern/2021-01-24/postmodern-20210124-git.tgz - MD5 05c2c5f4d2354a5fa69a32b7b96f8ff8 NAME simple-date FILENAME simple-date + 0q8izkkddmqq5sw55chkx6jrycawgchaknik5i84vynv50zirsbw URL + http://beta.quicklisp.org/archive/postmodern/2021-04-11/postmodern-20210411-git.tgz + MD5 8a75a05ba9e371f672f2620d40724cb2 NAME simple-date FILENAME simple-date DEPS ((NAME fiveam FILENAME fiveam)) DEPENDENCIES (fiveam) VERSION - postmodern-20210124-git SIBLINGS (cl-postgres postmodern s-sql) PARASITES + postmodern-20210411-git SIBLINGS (cl-postgres postmodern s-sql) PARASITES (simple-date/tests)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/str.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/str.nix index b352c476e08..11ddf729c3a 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/str.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/str.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "str"; - version = "cl-20210124-git"; + version = "cl-20210411-git"; description = "Modern, consistent and terse Common Lisp string manipulation library."; deps = [ args."cl-change-case" args."cl-ppcre" args."cl-ppcre-unicode" args."cl-unicode" args."flexi-streams" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/cl-str/2021-01-24/cl-str-20210124-git.tgz"; - sha256 = "07y24mx8gmhwz6px63llgsz15aqicqa4m8gd5zwxy708xggv73jc"; + url = "http://beta.quicklisp.org/archive/cl-str/2021-04-11/cl-str-20210411-git.tgz"; + sha256 = "0xyazb3j4j0wsq443fpavv4hxnizkcvhkgz709lnp7cxygpdnl7m"; }; packageName = "str"; @@ -20,9 +20,9 @@ rec { } /* (SYSTEM str DESCRIPTION Modern, consistent and terse Common Lisp string manipulation library. - SHA256 07y24mx8gmhwz6px63llgsz15aqicqa4m8gd5zwxy708xggv73jc URL - http://beta.quicklisp.org/archive/cl-str/2021-01-24/cl-str-20210124-git.tgz - MD5 afd5d3e1078bef872b0507215855397e NAME str FILENAME str DEPS + SHA256 0xyazb3j4j0wsq443fpavv4hxnizkcvhkgz709lnp7cxygpdnl7m URL + http://beta.quicklisp.org/archive/cl-str/2021-04-11/cl-str-20210411-git.tgz + MD5 6c6b4de0886d448155a5cca0dd38a189 NAME str FILENAME str DEPS ((NAME cl-change-case FILENAME cl-change-case) (NAME cl-ppcre FILENAME cl-ppcre) (NAME cl-ppcre-unicode FILENAME cl-ppcre-unicode) @@ -30,4 +30,4 @@ rec { (NAME flexi-streams FILENAME flexi-streams)) DEPENDENCIES (cl-change-case cl-ppcre cl-ppcre-unicode cl-unicode flexi-streams) VERSION - cl-20210124-git SIBLINGS (str.test) PARASITES NIL) */ + cl-20210411-git SIBLINGS (str.test) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/stumpwm.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/stumpwm.nix index f59a9d34e3d..13b025ea5be 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/stumpwm.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/stumpwm.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "stumpwm"; - version = "20210228-git"; + version = "20210411-git"; description = "A tiling, keyboard driven window manager"; deps = [ args."alexandria" args."cl-ppcre" args."clx" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/stumpwm/2021-02-28/stumpwm-20210228-git.tgz"; - sha256 = "0vfhn90vfyhlbjkfkzx0i7i6qh79p9q4c4hhsym80niz508xw5v8"; + url = "http://beta.quicklisp.org/archive/stumpwm/2021-04-11/stumpwm-20210411-git.tgz"; + sha256 = "0rrhmryfgbjrl04ww107pvm4lzm620xp7a5kwhqbh5d7hpbdk49j"; }; packageName = "stumpwm"; @@ -19,10 +19,10 @@ rec { overrides = x: x; } /* (SYSTEM stumpwm DESCRIPTION A tiling, keyboard driven window manager SHA256 - 0vfhn90vfyhlbjkfkzx0i7i6qh79p9q4c4hhsym80niz508xw5v8 URL - http://beta.quicklisp.org/archive/stumpwm/2021-02-28/stumpwm-20210228-git.tgz - MD5 0506bcd0951463ea45cebfdb5ce76511 NAME stumpwm FILENAME stumpwm DEPS + 0rrhmryfgbjrl04ww107pvm4lzm620xp7a5kwhqbh5d7hpbdk49j URL + http://beta.quicklisp.org/archive/stumpwm/2021-04-11/stumpwm-20210411-git.tgz + MD5 4497670e2aac3038ed5fb87121ff1b7a NAME stumpwm FILENAME stumpwm DEPS ((NAME alexandria FILENAME alexandria) (NAME cl-ppcre FILENAME cl-ppcre) (NAME clx FILENAME clx)) - DEPENDENCIES (alexandria cl-ppcre clx) VERSION 20210228-git SIBLINGS + DEPENDENCIES (alexandria cl-ppcre clx) VERSION 20210411-git SIBLINGS (stumpwm-tests) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia.nix index b8c330cc2fd..7f1077ed0cd 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "trivia"; - version = "20210228-git"; + version = "20210411-git"; description = "NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase"; deps = [ args."alexandria" args."closer-mop" args."introspect-environment" args."iterate" args."lisp-namespace" args."trivia_dot_balland2006" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_trivial" args."trivial-cltl2" args."type-i" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz"; - sha256 = "0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6"; + url = "http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz"; + sha256 = "1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8"; }; packageName = "trivia"; @@ -20,9 +20,9 @@ rec { } /* (SYSTEM trivia DESCRIPTION NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase - SHA256 0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6 URL - http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz - MD5 b374212a63c1e3b7e5c0e26348516106 NAME trivia FILENAME trivia DEPS + SHA256 1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8 URL + http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz + MD5 3fde6243390481d089cda082573876f6 NAME trivia FILENAME trivia DEPS ((NAME alexandria FILENAME alexandria) (NAME closer-mop FILENAME closer-mop) (NAME introspect-environment FILENAME introspect-environment) @@ -38,7 +38,7 @@ rec { (alexandria closer-mop introspect-environment iterate lisp-namespace trivia.balland2006 trivia.level0 trivia.level1 trivia.level2 trivia.trivial trivial-cltl2 type-i) - VERSION 20210228-git SIBLINGS + VERSION 20210411-git SIBLINGS (trivia.balland2006 trivia.benchmark trivia.cffi trivia.level0 trivia.level1 trivia.level2 trivia.ppcre trivia.quasiquote trivia.test trivia.trivial) diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_balland2006.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_balland2006.nix index 801781dd5a5..ce47f1d3df2 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_balland2006.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_balland2006.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "trivia_dot_balland2006"; - version = "trivia-20210228-git"; + version = "trivia-20210411-git"; description = "Optimizer for Trivia based on (Balland 2006)"; deps = [ args."alexandria" args."closer-mop" args."introspect-environment" args."iterate" args."lisp-namespace" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_trivial" args."trivial-cltl2" args."type-i" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz"; - sha256 = "0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6"; + url = "http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz"; + sha256 = "1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8"; }; packageName = "trivia.balland2006"; @@ -20,9 +20,9 @@ rec { } /* (SYSTEM trivia.balland2006 DESCRIPTION Optimizer for Trivia based on (Balland 2006) SHA256 - 0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6 URL - http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz - MD5 b374212a63c1e3b7e5c0e26348516106 NAME trivia.balland2006 FILENAME + 1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8 URL + http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz + MD5 3fde6243390481d089cda082573876f6 NAME trivia.balland2006 FILENAME trivia_dot_balland2006 DEPS ((NAME alexandria FILENAME alexandria) (NAME closer-mop FILENAME closer-mop) @@ -38,7 +38,7 @@ rec { (alexandria closer-mop introspect-environment iterate lisp-namespace trivia.level0 trivia.level1 trivia.level2 trivia.trivial trivial-cltl2 type-i) - VERSION trivia-20210228-git SIBLINGS + VERSION trivia-20210411-git SIBLINGS (trivia trivia.benchmark trivia.cffi trivia.level0 trivia.level1 trivia.level2 trivia.ppcre trivia.quasiquote trivia.test trivia.trivial) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level0.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level0.nix index 327ac0cdf1c..cfa992935f9 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level0.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level0.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "trivia_dot_level0"; - version = "trivia-20210228-git"; + version = "trivia-20210411-git"; description = "Bootstrapping Pattern Matching Library for implementing Trivia"; deps = [ args."alexandria" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz"; - sha256 = "0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6"; + url = "http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz"; + sha256 = "1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8"; }; packageName = "trivia.level0"; @@ -20,11 +20,11 @@ rec { } /* (SYSTEM trivia.level0 DESCRIPTION Bootstrapping Pattern Matching Library for implementing Trivia SHA256 - 0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6 URL - http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz - MD5 b374212a63c1e3b7e5c0e26348516106 NAME trivia.level0 FILENAME + 1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8 URL + http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz + MD5 3fde6243390481d089cda082573876f6 NAME trivia.level0 FILENAME trivia_dot_level0 DEPS ((NAME alexandria FILENAME alexandria)) DEPENDENCIES - (alexandria) VERSION trivia-20210228-git SIBLINGS + (alexandria) VERSION trivia-20210411-git SIBLINGS (trivia trivia.balland2006 trivia.benchmark trivia.cffi trivia.level1 trivia.level2 trivia.ppcre trivia.quasiquote trivia.test trivia.trivial) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level1.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level1.nix index eecb4c17eac..5cadfcf5723 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level1.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level1.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "trivia_dot_level1"; - version = "trivia-20210228-git"; + version = "trivia-20210411-git"; description = "Core patterns of Trivia"; deps = [ args."alexandria" args."trivia_dot_level0" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz"; - sha256 = "0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6"; + url = "http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz"; + sha256 = "1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8"; }; packageName = "trivia.level1"; @@ -19,13 +19,13 @@ rec { overrides = x: x; } /* (SYSTEM trivia.level1 DESCRIPTION Core patterns of Trivia SHA256 - 0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6 URL - http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz - MD5 b374212a63c1e3b7e5c0e26348516106 NAME trivia.level1 FILENAME + 1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8 URL + http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz + MD5 3fde6243390481d089cda082573876f6 NAME trivia.level1 FILENAME trivia_dot_level1 DEPS ((NAME alexandria FILENAME alexandria) (NAME trivia.level0 FILENAME trivia_dot_level0)) - DEPENDENCIES (alexandria trivia.level0) VERSION trivia-20210228-git + DEPENDENCIES (alexandria trivia.level0) VERSION trivia-20210411-git SIBLINGS (trivia trivia.balland2006 trivia.benchmark trivia.cffi trivia.level0 trivia.level2 trivia.ppcre trivia.quasiquote trivia.test trivia.trivial) diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level2.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level2.nix index ec0d99e06be..9e8ceca1eeb 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level2.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level2.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "trivia_dot_level2"; - version = "trivia-20210228-git"; + version = "trivia-20210411-git"; description = "NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase"; deps = [ args."alexandria" args."closer-mop" args."lisp-namespace" args."trivia_dot_level0" args."trivia_dot_level1" args."trivial-cltl2" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz"; - sha256 = "0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6"; + url = "http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz"; + sha256 = "1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8"; }; packageName = "trivia.level2"; @@ -20,9 +20,9 @@ rec { } /* (SYSTEM trivia.level2 DESCRIPTION NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase - SHA256 0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6 URL - http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz - MD5 b374212a63c1e3b7e5c0e26348516106 NAME trivia.level2 FILENAME + SHA256 1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8 URL + http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz + MD5 3fde6243390481d089cda082573876f6 NAME trivia.level2 FILENAME trivia_dot_level2 DEPS ((NAME alexandria FILENAME alexandria) (NAME closer-mop FILENAME closer-mop) @@ -33,7 +33,7 @@ rec { DEPENDENCIES (alexandria closer-mop lisp-namespace trivia.level0 trivia.level1 trivial-cltl2) - VERSION trivia-20210228-git SIBLINGS + VERSION trivia-20210411-git SIBLINGS (trivia trivia.balland2006 trivia.benchmark trivia.cffi trivia.level0 trivia.level1 trivia.ppcre trivia.quasiquote trivia.test trivia.trivial) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_quasiquote.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_quasiquote.nix index 420e4ae3058..bf6b1fb3548 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_quasiquote.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_quasiquote.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "trivia_dot_quasiquote"; - version = "trivia-20210228-git"; + version = "trivia-20210411-git"; description = "fare-quasiquote extension for trivia"; deps = [ args."alexandria" args."closer-mop" args."fare-quasiquote" args."fare-quasiquote-readtable" args."fare-utils" args."lisp-namespace" args."named-readtables" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_trivial" args."trivial-cltl2" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz"; - sha256 = "0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6"; + url = "http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz"; + sha256 = "1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8"; }; packageName = "trivia.quasiquote"; @@ -19,9 +19,9 @@ rec { overrides = x: x; } /* (SYSTEM trivia.quasiquote DESCRIPTION fare-quasiquote extension for trivia - SHA256 0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6 URL - http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz - MD5 b374212a63c1e3b7e5c0e26348516106 NAME trivia.quasiquote FILENAME + SHA256 1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8 URL + http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz + MD5 3fde6243390481d089cda082573876f6 NAME trivia.quasiquote FILENAME trivia_dot_quasiquote DEPS ((NAME alexandria FILENAME alexandria) (NAME closer-mop FILENAME closer-mop) @@ -39,7 +39,7 @@ rec { (alexandria closer-mop fare-quasiquote fare-quasiquote-readtable fare-utils lisp-namespace named-readtables trivia.level0 trivia.level1 trivia.level2 trivia.trivial trivial-cltl2) - VERSION trivia-20210228-git SIBLINGS + VERSION trivia-20210411-git SIBLINGS (trivia trivia.balland2006 trivia.benchmark trivia.cffi trivia.level0 trivia.level1 trivia.level2 trivia.ppcre trivia.test trivia.trivial) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_trivial.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_trivial.nix index 1173a24c8c6..3fe1ddbd06c 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_trivial.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_trivial.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "trivia_dot_trivial"; - version = "trivia-20210228-git"; + version = "trivia-20210411-git"; description = "Base level system of Trivia with a trivial optimizer. Systems that intend to enhance Trivia should depend on this package, not the TRIVIA system, @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."closer-mop" args."lisp-namespace" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivial-cltl2" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz"; - sha256 = "0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6"; + url = "http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz"; + sha256 = "1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8"; }; packageName = "trivia.trivial"; @@ -24,9 +24,9 @@ rec { Base level system of Trivia with a trivial optimizer. Systems that intend to enhance Trivia should depend on this package, not the TRIVIA system, in order to avoid the circular dependency. - SHA256 0qqyspq2mryl87wgrm43sj7d2wqb1pckk7fjvnmmyrf5kz5p4pc6 URL - http://beta.quicklisp.org/archive/trivia/2021-02-28/trivia-20210228-git.tgz - MD5 b374212a63c1e3b7e5c0e26348516106 NAME trivia.trivial FILENAME + SHA256 1dy35yhjhzcqsq5rwsan1f9x2ss8wcw55n2jzzgymj1vqvzp5mn8 URL + http://beta.quicklisp.org/archive/trivia/2021-04-11/trivia-20210411-git.tgz + MD5 3fde6243390481d089cda082573876f6 NAME trivia.trivial FILENAME trivia_dot_trivial DEPS ((NAME alexandria FILENAME alexandria) (NAME closer-mop FILENAME closer-mop) @@ -38,7 +38,7 @@ rec { DEPENDENCIES (alexandria closer-mop lisp-namespace trivia.level0 trivia.level1 trivia.level2 trivial-cltl2) - VERSION trivia-20210228-git SIBLINGS + VERSION trivia-20210411-git SIBLINGS (trivia trivia.balland2006 trivia.benchmark trivia.cffi trivia.level0 trivia.level1 trivia.level2 trivia.ppcre trivia.quasiquote trivia.test) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-features.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-features.nix index 272361dadc0..e762613bf08 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-features.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-features.nix @@ -2,15 +2,15 @@ args @ { fetchurl, ... }: rec { baseName = "trivial-features"; - version = "20210228-git"; + version = "20210411-git"; description = "Ensures consistent *FEATURES* across multiple CLs."; deps = [ ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/trivial-features/2021-02-28/trivial-features-20210228-git.tgz"; - sha256 = "1najk88r8nlpbxm8mjfj8b22f9chr9h2hxg9wqz87kkmhg4rfwwj"; + url = "http://beta.quicklisp.org/archive/trivial-features/2021-04-11/trivial-features-20210411-git.tgz"; + sha256 = "0z6nzql8z7bz8kzd08mh36h0r54vqx7pwigy8r617jhvb0r0n0n4"; }; packageName = "trivial-features"; @@ -20,8 +20,8 @@ rec { } /* (SYSTEM trivial-features DESCRIPTION Ensures consistent *FEATURES* across multiple CLs. SHA256 - 1najk88r8nlpbxm8mjfj8b22f9chr9h2hxg9wqz87kkmhg4rfwwj URL - http://beta.quicklisp.org/archive/trivial-features/2021-02-28/trivial-features-20210228-git.tgz - MD5 6d628c0c941346773751a684213a52d7 NAME trivial-features FILENAME - trivial-features DEPS NIL DEPENDENCIES NIL VERSION 20210228-git SIBLINGS + 0z6nzql8z7bz8kzd08mh36h0r54vqx7pwigy8r617jhvb0r0n0n4 URL + http://beta.quicklisp.org/archive/trivial-features/2021-04-11/trivial-features-20210411-git.tgz + MD5 5ec554fff48d38af5023604a1ae42d3a NAME trivial-features FILENAME + trivial-features DEPS NIL DEPENDENCIES NIL VERSION 20210411-git SIBLINGS (trivial-features-tests) PARASITES NIL) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-output/utilities_dot_print-items.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-output/utilities_dot_print-items.nix index bbaf2de554f..1e9decab327 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-output/utilities_dot_print-items.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-output/utilities_dot_print-items.nix @@ -2,7 +2,7 @@ args @ { fetchurl, ... }: rec { baseName = "utilities_dot_print-items"; - version = "20190813-git"; + version = "20210411-git"; parasites = [ "utilities.print-items/test" ]; @@ -11,8 +11,8 @@ rec { deps = [ args."alexandria" args."fiveam" ]; src = fetchurl { - url = "http://beta.quicklisp.org/archive/utilities.print-items/2019-08-13/utilities.print-items-20190813-git.tgz"; - sha256 = "12l4kzz621qfcg8p5qzyxp4n4hh9wdlpiziykwb4c80g32rdwkc2"; + url = "http://beta.quicklisp.org/archive/utilities.print-items/2021-04-11/utilities.print-items-20210411-git.tgz"; + sha256 = "0da2m4b993w31wph2ybdmdd6rycadrp44ccjdba5pygpkf3x00gx"; }; packageName = "utilities.print-items"; @@ -22,10 +22,10 @@ rec { } /* (SYSTEM utilities.print-items DESCRIPTION A protocol for flexible and composable printing. SHA256 - 12l4kzz621qfcg8p5qzyxp4n4hh9wdlpiziykwb4c80g32rdwkc2 URL - http://beta.quicklisp.org/archive/utilities.print-items/2019-08-13/utilities.print-items-20190813-git.tgz - MD5 0f26580bb5d3587ed1815f70976b2a0a NAME utilities.print-items FILENAME + 0da2m4b993w31wph2ybdmdd6rycadrp44ccjdba5pygpkf3x00gx URL + http://beta.quicklisp.org/archive/utilities.print-items/2021-04-11/utilities.print-items-20210411-git.tgz + MD5 35be0e5ee4c957699082fb6ae8f14ef2 NAME utilities.print-items FILENAME utilities_dot_print-items DEPS ((NAME alexandria FILENAME alexandria) (NAME fiveam FILENAME fiveam)) - DEPENDENCIES (alexandria fiveam) VERSION 20190813-git SIBLINGS NIL + DEPENDENCIES (alexandria fiveam) VERSION 20210411-git SIBLINGS NIL PARASITES (utilities.print-items/test)) */ diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-overrides.nix b/pkgs/development/lisp-modules/quicklisp-to-nix-overrides.nix index 628001000e8..ee2c4dbe0c6 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-overrides.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-overrides.nix @@ -276,4 +276,5 @@ $out/lib/common-lisp/query-fs" (extraLispDeps (with quicklisp-to-nix-packages; [cl-syslog])); md5 = ifLispNotIn ["sbcl" "ccl" "gcl"] (extraLispDeps (with quicklisp-to-nix-packages; [flexi-streams])); + cl-gobject-introspection = addNativeLibs (with pkgs; [glib gobject-introspection]); } diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix-systems.txt b/pkgs/development/lisp-modules/quicklisp-to-nix-systems.txt index 27eb3c90edd..93ca6916842 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix-systems.txt +++ b/pkgs/development/lisp-modules/quicklisp-to-nix-systems.txt @@ -41,6 +41,7 @@ cl-emb cl-fad cl-fuse cl-fuse-meta-fs +cl-gobject-introspection cl-hooks cl-html-diff cl-html5-parser diff --git a/pkgs/development/lisp-modules/quicklisp-to-nix.nix b/pkgs/development/lisp-modules/quicklisp-to-nix.nix index 1e0952aabaf..e8a5e5f026f 100644 --- a/pkgs/development/lisp-modules/quicklisp-to-nix.nix +++ b/pkgs/development/lisp-modules/quicklisp-to-nix.nix @@ -3520,6 +3520,20 @@ let quicklisp-to-nix-packages = rec { })); + "cl-gobject-introspection" = buildLispPackage + ((f: x: (x // (f x))) + (qlOverrides."cl-gobject-introspection" or (x: {})) + (import ./quicklisp-to-nix-output/cl-gobject-introspection.nix { + inherit fetchurl; + "alexandria" = quicklisp-to-nix-packages."alexandria"; + "babel" = quicklisp-to-nix-packages."babel"; + "cffi" = quicklisp-to-nix-packages."cffi"; + "iterate" = quicklisp-to-nix-packages."iterate"; + "trivial-features" = quicklisp-to-nix-packages."trivial-features"; + "trivial-garbage" = quicklisp-to-nix-packages."trivial-garbage"; + })); + + "cl-fuse-meta-fs" = buildLispPackage ((f: x: (x // (f x))) (qlOverrides."cl-fuse-meta-fs" or (x: {})) @@ -3879,7 +3893,9 @@ let quicklisp-to-nix-packages = rec { "lack-component" = quicklisp-to-nix-packages."lack-component"; "lack-middleware-backtrace" = quicklisp-to-nix-packages."lack-middleware-backtrace"; "lack-util" = quicklisp-to-nix-packages."lack-util"; + "split-sequence" = quicklisp-to-nix-packages."split-sequence"; "uiop" = quicklisp-to-nix-packages."uiop"; + "usocket" = quicklisp-to-nix-packages."usocket"; })); diff --git a/pkgs/development/lisp-modules/shell.nix b/pkgs/development/lisp-modules/shell.nix index a8ed246e6f8..bd6eea65f6f 100644 --- a/pkgs/development/lisp-modules/shell.nix +++ b/pkgs/development/lisp-modules/shell.nix @@ -11,6 +11,6 @@ self = rec { lispPackages.quicklisp-to-nix lispPackages.quicklisp-to-nix-system-info ]; CPATH = "${libfixposix}/include"; - LD_LIBRARY_PATH = "${openssl.out}/lib:${fuse}/lib:${libuv}/lib:${libev}/lib:${libmysqlclient}/lib:${libmysqlclient}/lib/mysql:${postgresql.lib}/lib:${sqlite.out}/lib:${libfixposix}/lib:${freetds}/lib:${openssl_lib_marked}/lib:${glib.out}/lib:${gdk-pixbuf}/lib:${cairo}/lib:${pango.out}/lib:${gtk3}/lib:${webkitgtk}/lib"; + LD_LIBRARY_PATH = "${openssl.out}/lib:${fuse}/lib:${libuv}/lib:${libev}/lib:${libmysqlclient}/lib:${libmysqlclient}/lib/mysql:${postgresql.lib}/lib:${sqlite.out}/lib:${libfixposix}/lib:${freetds}/lib:${openssl_lib_marked}/lib:${glib.out}/lib:${gdk-pixbuf}/lib:${cairo}/lib:${pango.out}/lib:${gtk3}/lib:${webkitgtk}/lib:${gobject-introspection}/lib"; }; in stdenv.mkDerivation self From 45a122eee57e517454911b41d6cb5a0d446f6a55 Mon Sep 17 00:00:00 2001 From: Bruno Bigras Date: Mon, 10 May 2021 11:21:33 -0400 Subject: [PATCH 089/163] nix-direnv: 1.2.4 -> 1.2.5 --- pkgs/tools/misc/nix-direnv/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/tools/misc/nix-direnv/default.nix b/pkgs/tools/misc/nix-direnv/default.nix index 39fd7d3e5f0..dd2ce37b439 100644 --- a/pkgs/tools/misc/nix-direnv/default.nix +++ b/pkgs/tools/misc/nix-direnv/default.nix @@ -1,14 +1,14 @@ -{ lib, stdenv, fetchFromGitHub, gnugrep, nix, nixFlakes }: +{ lib, stdenv, fetchFromGitHub, gnugrep, nixFlakes }: stdenv.mkDerivation rec { pname = "nix-direnv"; - version = "1.2.4"; + version = "1.2.5"; src = fetchFromGitHub { owner = "nix-community"; repo = "nix-direnv"; rev = version; - sha256 = "sha256-87x+MRQ1SjtN+wNCy42VJwlRwgQzHjNEK3J1bkvo7eQ="; + sha256 = "sha256-sqEodshg6nm3O4RK63ht8u6FU98bF/1i6frS50oyZY8="; }; # Substitute instead of wrapping because the resulting file is From f4a1f8e4610db7d623801c0cb789b3ac3a56c658 Mon Sep 17 00:00:00 2001 From: Francesco Gazzetta Date: Mon, 10 May 2021 18:57:50 +0200 Subject: [PATCH 090/163] qrcp: 0.8.1 -> 0.8.4 --- pkgs/tools/networking/qrcp/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/tools/networking/qrcp/default.nix b/pkgs/tools/networking/qrcp/default.nix index fd6b79ecb21..f417bb496f4 100644 --- a/pkgs/tools/networking/qrcp/default.nix +++ b/pkgs/tools/networking/qrcp/default.nix @@ -6,13 +6,13 @@ buildGoModule rec { pname = "qrcp"; - version = "0.8.1"; + version = "0.8.4"; src = fetchFromGitHub { owner = "claudiodangelis"; repo = "qrcp"; rev = version; - sha256 = "001w15hj5xb7p9gpvw1216lp26g5018qdi8mq6i84akb7zfd2q01"; + sha256 = "1m1xbb3x526j2v8m5m46km9zzj3dk9fvm5wckyqb8kxm4md12y50"; }; vendorSha256 = "1hn8c72fvih6ws1y2c4963pww3ld64m0yh3pmx62hwcy83bhb0v4"; From 67dfd53485b93995048dfe5e1f32b8b57a77005a Mon Sep 17 00:00:00 2001 From: Vincent Laporte Date: Fri, 7 May 2021 08:38:41 +0200 Subject: [PATCH 091/163] coqPackages.coqprime: enable for Coq 8.13 --- pkgs/development/coq-modules/coqprime/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/coq-modules/coqprime/default.nix b/pkgs/development/coq-modules/coqprime/default.nix index 79db1461075..d738041d5d2 100644 --- a/pkgs/development/coq-modules/coqprime/default.nix +++ b/pkgs/development/coq-modules/coqprime/default.nix @@ -6,7 +6,7 @@ with lib; mkCoqDerivation { owner = "thery"; inherit version; defaultVersion = with versions; switch coq.coq-version [ - { case = "8.12"; out = "8.12"; } + { case = range "8.12" "8.13"; out = "8.12"; } { case = range "8.10" "8.11"; out = "8.10"; } { case = range "8.8" "8.9"; out = "8.8"; } { case = "8.7"; out = "8.7.2"; } From bcbf6aafbd02538567f818649b0897b03784ed0c Mon Sep 17 00:00:00 2001 From: Vincent Laporte Date: Fri, 7 May 2021 08:38:46 +0200 Subject: [PATCH 092/163] coqPackages.metalib: enable for Coq 8.13 --- pkgs/development/coq-modules/metalib/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/coq-modules/metalib/default.nix b/pkgs/development/coq-modules/metalib/default.nix index 3ce3c625d26..14f1bab574a 100644 --- a/pkgs/development/coq-modules/metalib/default.nix +++ b/pkgs/development/coq-modules/metalib/default.nix @@ -4,7 +4,7 @@ with lib; mkCoqDerivation { pname = "metalib"; owner = "plclub"; inherit version; - defaultVersion = if versions.range "8.10" "8.12" coq.coq-version then "20200527" else null; + defaultVersion = if versions.range "8.10" "8.13" coq.coq-version then "20200527" else null; release."20200527".rev = "597fd7d0c93eb159274e84a39d554f10f1efccf8"; release."20200527".sha256 = "0wbypc05d2lqfm9qaw98ynr5yc1p0ipsvyc3bh1rk9nz7zwirmjs"; From 5f00e1484249726ad9bf8fb2fc108078e265365f Mon Sep 17 00:00:00 2001 From: Vincent Laporte Date: Fri, 7 May 2021 08:39:29 +0200 Subject: [PATCH 093/163] coq: default to version 8.13 --- pkgs/top-level/coq-packages.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/top-level/coq-packages.nix b/pkgs/top-level/coq-packages.nix index 2efd2c1849b..6027cd92d44 100644 --- a/pkgs/top-level/coq-packages.nix +++ b/pkgs/top-level/coq-packages.nix @@ -128,7 +128,7 @@ in rec { coqPackages_8_11 = mkCoqPackages coq_8_11; coqPackages_8_12 = mkCoqPackages coq_8_12; coqPackages_8_13 = mkCoqPackages coq_8_13; - coqPackages = recurseIntoAttrs coqPackages_8_11; + coqPackages = recurseIntoAttrs coqPackages_8_13; coq = coqPackages.coq; } From 0ffab925ca40082fcaeab5984b759cf028a2819f Mon Sep 17 00:00:00 2001 From: hyperfekt Date: Wed, 29 Apr 2020 13:41:09 +0200 Subject: [PATCH 094/163] fish: make python an optional dependency Python is still used for tests, but does not become part of the closure. In addition, nowadays fish only ever uses Python via __fish_anypython, so using sed or propagating python isn't necessary anymore. --- pkgs/shells/fish/default.nix | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pkgs/shells/fish/default.nix b/pkgs/shells/fish/default.nix index 61b2fe3032b..a5754290426 100644 --- a/pkgs/shells/fish/default.nix +++ b/pkgs/shells/fish/default.nix @@ -19,6 +19,9 @@ , fishPlugins , procps +# used to generate autocompletions from manpages and for configuration editing in the browser +, usePython ? true + , runCommand , writeText , nixosTests @@ -200,12 +203,10 @@ let ''; # Required binaries during execution - # Python: Autocompletion generated from manpages and config editing propagatedBuildInputs = [ coreutils gnugrep gnused - python3 groff gettext ] ++ lib.optional (!stdenv.isDarwin) man-db; @@ -237,14 +238,13 @@ let "$out/share/fish/functions/__fish_print_help.fish" sed -e "s|clear;|${getBin ncurses}/bin/clear;|" \ -i "$out/share/fish/functions/fish_default_key_bindings.fish" - sed -e "s|python3|${getBin python3}/bin/python3|" \ - -i $out/share/fish/functions/{__fish_config_interactive.fish,fish_config.fish,fish_update_completions.fish} sed -i "s|/usr/local/sbin /sbin /usr/sbin||" \ $out/share/fish/completions/{sudo.fish,doas.fish} sed -e "s| awk | ${gawk}/bin/awk |" \ -i $out/share/fish/functions/{__fish_print_packages.fish,__fish_print_addresses.fish,__fish_describe_command.fish,__fish_complete_man.fish,__fish_complete_convert_options.fish} \ $out/share/fish/completions/{cwebp,adb,ezjail-admin,grunt,helm,heroku,lsusb,make,p4,psql,rmmod,vim-addons}.fish + '' + optionalString usePython '' cat > $out/share/fish/functions/__fish_anypython.fish < Date: Mon, 10 May 2021 19:22:46 +0200 Subject: [PATCH 095/163] cargo-insta: 0.16.0 -> 1.7.1 (#122321) --- .../tools/rust/cargo-insta/cargo-lock.patch | 780 ------------------ .../tools/rust/cargo-insta/default.nix | 15 +- .../cargo-insta/ignore-rustfmt-test.patch | 10 - 3 files changed, 6 insertions(+), 799 deletions(-) delete mode 100644 pkgs/development/tools/rust/cargo-insta/cargo-lock.patch delete mode 100644 pkgs/development/tools/rust/cargo-insta/ignore-rustfmt-test.patch diff --git a/pkgs/development/tools/rust/cargo-insta/cargo-lock.patch b/pkgs/development/tools/rust/cargo-insta/cargo-lock.patch deleted file mode 100644 index 96f7d9ffb66..00000000000 --- a/pkgs/development/tools/rust/cargo-insta/cargo-lock.patch +++ /dev/null @@ -1,780 +0,0 @@ ---- a/Cargo.lock -+++ b/Cargo.lock -@@ -0,0 +1,777 @@ -+# This file is automatically @generated by Cargo. -+# It is not intended for manual editing. -+[[package]] -+name = "addr2line" -+version = "0.12.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "a49806b9dadc843c61e7c97e72490ad7f7220ae249012fbda9ad0609457c0543" -+dependencies = [ -+ "gimli", -+] -+ -+[[package]] -+name = "adler32" -+version = "1.1.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "567b077b825e468cc974f0020d4082ee6e03132512f207ef1a02fd5d00d1f32d" -+ -+[[package]] -+name = "aho-corasick" -+version = "0.7.10" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "8716408b8bc624ed7f65d223ddb9ac2d044c0547b6fa4b0d554f3a9540496ada" -+dependencies = [ -+ "memchr", -+] -+ -+[[package]] -+name = "ansi_term" -+version = "0.11.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b" -+dependencies = [ -+ "winapi", -+] -+ -+[[package]] -+name = "atty" -+version = "0.2.14" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" -+dependencies = [ -+ "hermit-abi", -+ "libc", -+ "winapi", -+] -+ -+[[package]] -+name = "autocfg" -+version = "1.0.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" -+ -+[[package]] -+name = "backtrace" -+version = "0.3.49" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "05100821de9e028f12ae3d189176b41ee198341eb8f369956407fea2f5cc666c" -+dependencies = [ -+ "addr2line", -+ "cfg-if", -+ "libc", -+ "miniz_oxide", -+ "object", -+ "rustc-demangle", -+] -+ -+[[package]] -+name = "base64" -+version = "0.10.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "0b25d992356d2eb0ed82172f5248873db5560c4721f564b13cb5193bda5e668e" -+dependencies = [ -+ "byteorder", -+] -+ -+[[package]] -+name = "bitflags" -+version = "1.2.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" -+ -+[[package]] -+name = "block-buffer" -+version = "0.7.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b" -+dependencies = [ -+ "block-padding", -+ "byte-tools", -+ "byteorder", -+ "generic-array", -+] -+ -+[[package]] -+name = "block-padding" -+version = "0.1.5" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5" -+dependencies = [ -+ "byte-tools", -+] -+ -+[[package]] -+name = "bstr" -+version = "0.2.13" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "31accafdb70df7871592c058eca3985b71104e15ac32f64706022c58867da931" -+dependencies = [ -+ "memchr", -+] -+ -+[[package]] -+name = "byte-tools" -+version = "0.3.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7" -+ -+[[package]] -+name = "byteorder" -+version = "1.3.4" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de" -+ -+[[package]] -+name = "cargo-insta" -+version = "0.16.0" -+dependencies = [ -+ "clap", -+ "console", -+ "difference", -+ "glob", -+ "insta", -+ "proc-macro2", -+ "serde", -+ "serde_json", -+ "structopt", -+ "syn", -+ "walkdir", -+] -+ -+[[package]] -+name = "cfg-if" -+version = "0.1.10" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" -+ -+[[package]] -+name = "clap" -+version = "2.33.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "bdfa80d47f954d53a35a64987ca1422f495b8d6483c0fe9f7117b36c2a792129" -+dependencies = [ -+ "ansi_term", -+ "atty", -+ "bitflags", -+ "strsim", -+ "textwrap", -+ "unicode-width", -+ "vec_map", -+] -+ -+[[package]] -+name = "clicolors-control" -+version = "1.0.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "90082ee5dcdd64dc4e9e0d37fbf3ee325419e39c0092191e0393df65518f741e" -+dependencies = [ -+ "atty", -+ "lazy_static", -+ "libc", -+ "winapi", -+] -+ -+[[package]] -+name = "console" -+version = "0.10.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "2586208b33573b7f76ccfbe5adb076394c88deaf81b84d7213969805b0a952a7" -+dependencies = [ -+ "clicolors-control", -+ "encode_unicode", -+ "lazy_static", -+ "libc", -+ "regex", -+ "terminal_size", -+ "termios", -+ "unicode-width", -+ "winapi", -+] -+ -+[[package]] -+name = "crossbeam-utils" -+version = "0.7.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" -+dependencies = [ -+ "autocfg", -+ "cfg-if", -+ "lazy_static", -+] -+ -+[[package]] -+name = "difference" -+version = "2.0.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198" -+ -+[[package]] -+name = "digest" -+version = "0.8.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5" -+dependencies = [ -+ "generic-array", -+] -+ -+[[package]] -+name = "dtoa" -+version = "0.4.6" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b" -+ -+[[package]] -+name = "encode_unicode" -+version = "0.3.6" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f" -+ -+[[package]] -+name = "fake-simd" -+version = "0.1.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed" -+ -+[[package]] -+name = "fnv" -+version = "1.0.7" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" -+ -+[[package]] -+name = "generic-array" -+version = "0.12.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec" -+dependencies = [ -+ "typenum", -+] -+ -+[[package]] -+name = "gimli" -+version = "0.21.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "bcc8e0c9bce37868955864dbecd2b1ab2bdf967e6f28066d65aaac620444b65c" -+ -+[[package]] -+name = "glob" -+version = "0.3.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" -+ -+[[package]] -+name = "globset" -+version = "0.4.5" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "7ad1da430bd7281dde2576f44c84cc3f0f7b475e7202cd503042dff01a8c8120" -+dependencies = [ -+ "aho-corasick", -+ "bstr", -+ "fnv", -+ "log", -+ "regex", -+] -+ -+[[package]] -+name = "globwalk" -+version = "0.8.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "178270263374052c40502e9f607134947de75302c1348d1a0e31db67c1691446" -+dependencies = [ -+ "bitflags", -+ "ignore", -+ "walkdir", -+] -+ -+[[package]] -+name = "heck" -+version = "0.3.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "20564e78d53d2bb135c343b3f47714a56af2061f1c928fdb541dc7b9fdd94205" -+dependencies = [ -+ "unicode-segmentation", -+] -+ -+[[package]] -+name = "hermit-abi" -+version = "0.1.14" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "b9586eedd4ce6b3c498bc3b4dd92fc9f11166aa908a914071953768066c67909" -+dependencies = [ -+ "libc", -+] -+ -+[[package]] -+name = "ignore" -+version = "0.4.16" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "22dcbf2a4a289528dbef21686354904e1c694ac642610a9bff9e7df730d9ec72" -+dependencies = [ -+ "crossbeam-utils", -+ "globset", -+ "lazy_static", -+ "log", -+ "memchr", -+ "regex", -+ "same-file", -+ "thread_local", -+ "walkdir", -+ "winapi-util", -+] -+ -+[[package]] -+name = "insta" -+version = "0.16.0" -+dependencies = [ -+ "backtrace", -+ "console", -+ "difference", -+ "globwalk", -+ "lazy_static", -+ "pest", -+ "pest_derive", -+ "ron", -+ "serde", -+ "serde_json", -+ "serde_yaml", -+] -+ -+[[package]] -+name = "itoa" -+version = "0.4.6" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6" -+ -+[[package]] -+name = "lazy_static" -+version = "1.4.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" -+ -+[[package]] -+name = "libc" -+version = "0.2.71" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "9457b06509d27052635f90d6466700c65095fdf75409b3fbdd903e988b886f49" -+ -+[[package]] -+name = "linked-hash-map" -+version = "0.5.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a" -+ -+[[package]] -+name = "log" -+version = "0.4.8" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" -+dependencies = [ -+ "cfg-if", -+] -+ -+[[package]] -+name = "maplit" -+version = "1.0.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d" -+ -+[[package]] -+name = "memchr" -+version = "2.3.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" -+ -+[[package]] -+name = "miniz_oxide" -+version = "0.3.7" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "791daaae1ed6889560f8c4359194f56648355540573244a5448a83ba1ecc7435" -+dependencies = [ -+ "adler32", -+] -+ -+[[package]] -+name = "object" -+version = "0.20.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "1ab52be62400ca80aa00285d25253d7f7c437b7375c4de678f5405d3afe82ca5" -+ -+[[package]] -+name = "opaque-debug" -+version = "0.2.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c" -+ -+[[package]] -+name = "pest" -+version = "2.1.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53" -+dependencies = [ -+ "ucd-trie", -+] -+ -+[[package]] -+name = "pest_derive" -+version = "2.1.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "833d1ae558dc601e9a60366421196a8d94bc0ac980476d0b67e1d0988d72b2d0" -+dependencies = [ -+ "pest", -+ "pest_generator", -+] -+ -+[[package]] -+name = "pest_generator" -+version = "2.1.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "99b8db626e31e5b81787b9783425769681b347011cc59471e33ea46d2ea0cf55" -+dependencies = [ -+ "pest", -+ "pest_meta", -+ "proc-macro2", -+ "quote", -+ "syn", -+] -+ -+[[package]] -+name = "pest_meta" -+version = "2.1.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "54be6e404f5317079812fc8f9f5279de376d8856929e21c184ecf6bbd692a11d" -+dependencies = [ -+ "maplit", -+ "pest", -+ "sha-1", -+] -+ -+[[package]] -+name = "proc-macro-error" -+version = "1.0.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "98e9e4b82e0ef281812565ea4751049f1bdcdfccda7d3f459f2e138a40c08678" -+dependencies = [ -+ "proc-macro-error-attr", -+ "proc-macro2", -+ "quote", -+ "syn", -+ "version_check", -+] -+ -+[[package]] -+name = "proc-macro-error-attr" -+version = "1.0.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "4f5444ead4e9935abd7f27dc51f7e852a0569ac888096d5ec2499470794e2e53" -+dependencies = [ -+ "proc-macro2", -+ "quote", -+ "syn", -+ "syn-mid", -+ "version_check", -+] -+ -+[[package]] -+name = "proc-macro2" -+version = "1.0.18" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "beae6331a816b1f65d04c45b078fd8e6c93e8071771f41b8163255bbd8d7c8fa" -+dependencies = [ -+ "unicode-xid", -+] -+ -+[[package]] -+name = "quote" -+version = "1.0.7" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37" -+dependencies = [ -+ "proc-macro2", -+] -+ -+[[package]] -+name = "regex" -+version = "1.3.9" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "9c3780fcf44b193bc4d09f36d2a3c87b251da4a046c87795a0d35f4f927ad8e6" -+dependencies = [ -+ "aho-corasick", -+ "memchr", -+ "regex-syntax", -+ "thread_local", -+] -+ -+[[package]] -+name = "regex-syntax" -+version = "0.6.18" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "26412eb97c6b088a6997e05f69403a802a92d520de2f8e63c2b65f9e0f47c4e8" -+ -+[[package]] -+name = "ron" -+version = "0.5.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "2ece421e0c4129b90e4a35b6f625e472e96c552136f5093a2f4fa2bbb75a62d5" -+dependencies = [ -+ "base64", -+ "bitflags", -+ "serde", -+] -+ -+[[package]] -+name = "rustc-demangle" -+version = "0.1.16" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "4c691c0e608126e00913e33f0ccf3727d5fc84573623b8d65b2df340b5201783" -+ -+[[package]] -+name = "ryu" -+version = "1.0.5" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e" -+ -+[[package]] -+name = "same-file" -+version = "1.0.6" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -+dependencies = [ -+ "winapi-util", -+] -+ -+[[package]] -+name = "serde" -+version = "1.0.112" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "736aac72d1eafe8e5962d1d1c3d99b0df526015ba40915cb3c49d042e92ec243" -+dependencies = [ -+ "serde_derive", -+] -+ -+[[package]] -+name = "serde_derive" -+version = "1.0.112" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "bf0343ce212ac0d3d6afd9391ac8e9c9efe06b533c8d33f660f6390cc4093f57" -+dependencies = [ -+ "proc-macro2", -+ "quote", -+ "syn", -+] -+ -+[[package]] -+name = "serde_json" -+version = "1.0.55" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "ec2c5d7e739bc07a3e73381a39d61fdb5f671c60c1df26a130690665803d8226" -+dependencies = [ -+ "itoa", -+ "ryu", -+ "serde", -+] -+ -+[[package]] -+name = "serde_yaml" -+version = "0.8.13" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "ae3e2dd40a7cdc18ca80db804b7f461a39bb721160a85c9a1fa30134bf3c02a5" -+dependencies = [ -+ "dtoa", -+ "linked-hash-map", -+ "serde", -+ "yaml-rust", -+] -+ -+[[package]] -+name = "sha-1" -+version = "0.8.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df" -+dependencies = [ -+ "block-buffer", -+ "digest", -+ "fake-simd", -+ "opaque-debug", -+] -+ -+[[package]] -+name = "strsim" -+version = "0.8.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a" -+ -+[[package]] -+name = "structopt" -+version = "0.3.15" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "de2f5e239ee807089b62adce73e48c625e0ed80df02c7ab3f068f5db5281065c" -+dependencies = [ -+ "clap", -+ "lazy_static", -+ "structopt-derive", -+] -+ -+[[package]] -+name = "structopt-derive" -+version = "0.4.8" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "510413f9de616762a4fbeab62509bf15c729603b72d7cd71280fbca431b1c118" -+dependencies = [ -+ "heck", -+ "proc-macro-error", -+ "proc-macro2", -+ "quote", -+ "syn", -+] -+ -+[[package]] -+name = "syn" -+version = "1.0.31" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "b5304cfdf27365b7585c25d4af91b35016ed21ef88f17ced89c7093b43dba8b6" -+dependencies = [ -+ "proc-macro2", -+ "quote", -+ "unicode-xid", -+] -+ -+[[package]] -+name = "syn-mid" -+version = "0.5.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "7be3539f6c128a931cf19dcee741c1af532c7fd387baa739c03dd2e96479338a" -+dependencies = [ -+ "proc-macro2", -+ "quote", -+ "syn", -+] -+ -+[[package]] -+name = "terminal_size" -+version = "0.1.12" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "8038f95fc7a6f351163f4b964af631bd26c9e828f7db085f2a84aca56f70d13b" -+dependencies = [ -+ "libc", -+ "winapi", -+] -+ -+[[package]] -+name = "termios" -+version = "0.3.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "6f0fcee7b24a25675de40d5bb4de6e41b0df07bc9856295e7e2b3a3600c400c2" -+dependencies = [ -+ "libc", -+] -+ -+[[package]] -+name = "textwrap" -+version = "0.11.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" -+dependencies = [ -+ "unicode-width", -+] -+ -+[[package]] -+name = "thread_local" -+version = "1.0.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "d40c6d1b69745a6ec6fb1ca717914848da4b44ae29d9b3080cbee91d72a69b14" -+dependencies = [ -+ "lazy_static", -+] -+ -+[[package]] -+name = "typenum" -+version = "1.12.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33" -+ -+[[package]] -+name = "ucd-trie" -+version = "0.1.3" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c" -+ -+[[package]] -+name = "unicode-segmentation" -+version = "1.6.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0" -+ -+[[package]] -+name = "unicode-width" -+version = "0.1.7" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "caaa9d531767d1ff2150b9332433f32a24622147e5ebb1f26409d5da67afd479" -+ -+[[package]] -+name = "unicode-xid" -+version = "0.2.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c" -+ -+[[package]] -+name = "vec_map" -+version = "0.8.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191" -+ -+[[package]] -+name = "version_check" -+version = "0.9.2" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed" -+ -+[[package]] -+name = "walkdir" -+version = "2.3.1" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "777182bc735b6424e1a57516d35ed72cb8019d85c8c9bf536dccb3445c1a2f7d" -+dependencies = [ -+ "same-file", -+ "winapi", -+ "winapi-util", -+] -+ -+[[package]] -+name = "winapi" -+version = "0.3.8" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6" -+dependencies = [ -+ "winapi-i686-pc-windows-gnu", -+ "winapi-x86_64-pc-windows-gnu", -+] -+ -+[[package]] -+name = "winapi-i686-pc-windows-gnu" -+version = "0.4.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" -+ -+[[package]] -+name = "winapi-util" -+version = "0.1.5" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178" -+dependencies = [ -+ "winapi", -+] -+ -+[[package]] -+name = "winapi-x86_64-pc-windows-gnu" -+version = "0.4.0" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" -+ -+[[package]] -+name = "yaml-rust" -+version = "0.4.4" -+source = "registry+https://github.com/rust-lang/crates.io-index" -+checksum = "39f0c922f1a334134dc2f7a8b67dc5d25f0735263feec974345ff706bcf20b0d" -+dependencies = [ -+ "linked-hash-map", -+] diff --git a/pkgs/development/tools/rust/cargo-insta/default.nix b/pkgs/development/tools/rust/cargo-insta/default.nix index e621fa9b972..0c377393354 100644 --- a/pkgs/development/tools/rust/cargo-insta/default.nix +++ b/pkgs/development/tools/rust/cargo-insta/default.nix @@ -1,22 +1,19 @@ -{ lib, rustPlatform, fetchFromGitHub }: +{ lib, rustPlatform, fetchFromGitHub, libiconv, stdenv }: rustPlatform.buildRustPackage rec { pname = "cargo-insta"; - version = "0.16.0"; + version = "1.7.1"; src = fetchFromGitHub { owner = "mitsuhiko"; repo = "insta"; rev = version; - sha256 = "1lcbdzh139lhmpz3pyik8nbgrbfc42z9ydz2hkg2lzjdpfdsz3ag"; + sha256 = "1qzzkhailxjqwp3rmdcpp112wn3x0gfi788vwj77pfdyclhpj0a7"; }; - cargoPatches = [ ./cargo-lock.patch ]; - cargoSha256 = "0qjzbcaznnmb0p0r23s82jjbfs5mhhkacg26lf8fq4vvlkr1hsqf"; - - patches = [ ./ignore-rustfmt-test.patch ]; - - cargoBuildFlags = [ "-p cargo-insta" ]; + sourceRoot = "source/cargo-insta"; + cargoSha256 = "01fj2j7ibrk5dyrfkmc610lh1p6f6bgzbgivq3dsd64vslhqmabw"; + buildInputs = lib.optionals stdenv.isDarwin [ libiconv ]; meta = with lib; { description = "A Cargo subcommand for snapshot testing"; diff --git a/pkgs/development/tools/rust/cargo-insta/ignore-rustfmt-test.patch b/pkgs/development/tools/rust/cargo-insta/ignore-rustfmt-test.patch deleted file mode 100644 index 6c38158d596..00000000000 --- a/pkgs/development/tools/rust/cargo-insta/ignore-rustfmt-test.patch +++ /dev/null @@ -1,10 +0,0 @@ ---- a/src/runtime.rs -+++ b/src/runtime.rs -@@ -85,6 +85,7 @@ fn format_rust_expression(value: &str) -> Cow<'_, str> { - } - - #[test] -+#[ignore] - fn test_format_rust_expression() { - use crate::assert_snapshot; - assert_snapshot!(format_rust_expression("vec![1,2,3]"), @"vec![1, 2, 3]"); From a3969f7909ac423f52af23282402bc415ee778fb Mon Sep 17 00:00:00 2001 From: Nicolas Berbiche Date: Mon, 10 May 2021 13:27:23 -0400 Subject: [PATCH 096/163] wayst: unstable-2020-10-12 -> unstable-2021-04-05 (#122098) --- pkgs/applications/terminal-emulators/wayst/default.nix | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/terminal-emulators/wayst/default.nix b/pkgs/applications/terminal-emulators/wayst/default.nix index dc79e48b24f..c6f39effed6 100644 --- a/pkgs/applications/terminal-emulators/wayst/default.nix +++ b/pkgs/applications/terminal-emulators/wayst/default.nix @@ -34,13 +34,13 @@ let in stdenv.mkDerivation rec { pname = "wayst"; - version = "unstable-2020-10-12"; + version = "unstable-2021-04-05"; src = fetchFromGitHub { owner = "91861"; repo = pname; - rev = "b8c7ca00a785a748026ed1ba08bf3d19916ced18"; - hash = "sha256-wHAU1yxukxApzhLLLctZ/AYqF7t21HQc5omPBZyxra0="; + rev = "e72ca78ef72c7b1e92473a98d435a3c85d7eab98"; + hash = "sha256-UXAVSfVpk/8KSg4oMw2tVWImD6HqJ7gEioR2MqhUUoQ="; }; makeFlags = [ "INSTALL_DIR=\${out}/bin" ]; @@ -83,6 +83,7 @@ stdenv.mkDerivation rec { meta = with lib; { description = "A simple terminal emulator"; + mainProgram = "wayst"; homepage = "https://github.com/91861/wayst"; license = licenses.mit; platforms = platforms.linux; From 8fe0744dd152b74e8ad95736166c19e980647ed2 Mon Sep 17 00:00:00 2001 From: Claudio Bley Date: Mon, 10 May 2021 16:00:06 +0200 Subject: [PATCH 097/163] bochs: Fix compilation with GCC 10 ZHF: #122042 --- .../bochs_fix_narrowing_conv_warning.patch | 29 +++++++++++++++++++ .../virtualization/bochs/default.nix | 6 +++- 2 files changed, 34 insertions(+), 1 deletion(-) create mode 100644 pkgs/applications/virtualization/bochs/bochs_fix_narrowing_conv_warning.patch diff --git a/pkgs/applications/virtualization/bochs/bochs_fix_narrowing_conv_warning.patch b/pkgs/applications/virtualization/bochs/bochs_fix_narrowing_conv_warning.patch new file mode 100644 index 00000000000..167dd65d05b --- /dev/null +++ b/pkgs/applications/virtualization/bochs/bochs_fix_narrowing_conv_warning.patch @@ -0,0 +1,29 @@ +------------------------------------------------------------------------ +r13882 | vruppert | 2020-06-09 09:30:01 +0200 (Tue, 09 Jun 2020) | 2 lines + +Compilation fix for MSYS2 gcc 10.1.0 (narrowing conversion). + + +Index: iodev/display/voodoo_data.h +=================================================================== +--- a/iodev/display/voodoo_data.h (revision 13881) ++++ b/iodev/display/voodoo_data.h (revision 13882) +@@ -1837,11 +1837,11 @@ + + /* fifo content defines */ + #define FIFO_TYPES (7 << 29) +-#define FIFO_WR_REG (1 << 29) +-#define FIFO_WR_TEX (2 << 29) +-#define FIFO_WR_FBI_32 (3 << 29) +-#define FIFO_WR_FBI_16L (4 << 29) +-#define FIFO_WR_FBI_16H (5 << 29) ++#define FIFO_WR_REG (1U << 29) ++#define FIFO_WR_TEX (2U << 29) ++#define FIFO_WR_FBI_32 (3U << 29) ++#define FIFO_WR_FBI_16L (4U << 29) ++#define FIFO_WR_FBI_16H (5U << 29) + + BX_CPP_INLINE void fifo_reset(fifo_state *f) + { + +------------------------------------------------------------------------ diff --git a/pkgs/applications/virtualization/bochs/default.nix b/pkgs/applications/virtualization/bochs/default.nix index f2418d80d2e..3a8e9dc0bee 100644 --- a/pkgs/applications/virtualization/bochs/default.nix +++ b/pkgs/applications/virtualization/bochs/default.nix @@ -26,7 +26,11 @@ stdenv.mkDerivation rec { sha256 = "0ql8q6y1k356li1g9gbvl21448mlxphxxi6kjb2b3pxvzd0pp2b3"; }; - patches = [ ./bochs-2.6.11-glibc-2.26.patch ./fix-build-smp.patch ]; + patches = [ + ./bochs-2.6.11-glibc-2.26.patch + ./fix-build-smp.patch + ./bochs_fix_narrowing_conv_warning.patch + ]; buildInputs = [ pkg-config libtool gtk2 libGLU libGL readline libX11 libXpm docbook_xml_dtd_45 docbook_xsl ] From a8a2a2362b75750335687b3d9c4f1af6a744461b Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Fri, 7 May 2021 00:14:28 +0200 Subject: [PATCH 098/163] python3Packages.plugwise: 0.9.3 -> 0.9.4 --- .../python-modules/plugwise/default.nix | 23 +++++++++---------- 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/pkgs/development/python-modules/plugwise/default.nix b/pkgs/development/python-modules/plugwise/default.nix index 289f1871f33..d62c2e8bb72 100644 --- a/pkgs/development/python-modules/plugwise/default.nix +++ b/pkgs/development/python-modules/plugwise/default.nix @@ -1,31 +1,31 @@ { lib -, buildPythonPackage -, fetchFromGitHub , aiohttp , async-timeout +, buildPythonPackage , crcmod , defusedxml -, pyserial -, pytz -, python-dateutil -, semver +, fetchFromGitHub , jsonpickle +, munch , mypy +, pyserial , pytest-aiohttp , pytest-asyncio -, pytest-cov , pytestCheckHook +, python-dateutil +, pytz +, semver }: buildPythonPackage rec { pname = "plugwise"; - version = "0.9.3"; + version = "0.9.4"; src = fetchFromGitHub { owner = pname; repo = "python-plugwise"; rev = version; - sha256 = "sha256-MZ4R55vGUyWmR0Md83eNerzsgtYMch1vfQ3sqbm12bM="; + sha256 = "sha256-5r+Xe3EKLjuR7mPGEPOKzhE7G6OzNEClf847Px9VdWU="; }; propagatedBuildInputs = [ @@ -33,9 +33,10 @@ buildPythonPackage rec { async-timeout crcmod defusedxml + munch pyserial - pytz python-dateutil + pytz semver ]; @@ -44,8 +45,6 @@ buildPythonPackage rec { mypy pytest-aiohttp pytest-asyncio - pytest-cov - pytest-asyncio pytestCheckHook ]; From 0f5d490226de05804a3ec6b5fc9d4552efe3ea5f Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Fri, 7 May 2021 00:16:44 +0200 Subject: [PATCH 099/163] home-assistant: enable plugwise tests --- pkgs/servers/home-assistant/default.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index 22b61c09334..86b8094d202 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -330,6 +330,7 @@ in with py.pkgs; buildPythonApplication rec { "persistent_notification" "person" "plaato" + "plugwise" "prometheus" "proximity" "push" From e4b05d9af55b403baaa6fdd738ee16c4498c4299 Mon Sep 17 00:00:00 2001 From: Henri Menke Date: Mon, 10 May 2021 20:34:54 +0200 Subject: [PATCH 100/163] zfs: remove trace output We cannot have trace output if the package is marked broken, because ofborg will consider the evaluation failed if there is any output. Hence if there is any unsupported kernel version in nixpkgs, the trace will show up and ofborg will complain. --- pkgs/os-specific/linux/zfs/default.nix | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/pkgs/os-specific/linux/zfs/default.nix b/pkgs/os-specific/linux/zfs/default.nix index adfd0cda819..e10be635b1c 100644 --- a/pkgs/os-specific/linux/zfs/default.nix +++ b/pkgs/os-specific/linux/zfs/default.nix @@ -182,13 +182,9 @@ let license = licenses.cddl; platforms = platforms.linux; maintainers = with maintainers; [ hmenke jcumming jonringer wizeman fpletz globin mic92 ]; - broken = if - buildKernel && (kernelCompatible != null) && !kernelCompatible - then builtins.trace '' - Linux v${kernel.version} is not yet supported by zfsonlinux v${version}. - ${lib.optionalString (!isUnstable) "Try zfsUnstable or set the NixOS option boot.zfs.enableUnstable."} - '' true - else false; + # If your Linux kernel version is not yet supported by zfs, try zfsUnstable. + # On NixOS set the option boot.zfs.enableUnstable. + broken = buildKernel && (kernelCompatible != null) && !kernelCompatible; }; }; in { From 586e118d7b4a4877832c556a930396b417a69784 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Sun, 9 May 2021 23:09:20 +0200 Subject: [PATCH 101/163] python3Packages.hatasmota: 0.2.11 -> 0.2.12 --- pkgs/development/python-modules/hatasmota/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/hatasmota/default.nix b/pkgs/development/python-modules/hatasmota/default.nix index f75891c2600..36fb5b61c74 100644 --- a/pkgs/development/python-modules/hatasmota/default.nix +++ b/pkgs/development/python-modules/hatasmota/default.nix @@ -7,13 +7,13 @@ buildPythonPackage rec { pname = "hatasmota"; - version = "0.2.11"; + version = "0.2.12"; src = fetchFromGitHub { owner = "emontnemery"; repo = pname; rev = version; - sha256 = "sha256-S2pVxYpB8NcZIbhC+gnGrJxM6tvoPS1Uh87HTYiksWI="; + sha256 = "sha256-rf0EB9PxageMQhPzG96oWovt+5L/u68VPllzPT4yp2A="; }; propagatedBuildInputs = [ From cf51b95aea169850208f2e8944d27fb290e1f9b4 Mon Sep 17 00:00:00 2001 From: Martin Weinelt Date: Mon, 10 May 2021 21:25:43 +0200 Subject: [PATCH 102/163] home-assistant: add jsonpickle to checkInputs Drop asynctest, it was dropped back in january upstream. These dependencies are sadly not part of the manifest, that we are parsing. --- pkgs/servers/home-assistant/default.nix | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index 86b8094d202..d44663fc3ce 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -182,17 +182,17 @@ in with py.pkgs; buildPythonApplication rec { doCheck = stdenv.isLinux; checkInputs = [ - # test infrastructure - asynctest + # test infrastructure (selectively from requirement_test.txt) pytest-aiohttp pytest-mock pytest-rerunfailures pytest-xdist pytestCheckHook requests-mock - # component dependencies - pyotp + jsonpickle respx + # required by tests/auth/mfa_modules + pyotp ] ++ lib.concatMap (component: getPackages component py.pkgs) componentTests; # We can reasonably test components that don't communicate with any network From 2d5cb58f4b5d3cc9fb751dd85ee2e5c16fdf434f Mon Sep 17 00:00:00 2001 From: Jason Felice Date: Mon, 10 May 2021 15:29:57 -0400 Subject: [PATCH 103/163] kak-ansi: 0.2.3 -> 0.2.4 --- pkgs/applications/editors/kakoune/plugins/overrides.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/editors/kakoune/plugins/overrides.nix b/pkgs/applications/editors/kakoune/plugins/overrides.nix index 2ca24cf661a..fb1287ba490 100644 --- a/pkgs/applications/editors/kakoune/plugins/overrides.nix +++ b/pkgs/applications/editors/kakoune/plugins/overrides.nix @@ -34,13 +34,13 @@ self: super: { kak-ansi = stdenv.mkDerivation rec { pname = "kak-ansi"; - version = "0.2.3"; + version = "0.2.4"; src = fetchFromGitHub { owner = "eraserhd"; repo = "kak-ansi"; rev = "v${version}"; - sha256 = "pO7M3MjKMJQew9O20KALEvsXLuCKPYGGTtuN/q/kj8Q="; + sha256 = "kFjTYFy0KF5WWEHU4hHFAnD/03/d3ptjqMMbTSaGImE="; }; installPhase = '' From 223571b6d9c4794fb2113853d0902fcb6d2f4e4c Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Sun, 9 May 2021 23:47:40 +0200 Subject: [PATCH 104/163] python3Packages.denonavr: 0.9.10 -> 0.10.7 --- pkgs/development/python-modules/denonavr/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/denonavr/default.nix b/pkgs/development/python-modules/denonavr/default.nix index 02b4ba47714..57a1b9b582d 100644 --- a/pkgs/development/python-modules/denonavr/default.nix +++ b/pkgs/development/python-modules/denonavr/default.nix @@ -15,14 +15,14 @@ buildPythonPackage rec { pname = "denonavr"; - version = "0.10.6"; + version = "0.10.7"; disabled = pythonOlder "3.6"; src = fetchFromGitHub { owner = "scarface-4711"; repo = pname; rev = version; - sha256 = "sha256-jcbjExcyZSE+qVPuYiMmuneugDMBoYz4apY/lz4JnMI="; + sha256 = "sha256-IGfU9nnlfZf8U6pCzG7cegmqxmDNONom0U14PZHHaYY="; }; propagatedBuildInputs = [ From 18ed189365e53f4bdfd023d5b749c8c9f3b8f7ab Mon Sep 17 00:00:00 2001 From: evils <30512529+evils@users.noreply.github.com> Date: Mon, 10 May 2021 22:06:17 +0200 Subject: [PATCH 105/163] python3.pkgs.rtoml: init at 0.6.1 (#122400) --- .../python-modules/rtoml/default.nix | 48 +++++++++++++++++++ pkgs/top-level/python-packages.nix | 2 + 2 files changed, 50 insertions(+) create mode 100644 pkgs/development/python-modules/rtoml/default.nix diff --git a/pkgs/development/python-modules/rtoml/default.nix b/pkgs/development/python-modules/rtoml/default.nix new file mode 100644 index 00000000000..f50ad558176 --- /dev/null +++ b/pkgs/development/python-modules/rtoml/default.nix @@ -0,0 +1,48 @@ +{ lib +, buildPythonPackage +, fetchFromGitHub +, pythonOlder +, setuptools-rust +, rustPlatform +, pytestCheckHook +}: + +buildPythonPackage rec { + pname = "rtoml"; + version = "0.6.1"; + disabled = pythonOlder "3.7"; + + src = fetchFromGitHub { + owner = "samuelcolvin"; + repo = pname; + rev = "v${version}"; + sha256 = "07bf30if1wmbqjp5n4ib43n6frx8ybyxc9fndxncq7aylkrhd7hy"; + }; + + cargoDeps = rustPlatform.fetchCargoTarball { + inherit src; + name = "${pname}-${version}"; + sha256 = "1q082sdac5vm4l3b45rfjp4vppp9y9qhagdjqqfdz8gdhm1k8yyy"; + }; + + nativeBuildInputs = with rustPlatform; [ + setuptools-rust + rust.rustc + rust.cargo + cargoSetupHook + ]; + + pythonImportsCheck = [ "rtoml" ]; + + checkInputs = [ pytestCheckHook ]; + preCheck = '' + cd tests + ''; + + meta = with lib; { + description = "Rust based TOML library for python"; + homepage = "https://github.com/samuelcolvin/rtoml"; + license = licenses.mit; + maintainers = with maintainers; [ evils ]; + }; +} diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index fc4c6e6f1a4..f4f6a4d6e36 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -7216,6 +7216,8 @@ in { rtmidi-python = callPackage ../development/python-modules/rtmidi-python { }; + rtoml = callPackage ../development/python-modules/rtoml { }; + Rtree = callPackage ../development/python-modules/Rtree { inherit (pkgs) libspatialindex; }; From d4077929d6f7f02d75b85f9a5648890db474bde4 Mon Sep 17 00:00:00 2001 From: Hunter Jones Date: Mon, 10 May 2021 15:16:04 -0500 Subject: [PATCH 106/163] kstars: 3.5.2 -> 3.5.3 --- .../science/astronomy/kstars/default.nix | 15 ++--- .../science/astronomy/kstars/fs-fixes.patch | 59 ------------------- 2 files changed, 4 insertions(+), 70 deletions(-) delete mode 100644 pkgs/applications/science/astronomy/kstars/fs-fixes.patch diff --git a/pkgs/applications/science/astronomy/kstars/default.nix b/pkgs/applications/science/astronomy/kstars/default.nix index cd7405ae09d..861dc66293e 100644 --- a/pkgs/applications/science/astronomy/kstars/default.nix +++ b/pkgs/applications/science/astronomy/kstars/default.nix @@ -14,20 +14,13 @@ mkDerivation rec { pname = "kstars"; - version = "3.5.2"; + version = "3.5.3"; src = fetchurl { url = "mirror://kde/stable/kstars/kstars-${version}.tar.xz"; - sha256 = "sha256-iX7rMQbctdK3AeH4ZvH+T4rv1ZHwn55urJh150KoXXU="; + sha256 = "sha256-kgUsG2k2YSAAH7ea2qfGw4gON5CFdUoQ3EwOnATXZ5g="; }; - patches = [ - # Patches ksutils.cpp to use nix store prefixes to find program binaries of - # indilib and xplanet dependencies. Without the patch, Ekos is unable to spawn - # indi servers for local telescope/camera control. - ./fs-fixes.patch - ]; - nativeBuildInputs = [ extra-cmake-modules kdoctools ]; buildInputs = [ kconfig kdoctools kguiaddons ki18n kinit kiconthemes kio @@ -41,8 +34,8 @@ mkDerivation rec { ]; cmakeFlags = [ - "-DINDI_NIX_ROOT=${indi-full}" - "-DXPLANET_NIX_ROOT=${xplanet}" + "-DINDI_PREFIX=${indi-full}" + "-DXPLANET_PREFIX=${xplanet}" ]; meta = with lib; { diff --git a/pkgs/applications/science/astronomy/kstars/fs-fixes.patch b/pkgs/applications/science/astronomy/kstars/fs-fixes.patch deleted file mode 100644 index b9bdfc0c5de..00000000000 --- a/pkgs/applications/science/astronomy/kstars/fs-fixes.patch +++ /dev/null @@ -1,59 +0,0 @@ ---- kstars-3.5.0/CMakeLists.txt.old 2020-11-24 12:36:37.967433937 -0600 -+++ kstars-3.5.0/CMakeLists.txt 2020-11-24 13:36:56.275263691 -0600 -@@ -5,6 +5,9 @@ - set (KSTARS_BUILD_RELEASE "Stable") - set (CMAKE_CXX_STANDARD 11) - -+add_definitions(-DINDI_NIX_ROOT=${INDI_NIX_ROOT}) -+add_definitions(-DXPLANET_NIX_ROOT=${XPLANET_NIX_ROOT}) -+ - # Build KStars Lite with -DBUILD_KSTARS_LITE=ON - option(BUILD_KSTARS_LITE "Build KStars Lite" OFF) - ---- kstars-3.5.0/kstars/auxiliary/ksutils.old.cpp 2020-11-24 12:22:14.397319680 -0600 -+++ kstars-3.5.0/kstars/auxiliary/ksutils.cpp 2020-11-24 13:32:22.946477798 -0600 -@@ -1081,6 +1081,10 @@ - // We support running within Snaps, Flatpaks, and AppImage - // The path should accomodate the differences between the different - // packaging solutions -+ #define STR_EXPAND(x) #x -+ #define STR(x) STR_EXPAND(x) -+ QString indi_prefix = QString(STR(INDI_NIX_ROOT)); -+ QString xplanet_prefix = QString(STR(XPLANET_NIX_ROOT)); - QString snap = QProcessEnvironment::systemEnvironment().value("SNAP"); - QString flat = QProcessEnvironment::systemEnvironment().value("FLATPAK_DEST"); - QString appimg = QProcessEnvironment::systemEnvironment().value("APPDIR"); -@@ -1110,21 +1114,21 @@ - #if defined(Q_OS_OSX) - return "/usr/local/bin/indiserver"; - #endif -- return prefix + "/bin/indiserver"; -+ return indi_prefix + "/bin/indiserver"; - } - else if (option == "INDIHubAgent") - { - #if defined(Q_OS_OSX) - return "/usr/local/bin/indihub-agent"; - #endif -- return prefix + "/bin/indihub-agent"; -+ return indi_prefix + "/bin/indihub-agent"; - } - else if (option == "indiDriversDir") - { - #if defined(Q_OS_OSX) - return "/usr/local/share/indi"; - #elif defined(Q_OS_LINUX) -- return prefix + "/share/indi"; -+ return indi_prefix + "/share/indi"; - #else - return QStandardPaths::locate(QStandardPaths::GenericDataLocation, "indi", QStandardPaths::LocateDirectory); - #endif -@@ -1181,7 +1185,7 @@ - #if defined(Q_OS_OSX) - return "/usr/local/bin/xplanet"; - #endif -- return prefix + "/bin/xplanet"; -+ return xplanet_prefix + "/bin/xplanet"; - } - else if (option == "ASTAP") - { From 27b4fd19ed41d6c747b8e4fc90a835757afd6558 Mon Sep 17 00:00:00 2001 From: Joe DeVivo Date: Tue, 4 May 2021 18:13:42 -0700 Subject: [PATCH 107/163] ssm-agent: copy files required for agent startup --- .../networking/cluster/ssm-agent/default.nix | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/pkgs/applications/networking/cluster/ssm-agent/default.nix b/pkgs/applications/networking/cluster/ssm-agent/default.nix index 3aa583f3ae3..79cf13b4269 100644 --- a/pkgs/applications/networking/cluster/ssm-agent/default.nix +++ b/pkgs/applications/networking/cluster/ssm-agent/default.nix @@ -63,6 +63,9 @@ buildGoPackage rec { substituteInPlace agent/session/shell/shell_unix.go \ --replace '"script"' '"${util-linux}/bin/script"' + substituteInPlace agent/appconfig/constants_unix.go \ + --replace '"/etc/amazon/ssm/"' '"${placeholder "out"}/etc/amazon/ssm/"' + echo "${version}" > VERSION ''; @@ -96,6 +99,20 @@ buildGoPackage rec { popd ''; + # These templates retain their `.template` extensions on installation. The + # amazon-ssm-agent.json.template is required as default configuration when an + # amazon-ssm-agent.json isn't present. Here, we retain the template to show + # we're using the default configuration. + + # seelog.xml isn't actually required to run, but it does ship as a template + # with debian packages, so it's here for reference. Future work in the nixos + # module could use this template and substitute a different log level. + postInstall = '' + mkdir -p $out/etc/amazon/ssm + cp go/src/${goPackagePath}/amazon-ssm-agent.json.template $out/etc/amazon/ssm/amazon-ssm-agent.json.template + cp go/src/${goPackagePath}/seelog_unix.xml $out/etc/amazon/ssm/seelog.xml.template + ''; + postFixup = '' wrapProgram $out/bin/amazon-ssm-agent --prefix PATH : ${bashInteractive}/bin ''; From bf92d0ec3794fcfb8b23bbeb5dd9bf50fbf97bc4 Mon Sep 17 00:00:00 2001 From: Joe DeVivo Date: Sat, 8 May 2021 16:03:38 -0700 Subject: [PATCH 108/163] nixos/ssm-agent: conf files written to /etc ssm-agent expects files in /etc/amazon/ssm. The pkg substitutes a location in the nix store for those default files, but if we ever want to adjust this configuration on NixOS, we'd need the ability to modify that file. This change to the nixos module writes copies of the default files from the nix store to /etc/amazon/ssm. Future versions can add config, but right now this would allow users to at least write out a text value to environment.etc."amazon/ssm/amazon-ssm-agent.json".text to provide their own config. --- nixos/modules/services/misc/ssm-agent.nix | 15 +++++++++++---- .../networking/cluster/ssm-agent/default.nix | 7 ++++--- 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/nixos/modules/services/misc/ssm-agent.nix b/nixos/modules/services/misc/ssm-agent.nix index e50b07e0b86..c29d03d199b 100644 --- a/nixos/modules/services/misc/ssm-agent.nix +++ b/nixos/modules/services/misc/ssm-agent.nix @@ -22,8 +22,8 @@ in { package = mkOption { type = types.path; description = "The SSM agent package to use"; - default = pkgs.ssm-agent; - defaultText = "pkgs.ssm-agent"; + default = pkgs.ssm-agent.override { overrideEtc = false; }; + defaultText = "pkgs.ssm-agent.override { overrideEtc = false; }"; }; }; @@ -37,8 +37,10 @@ in { serviceConfig = { ExecStart = "${cfg.package}/bin/amazon-ssm-agent"; KillMode = "process"; - Restart = "on-failure"; - RestartSec = "15min"; + # We want this restating pretty frequently. It could be our only means + # of accessing the instance. + Restart = "always"; + RestartSec = "1min"; }; }; @@ -62,5 +64,10 @@ in { isNormalUser = true; group = "ssm-user"; }; + + environment.etc."amazon/ssm/seelog.xml".source = "${cfg.package}/seelog.xml.template"; + + environment.etc."amazon/ssm/amazon-ssm-agent.json".source = "${cfg.package}/etc/amazon/ssm/amazon-ssm-agent.json.template"; + }; } diff --git a/pkgs/applications/networking/cluster/ssm-agent/default.nix b/pkgs/applications/networking/cluster/ssm-agent/default.nix index 79cf13b4269..86b48633c25 100644 --- a/pkgs/applications/networking/cluster/ssm-agent/default.nix +++ b/pkgs/applications/networking/cluster/ssm-agent/default.nix @@ -8,6 +8,7 @@ , dmidecode , util-linux , bashInteractive +, overrideEtc ? true }: let @@ -63,10 +64,10 @@ buildGoPackage rec { substituteInPlace agent/session/shell/shell_unix.go \ --replace '"script"' '"${util-linux}/bin/script"' - substituteInPlace agent/appconfig/constants_unix.go \ - --replace '"/etc/amazon/ssm/"' '"${placeholder "out"}/etc/amazon/ssm/"' - echo "${version}" > VERSION + '' + lib.optionalString overrideEtc '' + substituteInPlace agent/appconfig/constants_unix.go \ + --replace '"/etc/amazon/ssm/"' '"${placeholder "out"}/etc/amazon/ssm/"' ''; preBuild = '' From b22dda26a8c1c714b46455d5a81ba557ca917631 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Sun, 9 May 2021 23:15:40 +0200 Subject: [PATCH 109/163] python3Packages.watchdog: 2.0.3 -> 2.1.0 --- pkgs/development/python-modules/watchdog/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/watchdog/default.nix b/pkgs/development/python-modules/watchdog/default.nix index df9586fc8e0..7d7603d3eb0 100644 --- a/pkgs/development/python-modules/watchdog/default.nix +++ b/pkgs/development/python-modules/watchdog/default.nix @@ -11,11 +11,11 @@ buildPythonPackage rec { pname = "watchdog"; - version = "2.0.3"; + version = "2.1.0"; src = fetchPypi { inherit pname version; - sha256 = "sha256-QojTqYQyTbSS5XqhaWZiOKJXjwr1oIFoVSZgj7n2vWE="; + sha256 = "sha256-VTFu+rUvZZuLe1lzBoC/snrAA1IvJMRPa81gxONzbM0="; }; buildInputs = lib.optionals stdenv.isDarwin [ CoreServices ]; From 853c1406962c6833d396029b2c33d728681a5e6a Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Mon, 10 May 2021 22:24:00 +0200 Subject: [PATCH 110/163] haskellPackages: Mark more failing builds broken --- .../haskell-modules/configuration-common.nix | 15 ---- .../configuration-hackage2nix/broken.yaml | 12 ++++ .../configuration-hackage2nix/main.yaml | 69 ------------------- .../transitive-broken.yaml | 43 +++++------- .../haskell-modules/hackage-packages.nix | 49 ++++--------- 5 files changed, 41 insertions(+), 147 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index f50f09ab629..7668d854bb2 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -1037,9 +1037,6 @@ self: super: { # Has tasty < 1.2 requirement, but works just fine with 1.2 temporary-resourcet = doJailbreak super.temporary-resourcet; - # Requires dhall >= 1.23.0 - ats-pkg = dontCheck (super.ats-pkg.override { dhall = self.dhall_1_29_0; }); - # fake a home dir and capture generated man page ats-format = overrideCabal super.ats-format (old : { preConfigure = "export HOME=$PWD"; @@ -1068,18 +1065,6 @@ self: super: { # https://github.com/erikd/hjsmin/issues/32 hjsmin = dontCheck super.hjsmin; - nix-tools = super.nix-tools.overrideScope (self: super: { - # Needs https://github.com/peti/hackage-db/pull/9 - hackage-db = super.hackage-db.overrideAttrs (old: { - src = pkgs.fetchFromGitHub { - owner = "ElvishJerricco"; - repo = "hackage-db"; - rev = "84ca9fc75ad45a71880e938e0d93ea4bde05f5bd"; - sha256 = "0y3kw1hrxhsqmyx59sxba8npj4ya8dpgjljc21gkgdvdy9628q4c"; - }; - }); - }); - # upstream issue: https://github.com/vmchale/atspkg/issues/12 language-ats = dontCheck super.language-ats; diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index d462477e87d..c3f8c09952e 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -5223,3 +5223,15 @@ broken-packages: - ztar - Zwaluw - zxcvbn-dvorak + - ordered + - Hipmunk + - hxt-cache + - Graphalyze + - ribosome + - Thrift + - bindings-levmar + - network-msg + - reflex-dom-helper + - network-metrics + - ats-pkg + - digest-pure diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index e8d904052cd..885ab784f53 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -359,72 +359,3 @@ dont-distribute-packages: - tensorflow-mnist - yices-easy - yices-painless - - # these packages don't evaluate because they have broken (system) dependencies - - XML - - comark - - couch-simple - - diagrams-hsqml - - diagrams-reflex - - dialog - - fltkhs-demos - - fltkhs-fluid-demos - - fltkhs-hello-world - - fltkhs-themes - - ghcjs-dom-hello - - ghcjs-dom-webkit - - gi-javascriptcore - - gi-webkit - - gi-webkit2 - - gi-webkit2webextension - - gsmenu - - haste-gapi - - haste-perch - - hbro - - hplayground - - hs-mesos - - hsqml - - hsqml-datamodel - - hsqml-datamodel-vinyl - - hsqml-datemodel-vinyl - - hsqml-demo-manic - - hsqml-demo-morris - - hsqml-demo-notes - - hsqml-demo-notes - - hsqml-demo-samples - - hsqml-morris - - hsqml-morris - - hstorchat - - imprevu-happstack - - jsaddle-webkit2gtk - - jsaddle-webkitgtk - - jsc - - lambdacat - - leksah - - manatee-all - - manatee-browser - - manatee-reader - - markup-preview - - nomyx-api - - nomyx-core - - nomyx-language - - nomyx-library - - nomyx-server - - passman-cli - - passman-core - - reflex-dom-colonnade - - reflex-dom-contrib - - reflex-dom-fragment-shader-canvas - - reflex-dom-helpers - - reflex-jsx - - sneathlane-haste - - spike - - tianbar - - trasa-reflex - - treersec - - wai-middleware-brotli - - web-browser-in-haskell - - webkit - - webkitgtk3 - - webkitgtk3-javascriptcore - - websnap diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 7c92552682f..5b23793a9f1 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -7,7 +7,6 @@ dont-distribute-packages: - 4Blocks - a50 - abcBridge - - abeson - AbortT-monadstf - AbortT-mtl - accelerate-arithmetic @@ -36,8 +35,6 @@ dont-distribute-packages: - AERN-Real-Interval - AERN-RnToRm - AERN-RnToRm-Plot - - aeson-bson - - AesonBson - aeson-native - afv - agda-server @@ -299,10 +296,6 @@ dont-distribute-packages: - bronyradiogermany-streaming - brotli-conduit - brotli-streams - - bson-generic - - bson-generics - - bson-lens - - bson-mapping - b-tree - btree - buchhaltung @@ -354,6 +347,7 @@ dont-distribute-packages: - casadi-bindings-snopt-interface - cash - cassandra-cql + - cassandra-thrift - cassy - casui - categorical-algebra @@ -392,6 +386,7 @@ dont-distribute-packages: - chp-transformers - chr-core - chr-lang + - chromatin - chu2 - chunks - ciphersaber2 @@ -549,7 +544,6 @@ dont-distribute-packages: - csv-enumerator - ctpl - cube - - currency-codes - cursedcsv - cv-combinators - cypher @@ -856,7 +850,6 @@ dont-distribute-packages: - follower - foo - Forestry - - forex2ledger - formal - FormalGrammars - format @@ -931,12 +924,14 @@ dont-distribute-packages: - generics-mrsop-gdiff - genesis - genesis-test + - GenI - geniconvert - geni-gui + - geniserver + - geni-util - GenSmsPdu - GenussFold - geodetic - - geojson-types - geolite-csv - getemx - ghc-imported-from @@ -1036,7 +1031,6 @@ dont-distribute-packages: - graph-visit - greencard-lib - gridbounds - - gridfs - gridland - grid-proto - GrowlNotify @@ -1331,6 +1325,7 @@ dont-distribute-packages: - hinze-streams - hipbot - HipmunkPlayground + - Hipmunk-Utils - hipsql-client - hipsql-server - hirt @@ -1370,6 +1365,7 @@ dont-distribute-packages: - hogre-examples - Holumbus-Distribution - Holumbus-MapReduce + - Holumbus-Searchengine - Holumbus-Storage - holy-project - hommage @@ -1440,6 +1436,7 @@ dont-distribute-packages: - hsc3-sf-hsndfile - hsc3-unsafe - hsc3-utils + - hscassandra - hscope - hsdev - Hsed @@ -1776,6 +1773,8 @@ dont-distribute-packages: - leksah - leksah-server - lens-utils + - levmar + - levmar-chart - lex-applicative - lgtk - lha @@ -1927,6 +1926,7 @@ dont-distribute-packages: - MC-Fold-DP - mcmc - mcmc-samplers + - mDNSResponder-client - mealy - mediabus-fdk-aac - mediabus-rtp @@ -1978,7 +1978,6 @@ dont-distribute-packages: - modular-prelude-classy - modulo - mole - - mollie-api-haskell - MonadCatchIO-mtl - MonadCatchIO-mtl-foreign - MonadCatchIO-transformers-foreign @@ -1991,8 +1990,6 @@ dont-distribute-packages: - Monaris - Monatron-IO - monetdb-mapi - - mongoDB - - mongodb-queue - mongrel2-handler - monky - Monocle @@ -2034,6 +2031,7 @@ dont-distribute-packages: - multisetrewrite - murder - murmurhash3 + - musicbrainz-email - music-graphics - music-parts - music-pitch @@ -2208,10 +2206,8 @@ dont-distribute-packages: - periodic-server - perm - PermuteEffects - - persistent-audit - persistent-hssqlppp - persistent-map - - persistent-mongoDB - persona-idp - peyotls - peyotls-codec @@ -2236,7 +2232,6 @@ dont-distribute-packages: - pipes-files - pipes-illumina - pipes-key-value-csv - - pipes-mongodb - pipes-p2p - pipes-p2p-examples - pisigma @@ -2311,11 +2306,11 @@ dont-distribute-packages: - progressbar - project-m36 - prologue - - prolude - prometheus-effect - propane - proplang - prosidyc + - proteome - proto3-suite - protobuf-native - protocol-buffers-descriptor-fork @@ -2504,6 +2499,8 @@ dont-distribute-packages: - rfc-servant - rhythm-game-tutorial - rib + - ribosome-root + - ribosome-test - ridley-extras - rio-process-pool - riot @@ -2612,7 +2609,6 @@ dont-distribute-packages: - SelectSequencesFromMSA - selenium-server - self-extract - - Semantique - semi-iso - semiring - semiring-num @@ -2733,14 +2729,12 @@ dont-distribute-packages: - snaplet-actionlog - snaplet-auth-acid - snaplet-coffee - - snaplet-environments - snaplet-hasql - snaplet-haxl - snaplet-hdbc - snaplet-lss - snaplet-mandrill - snaplet-mongoDB - - snaplet-mongodb-minimalistic - snaplet-mysql-simple - snaplet-oauth - snaplet-postmark @@ -2773,6 +2767,7 @@ dont-distribute-packages: - sounddelay - soundgen - source-code-server + - SourceGraph - sparkle - sparrow - sparsebit @@ -2822,6 +2817,7 @@ dont-distribute-packages: - starrover2 - stateful-mtl - static-closure + - statsd-client - statsdi - STLinkUSB - STM32-Zombie @@ -3273,12 +3269,7 @@ dont-distribute-packages: - yoko - york-lava - yql - - yu-auth - - yu-core - - yu-launch - - yu-tool - yuuko - - yu-utils - zasni-gerna - zephyr - zerobin diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 1fe4f0c6c04..6bc723606b8 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -7537,6 +7537,7 @@ self: { description = "Graph-Theoretic Analysis library"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Grempa" = callPackage @@ -10313,6 +10314,7 @@ self: { description = "A Haskell binding for Chipmunk"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Hipmunk-Utils" = callPackage @@ -19772,6 +19774,7 @@ self: { description = "Haskell bindings for the Apache Thrift RPC system"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Tic-Tac-Toe" = callPackage @@ -34653,6 +34656,8 @@ self: { doHaddock = false; description = "A build tool for ATS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ats-setup" = callPackage @@ -41089,6 +41094,7 @@ self: { description = "Low level bindings to the C levmar (Levenberg-Marquardt) library"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) blas; liblapack = null;}; "bindings-libcddb" = callPackage @@ -74034,7 +74040,6 @@ self: { ]; description = "HsQML (Qt5) backend for Diagrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "diagrams-html5" = callPackage @@ -74229,7 +74234,6 @@ self: { ]; description = "reflex backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "diagrams-rubiks-cube" = callPackage @@ -74332,7 +74336,6 @@ self: { ]; description = "Simple dialog-based user interfaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "dialogflow-fulfillment" = callPackage @@ -74748,6 +74751,7 @@ self: { description = "Pure hash functions for bytestrings"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digest-sig" = callPackage @@ -101661,7 +101665,6 @@ self: { ]; description = "GHCJS DOM Hello World, an example package"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "ghcjs-dom-jsaddle" = callPackage @@ -101700,7 +101703,6 @@ self: { ]; description = "DOM library that supports both GHCJS and WebKitGTK"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "ghcjs-fetch" = callPackage @@ -103092,7 +103094,6 @@ self: { libraryPkgconfigDepends = [ webkitgtk ]; description = "JavaScriptCore bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk;}; "gi-javascriptcore_4_0_23" = callPackage @@ -103390,7 +103391,6 @@ self: { doHaddock = false; description = "WebKit bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk24x-gtk3;}; "gi-webkit2" = callPackage @@ -103415,7 +103415,6 @@ self: { libraryPkgconfigDepends = [ webkitgtk ]; description = "WebKit2 bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk;}; "gi-webkit2_4_0_27" = callPackage @@ -103465,7 +103464,6 @@ self: { libraryPkgconfigDepends = [ webkitgtk ]; description = "WebKit2-WebExtension bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk;}; "gi-wnck" = callPackage @@ -133986,7 +133984,6 @@ self: { tasty-quickcheck ]; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {mesos = null; inherit (pkgs) protobuf;}; "hs-multiaddr" = callPackage @@ -137656,7 +137653,6 @@ self: { ]; description = "Haskell binding for Qt Quick"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {qt5 = null;}; "hsqml-datamodel" = callPackage @@ -137669,7 +137665,6 @@ self: { libraryPkgconfigDepends = [ qt5 ]; description = "HsQML (Qt5) data model"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {qt5 = null;}; "hsqml-datamodel-vinyl" = callPackage @@ -137702,7 +137697,6 @@ self: { ]; description = "HsQML-based clone of Pipe Mania"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hsqml-demo-morris" = callPackage @@ -137740,7 +137734,6 @@ self: { ]; description = "Sticky notes example program implemented in HsQML"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hsqml-demo-samples" = callPackage @@ -137755,7 +137748,6 @@ self: { executableHaskellDepends = [ base hsqml OpenGL OpenGLRaw text ]; description = "HsQML sample programs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hsqml-morris" = callPackage @@ -138048,7 +138040,6 @@ self: { ]; description = "Distributed instant messaging over Tor"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "hstox" = callPackage @@ -142615,6 +142606,7 @@ self: { description = "Cache for HXT XML Documents and other binary data"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hxt-charproperties" = callPackage @@ -151315,7 +151307,6 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "jsaddle-webkitgtk" = callPackage @@ -151334,7 +151325,6 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "jsaddle-wkwebview" = callPackage @@ -151369,7 +151359,6 @@ self: { ]; description = "High level interface for webkit-javascriptcore"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "jsmw" = callPackage @@ -156350,7 +156339,6 @@ self: { ]; description = "Webkit Browser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "lambdacms-core" = callPackage @@ -168329,7 +168317,6 @@ self: { doHaddock = false; description = "Virtual package to install all Manatee packages"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "manatee-anything" = callPackage @@ -168370,7 +168357,6 @@ self: { ]; description = "Browser extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "manatee-core" = callPackage @@ -168589,7 +168575,6 @@ self: { ]; description = "Feed reader extension for Manatee"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "manatee-template" = callPackage @@ -169231,7 +169216,6 @@ self: { ]; description = "A simple markup document preview (markdown, textile, reStructuredText)"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; }) {}; "marmalade-upload" = callPackage @@ -184011,6 +183995,7 @@ self: { description = "Send metrics to Ganglia, Graphite, and statsd"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-minihttp" = callPackage @@ -184043,6 +184028,7 @@ self: { description = "Recvmsg and sendmsg bindings"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "network-msgpack-rpc" = callPackage @@ -191386,6 +191372,7 @@ self: { description = "A definition of Posets"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ordered-containers" = callPackage @@ -195242,7 +195229,6 @@ self: { ]; description = "Deterministic password generator command line interface"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "passman-core" = callPackage @@ -195268,7 +195254,6 @@ self: { doHaddock = false; description = "Deterministic password generator core"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "password" = callPackage @@ -217354,7 +217339,6 @@ self: { ]; description = "A playground for experimenting with infrastructure and common code for reflex applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "reflex-dom-core" = callPackage @@ -217414,7 +217398,6 @@ self: { executableHaskellDepends = [ base reflex-dom text ]; description = "A reflex-dom widget to draw on a canvas with a fragment shader program"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "reflex-dom-helpers" = callPackage @@ -217431,7 +217414,6 @@ self: { testHaskellDepends = [ base ]; description = "Html tag helpers for reflex-dom"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "reflex-dom-pandoc" = callPackage @@ -217679,7 +217661,6 @@ self: { ]; description = "Use jsx-like syntax in Reflex"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "reflex-libtelnet" = callPackage @@ -221976,6 +221957,7 @@ self: { description = "api extensions for nvim-hs"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ribosome-root" = callPackage @@ -242211,7 +242193,6 @@ self: { executablePkgconfigDepends = [ libsoup ]; description = "Experimental web browser"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libsoup;}; "spine" = callPackage @@ -259069,7 +259050,6 @@ self: { ]; description = "A desktop bar based on WebKit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gtk3; inherit (pkgs) webkitgtk;}; "tibetan-utils" = callPackage @@ -276930,7 +276910,6 @@ self: { libraryHaskellDepends = [ base gtk webkit ]; description = "Web Browser In Haskell"; license = "GPL"; - hydraPlatforms = lib.platforms.none; }) {}; "web-css" = callPackage @@ -277810,7 +277789,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the Webkit library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; }) {webkit = null;}; "webkit-javascriptcore" = callPackage @@ -277862,7 +277840,6 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the Webkit library"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk24x-gtk3;}; "webkitgtk3-javascriptcore" = callPackage @@ -277877,7 +277854,6 @@ self: { libraryPkgconfigDepends = [ webkitgtk24x-gtk3 ]; description = "JavaScriptCore FFI from webkitgtk"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk24x-gtk3;}; "webmention" = callPackage @@ -277997,7 +277973,6 @@ self: { executableHaskellDepends = [ base filepath gtk webkit ]; description = "Transforms URLs to PNGs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "websockets" = callPackage From 912c7bd20dc0e2a14430ca00037ee81b59608b7b Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 4 May 2021 18:16:00 +0200 Subject: [PATCH 111/163] maintainers/scripts/haskell/hydra-report.hs: init --- maintainers/scripts/haskell/hydra-report.hs | 306 ++++++++++++++++++++ 1 file changed, 306 insertions(+) create mode 100755 maintainers/scripts/haskell/hydra-report.hs diff --git a/maintainers/scripts/haskell/hydra-report.hs b/maintainers/scripts/haskell/hydra-report.hs new file mode 100755 index 00000000000..20b856c42e3 --- /dev/null +++ b/maintainers/scripts/haskell/hydra-report.hs @@ -0,0 +1,306 @@ +#! /usr/bin/env nix-shell +#! nix-shell -p "haskellPackages.ghcWithPackages (p: [p.aeson p.req])" +#! nix-shell -p hydra-unstable +#! nix-shell -i runhaskell + +{- + +The purpose of this script is + +1) download the state of the nixpkgs/haskell-updates job from hydra (with get-report) +2) print a summary of the state suitable for pasting into a github comment (with ping-maintainers) +3) print a list of broken packages suitable for pasting into configuration-hackage2nix.yaml + +Because step 1) is very expensive and takes roughly ~30 minutes the result is cached in a json file in XDG_CACHE. + +-} +{-# LANGUAGE BlockArguments #-} +{-# LANGUAGE DeriveAnyClass #-} +{-# LANGUAGE DeriveGeneric #-} +{-# LANGUAGE DuplicateRecordFields #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE MultiWayIf #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TupleSections #-} + +import Control.Monad (forM, forM_, (<=<)) +import Control.Monad.Trans (MonadIO (liftIO)) +import Data.Aeson ( + FromJSON, + ToJSON, + decodeFileStrict', + eitherDecodeStrict', + encodeFile, + ) +import qualified Data.ByteString.Char8 as ByteString +import Data.Either (fromRight) +import Data.Foldable (Foldable (toList), fold, foldl') +import Data.Function ((&)) +import Data.Functor ((<&>)) +import Data.List.NonEmpty (NonEmpty, nonEmpty) +import qualified Data.List.NonEmpty as NonEmpty +import Data.Map.Strict (Map) +import qualified Data.Map.Strict as Map +import Data.Maybe (fromMaybe, mapMaybe) +import Data.Monoid (Sum (Sum, getSum)) +import Data.Semigroup (Min (Min, getMin)) +import Data.Sequence (Seq) +import qualified Data.Sequence as Seq +import Data.Set (Set) +import qualified Data.Set as Set +import Data.Text (Text) +import qualified Data.Text as Text +import Data.Text.Encoding (encodeUtf8) +import Data.Time (defaultTimeLocale, formatTime, getCurrentTime) +import Data.Time.Clock (UTCTime) +import GHC.Generics (Generic) +import Network.HTTP.Req ( + GET (GET), + NoReqBody (NoReqBody), + defaultHttpConfig, + https, + jsonResponse, + req, + responseBody, + runReq, + (/:), + ) +import System.Directory (XdgDirectory (XdgCache), getXdgDirectory) +import System.Environment (getArgs) +import System.Process (readProcess) + +newtype JobsetEvals = JobsetEvals + { evals :: Seq Eval + } + deriving (Generic, ToJSON, FromJSON, Show) + +newtype Nixpkgs = Nixpkgs {revision :: Text} + deriving (Generic, ToJSON, FromJSON, Show) + +newtype JobsetEvalInputs = JobsetEvalInputs {nixpkgs :: Nixpkgs} + deriving (Generic, ToJSON, FromJSON, Show) + +data Eval = Eval + { builds :: Seq Int + , id :: Int + , jobsetevalinputs :: JobsetEvalInputs + } + deriving (Generic, ToJSON, FromJSON, Show) + +data Build = Build + { job :: Text + , buildstatus :: Int + , finished :: Int + , id :: Int + , nixname :: Text + , system :: Text + , jobsetevals :: Seq Int + } + deriving (Generic, ToJSON, FromJSON, Show) + +main :: IO () +main = do + args <- getArgs + case args of + ["get-report"] -> getBuildReports + ["ping-maintainers"] -> printMaintainerPing + ["mark-broken-list"] -> printMarkBrokenList + _ -> putStrLn "Usage: get-report | ping-maintainers | mark-broken-list" + +reportFileName :: IO FilePath +reportFileName = getXdgDirectory XdgCache "haskell-updates-build-report.json" + +showT :: Show a => a -> Text +showT = Text.pack . show + +getBuildReports :: IO () +getBuildReports = runReq defaultHttpConfig $ do + -- GET request http response + now <- liftIO getCurrentTime + r <- req GET (https "hydra.nixos.org" /: "jobset" /: "nixpkgs" /: "haskell-updates" /: "evals") NoReqBody jsonResponse mempty + let eval = Seq.lookup 0 . evals $ (responseBody r :: JobsetEvals) + eval & maybe (liftIO $ putStrLn "No Evalution found") \eval -> do + (buildReports :: Seq Build) <- forM (builds eval) \buildId -> + responseBody <$> req GET (https "hydra.nixos.org" /: "build" /: showT buildId) NoReqBody jsonResponse mempty + fileName <- liftIO reportFileName + liftIO $ encodeFile fileName (eval, now, buildReports) + +hydraEvalCommand = "hydra-eval-jobs" +hydraEvalParams = ["-I", ".", "pkgs/top-level/release-haskell.nix"] +handlesCommand = "nix-instantiate" +handlesParams = ["--eval", "--strict", "--json", "-"] +handlesExpression = "with import ./. {}; with lib; zipAttrsWith (_: builtins.head) (mapAttrsToList (_: v: if v ? github then { \"${v.email}\" = v.github; } else {}) (import maintainers/maintainer-list.nix))" + +newtype Maintainers = Maintainers {maintainers :: Text} deriving (Generic, ToJSON, FromJSON) + +type HydraJobs = Map Text Maintainers +type MaintainerMap = Map Text (NonEmpty Text) + +getMaintainerMap :: IO MaintainerMap +getMaintainerMap = do + hydraJobs :: HydraJobs <- get hydraEvalCommand hydraEvalParams "" "Failed to decode hydra-eval-jobs output: " + handlesMap :: Map Text Text <- get handlesCommand handlesParams handlesExpression "Failed to decode nix output for lookup of github handles: " + pure $ hydraJobs & Map.mapMaybe (nonEmpty . mapMaybe (`Map.lookup` handlesMap) . Text.splitOn ", " . maintainers) + where + get c p i e = readProcess c p i <&> \x -> either (error . (<> "Raw:'" <> x <> "'") . (e <>)) Prelude.id . eitherDecodeStrict' . encodeUtf8 . Text.pack $ x + +-- BuildStates are sorted by subjective importance/concerningness +data BuildState = Failed | DependencyFailed | OutputLimitExceeded | Unknown Int | Aborted | Unfinished | Success deriving (Show, Eq, Ord) + +icon :: BuildState -> Text +icon = \case + Failed -> ":x:" + DependencyFailed -> ":heavy_exclamation_mark:" + OutputLimitExceeded -> ":warning:" + Unknown x -> "unknown code " <> showT x + Aborted -> ":no_entry:" + Unfinished -> ":hourglas_flowing_sand:" + Success -> ":heavy_check_mark:" + +platformIcon :: Platform -> Text +platformIcon (Platform x) = case x of + "x86_64-linux" -> ":penguin:" + "aarch64-linux" -> ":iphone:" + "x86_64-darwin" -> ":apple:" + _ -> x + +data BuildResult = BuildResult {state :: BuildState, id :: Int} deriving (Show, Eq, Ord) +newtype Platform = Platform {platform :: Text} deriving (Show, Eq, Ord) +newtype Table row col a = Table (Map (row, col) a) +type StatusSummary = Map Text (Table Text Platform BuildResult, Set Text) + +instance (Ord row, Ord col, Semigroup a) => Semigroup (Table row col a) where + Table l <> Table r = Table (Map.unionWith (<>) l r) +instance (Ord row, Ord col, Semigroup a) => Monoid (Table row col a) where + mempty = Table Map.empty +instance Functor (Table row col) where + fmap f (Table a) = Table (fmap f a) +instance Foldable (Table row col) where + foldMap f (Table a) = foldMap f a + +buildSummary :: MaintainerMap -> Seq Build -> StatusSummary +buildSummary maintainerMap = foldl (Map.unionWith unionSummary) Map.empty . fmap toSummary + where + unionSummary (Table l, l') (Table r, r') = (Table $ Map.union l r, l' <> r') + toSummary Build{finished, buildstatus, job, id, system, nixname} = Map.singleton name (Table (Map.singleton (set, Platform system) (BuildResult state id)), maintainers) + where + state = case (finished, buildstatus) of + (0, _) -> Unfinished + (_, 0) -> Success + (_, 7) -> Aborted + (_, 2) -> DependencyFailed + (_, 1) -> Failed + (_, 11) -> OutputLimitExceeded + (_, i) -> Unknown i + packageName = fromMaybe job (Text.stripSuffix ("." <> system) job) + splitted = nonEmpty $ Text.splitOn "." packageName + name = maybe packageName NonEmpty.last splitted + set = maybe "" (Text.intercalate "." . NonEmpty.init) splitted + maintainers = maybe mempty (Set.fromList . toList) (Map.lookup job maintainerMap) + +readBuildReports :: IO (Eval, UTCTime, Seq Build) +readBuildReports = do + file <- reportFileName + fromMaybe (error $ "Could not decode " <> file) <$> decodeFileStrict' file + +sep :: Text +sep = " | " +joinTable :: [Text] -> Text +joinTable t = sep <> Text.intercalate sep t <> sep + +type NumSummary = Table Platform BuildState Int + +printTable :: (Ord rows, Ord cols) => Text -> (rows -> Text) -> (cols -> Text) -> (entries -> Text) -> Table rows cols entries -> [Text] +printTable name showR showC showE (Table mapping) = joinTable <$> (name : map showC cols) : replicate (length cols + sepsInName + 1) "---" : map printRow rows + where + sepsInName = Text.count "|" name + printRow row = showR row : map (\col -> maybe "" showE (Map.lookup (row, col) mapping)) cols + rows = toList $ Set.fromList (fst <$> Map.keys mapping) + cols = toList $ Set.fromList (snd <$> Map.keys mapping) + +printJob :: Text -> (Table Text Platform BuildResult, Text) -> [Text] +printJob name (Table mapping, maintainers) = + if length sets <= 1 + then map printSingleRow sets + else ["- [ ] " <> name <> " " <> maintainers] <> map printRow sets + where + printRow set = " - " <> printState set <> " " <> (if Text.null set then "toplevel" else set) + printSingleRow set = "- [ ] " <> printState set <> " " <> (if Text.null set then "" else set <> ".") <> name <> " " <> maintainers + printState set = Text.intercalate " " $ map (\pf -> maybe "" (label pf) $ Map.lookup (set, pf) mapping) platforms + sets = toList $ Set.fromList (fst <$> Map.keys mapping) + platforms = toList $ Set.fromList (snd <$> Map.keys mapping) + label pf (BuildResult s i) = "[[" <> platformIcon pf <> icon s <> "]](https://hydra.nixos.org/build/" <> showT i <> ")" + +statusToNumSummary :: StatusSummary -> NumSummary +statusToNumSummary = fmap getSum . foldMap (fmap Sum . jobTotals) + +jobTotals :: (Table Text Platform BuildResult, a) -> Table Platform BuildState Int +jobTotals (Table mapping, _) = getSum <$> Table (Map.foldMapWithKey (\(set, platform) (BuildResult buildstate _) -> Map.singleton (platform, buildstate) (Sum 1)) mapping) + +details :: Text -> [Text] -> [Text] +details summary content = ["
" <> summary <> " ", ""] <> content <> ["
", ""] + +printBuildSummary :: Eval -> UTCTime -> StatusSummary -> Text +printBuildSummary + Eval{id, jobsetevalinputs = JobsetEvalInputs{nixpkgs = Nixpkgs{revision}}} + fetchTime + summary = + Text.unlines $ + header <> totals + <> optionalList "#### Maintained packages with build failure" (maintainedList fails) + <> optionalList "#### Maintained packages with failed dependency" (maintainedList failedDeps) + <> optionalList "#### Maintained packages with unknown error" (maintainedList unknownErr) + <> optionalHideableList "#### Unmaintained packages with build failure" (unmaintainedList fails) + <> optionalHideableList "#### Unmaintained packages with failed dependency" (unmaintainedList failedDeps) + <> optionalHideableList "#### Unmaintained packages with unknown error" (unmaintainedList unknownErr) + <> footer + where + footer = ["*Report generated with [maintainers/scripts/haskell/hydra-report.hs](https://github.com/NixOS/nixpkgs/blob/haskell-updates/maintainers/scripts/haskell/hydra-report.sh)*"] + totals = + [ "#### Build summary" + , "" + ] + <> printTable "Platform" (\x -> platform x <> " " <> platformIcon x) (\x -> showT x <> " " <> icon x) showT (statusToNumSummary summary) + header = + [ "### [haskell-updates build report from hydra](https://hydra.nixos.org/jobset/nixpkgs/haskell-updates)" + , "*" + <> "evaluation [" + <> showT id + <> "](https://hydra.nixos.org/eval/" + <> showT id + <> ") of nixpkgs commit [" + <> Text.take 7 revision + <> "](https://github.com/NixOS/nixpkgs/commits/" + <> revision + <> ") as of " + <> Text.pack (formatTime defaultTimeLocale "%Y-%m-%d %H:%M UTC" fetchTime) + <> "*" + ] + jobsByState pred = Map.filter (pred . foldl' min Success . fmap state . fst) summary + fails = jobsByState (== Failed) + failedDeps = jobsByState (== DependencyFailed) + unknownErr = jobsByState (\x -> x > DependencyFailed && x < Aborted) + withMaintainer = Map.mapMaybe (\(x, m) -> (x,) <$> nonEmpty (Set.toList m)) + withoutMaintainer = Map.mapMaybe (\(x, m) -> if Set.null m then Just x else Nothing) + optionalList header list = if null list then mempty else [header] <> list + optionalHideableList header list = if null list then mempty else [header] <> details (showT (length list) <> " job(s)") list + maintainedList = showMaintainedBuild <=< Map.toList . withMaintainer + unmaintainedList = showBuild <=< Map.toList . withoutMaintainer + showBuild (name, table) = printJob name (table, "") + showMaintainedBuild (name, (table, maintainers)) = printJob name (table, Text.intercalate " " (fmap ("@" <>) (toList maintainers))) + +printMaintainerPing :: IO () +printMaintainerPing = do + maintainerMap <- getMaintainerMap + (eval, fetchTime, buildReport) <- readBuildReports + putStrLn (Text.unpack (printBuildSummary eval fetchTime (buildSummary maintainerMap buildReport))) + +printMarkBrokenList :: IO () +printMarkBrokenList = do + (_, _, buildReport) <- readBuildReports + forM_ buildReport \Build{buildstatus, job} -> + case (buildstatus, Text.splitOn "." job) of + (1, ["haskellPackages", name, "x86_64-linux"]) -> putStrLn $ " - " <> Text.unpack name + _ -> pure () From 277bb664de43f757c5afcf7e2d414e6b94583022 Mon Sep 17 00:00:00 2001 From: "(cdep)illabout" Date: Sat, 8 May 2021 14:15:20 +0900 Subject: [PATCH 112/163] maintainers/scripts/haskell/hydra-report.hs: Use only 2 queries to get report --- maintainers/scripts/haskell/hydra-report.hs | 31 +++++++++++---------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/maintainers/scripts/haskell/hydra-report.hs b/maintainers/scripts/haskell/hydra-report.hs index 20b856c42e3..e3250ecc311 100755 --- a/maintainers/scripts/haskell/hydra-report.hs +++ b/maintainers/scripts/haskell/hydra-report.hs @@ -11,7 +11,7 @@ The purpose of this script is 2) print a summary of the state suitable for pasting into a github comment (with ping-maintainers) 3) print a list of broken packages suitable for pasting into configuration-hackage2nix.yaml -Because step 1) is very expensive and takes roughly ~30 minutes the result is cached in a json file in XDG_CACHE. +Because step 1) is quite expensive and takes roughly ~5 minutes the result is cached in a json file in XDG_CACHE. -} {-# LANGUAGE BlockArguments #-} @@ -25,7 +25,7 @@ Because step 1) is very expensive and takes roughly ~30 minutes the result is ca {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TupleSections #-} -import Control.Monad (forM, forM_, (<=<)) +import Control.Monad (forM, forM_, when, (<=<)) import Control.Monad.Trans (MonadIO (liftIO)) import Data.Aeson ( FromJSON, @@ -60,10 +60,12 @@ import Network.HTTP.Req ( GET (GET), NoReqBody (NoReqBody), defaultHttpConfig, + header, https, jsonResponse, req, responseBody, + responseTimeout, runReq, (/:), ) @@ -83,8 +85,7 @@ newtype JobsetEvalInputs = JobsetEvalInputs {nixpkgs :: Nixpkgs} deriving (Generic, ToJSON, FromJSON, Show) data Eval = Eval - { builds :: Seq Int - , id :: Int + { id :: Int , jobsetevalinputs :: JobsetEvalInputs } deriving (Generic, ToJSON, FromJSON, Show) @@ -116,16 +117,18 @@ showT :: Show a => a -> Text showT = Text.pack . show getBuildReports :: IO () -getBuildReports = runReq defaultHttpConfig $ do - -- GET request http response - now <- liftIO getCurrentTime - r <- req GET (https "hydra.nixos.org" /: "jobset" /: "nixpkgs" /: "haskell-updates" /: "evals") NoReqBody jsonResponse mempty - let eval = Seq.lookup 0 . evals $ (responseBody r :: JobsetEvals) - eval & maybe (liftIO $ putStrLn "No Evalution found") \eval -> do - (buildReports :: Seq Build) <- forM (builds eval) \buildId -> - responseBody <$> req GET (https "hydra.nixos.org" /: "build" /: showT buildId) NoReqBody jsonResponse mempty - fileName <- liftIO reportFileName - liftIO $ encodeFile fileName (eval, now, buildReports) +getBuildReports = runReq defaultHttpConfig do + evalMay <- Seq.lookup 0 . evals <$> myReq (https "hydra.nixos.org" /: "jobset" /: "nixpkgs" /: "haskell-updates" /: "evals") mempty + eval@Eval{id} <- maybe (liftIO $ fail "No Evalution found") pure evalMay + liftIO . putStrLn $ "Fetching evaluation " <> show id <> " from Hydra. This might take a few minutes..." + buildReports :: Seq Build <- myReq (https "hydra.nixos.org" /: "eval" /: showT id /: "builds") (responseTimeout 600000000) + liftIO do + fileName <- reportFileName + putStrLn $ "Finished fetching all builds from Hydra, saving report as " <> fileName + now <- getCurrentTime + encodeFile fileName (eval, now, buildReports) + where + myReq query option = responseBody <$> req GET query NoReqBody jsonResponse (header "User-Agent" "hydra-report.hs/v1 (nixkpgs;maintainers/scripts/haskell)" <> option) hydraEvalCommand = "hydra-eval-jobs" hydraEvalParams = ["-I", ".", "pkgs/top-level/release-haskell.nix"] From df0572cf3a34a73a66f2437c6737ceed2f26b3a3 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Sun, 9 May 2021 00:37:05 +0200 Subject: [PATCH 113/163] maintainers/scripts/haskell/hydra-report.hs: Enable warnings and small refactoring --- maintainers/scripts/haskell/hydra-report.hs | 34 ++++++++++++--------- 1 file changed, 19 insertions(+), 15 deletions(-) diff --git a/maintainers/scripts/haskell/hydra-report.hs b/maintainers/scripts/haskell/hydra-report.hs index e3250ecc311..9e1641ce8f8 100755 --- a/maintainers/scripts/haskell/hydra-report.hs +++ b/maintainers/scripts/haskell/hydra-report.hs @@ -24,8 +24,9 @@ Because step 1) is quite expensive and takes roughly ~5 minutes the result is ca {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TupleSections #-} +{-# OPTIONS_GHC -Wall #-} -import Control.Monad (forM, forM_, when, (<=<)) +import Control.Monad (forM_, (<=<)) import Control.Monad.Trans (MonadIO (liftIO)) import Data.Aeson ( FromJSON, @@ -34,9 +35,7 @@ import Data.Aeson ( eitherDecodeStrict', encodeFile, ) -import qualified Data.ByteString.Char8 as ByteString -import Data.Either (fromRight) -import Data.Foldable (Foldable (toList), fold, foldl') +import Data.Foldable (Foldable (toList), foldl') import Data.Function ((&)) import Data.Functor ((<&>)) import Data.List.NonEmpty (NonEmpty, nonEmpty) @@ -45,7 +44,6 @@ import Data.Map.Strict (Map) import qualified Data.Map.Strict as Map import Data.Maybe (fromMaybe, mapMaybe) import Data.Monoid (Sum (Sum, getSum)) -import Data.Semigroup (Min (Min, getMin)) import Data.Sequence (Seq) import qualified Data.Sequence as Seq import Data.Set (Set) @@ -72,6 +70,8 @@ import Network.HTTP.Req ( import System.Directory (XdgDirectory (XdgCache), getXdgDirectory) import System.Environment (getArgs) import System.Process (readProcess) +import Prelude hiding (id) +import qualified Prelude newtype JobsetEvals = JobsetEvals { evals :: Seq Eval @@ -130,10 +130,15 @@ getBuildReports = runReq defaultHttpConfig do where myReq query option = responseBody <$> req GET query NoReqBody jsonResponse (header "User-Agent" "hydra-report.hs/v1 (nixkpgs;maintainers/scripts/haskell)" <> option) +hydraEvalCommand :: FilePath hydraEvalCommand = "hydra-eval-jobs" +hydraEvalParams :: [String] hydraEvalParams = ["-I", ".", "pkgs/top-level/release-haskell.nix"] +handlesCommand :: FilePath handlesCommand = "nix-instantiate" +handlesParams :: [String] handlesParams = ["--eval", "--strict", "--json", "-"] +handlesExpression :: String handlesExpression = "with import ./. {}; with lib; zipAttrsWith (_: builtins.head) (mapAttrsToList (_: v: if v ? github then { \"${v.email}\" = v.github; } else {}) (import maintainers/maintainer-list.nix))" newtype Maintainers = Maintainers {maintainers :: Text} deriving (Generic, ToJSON, FromJSON) @@ -159,7 +164,7 @@ icon = \case OutputLimitExceeded -> ":warning:" Unknown x -> "unknown code " <> showT x Aborted -> ":no_entry:" - Unfinished -> ":hourglas_flowing_sand:" + Unfinished -> ":hourglass_flowing_sand:" Success -> ":heavy_check_mark:" platformIcon :: Platform -> Text @@ -187,7 +192,7 @@ buildSummary :: MaintainerMap -> Seq Build -> StatusSummary buildSummary maintainerMap = foldl (Map.unionWith unionSummary) Map.empty . fmap toSummary where unionSummary (Table l, l') (Table r, r') = (Table $ Map.union l r, l' <> r') - toSummary Build{finished, buildstatus, job, id, system, nixname} = Map.singleton name (Table (Map.singleton (set, Platform system) (BuildResult state id)), maintainers) + toSummary Build{finished, buildstatus, job, id, system} = Map.singleton name (Table (Map.singleton (set, Platform system) (BuildResult state id)), maintainers) where state = case (finished, buildstatus) of (0, _) -> Unfinished @@ -240,7 +245,7 @@ statusToNumSummary :: StatusSummary -> NumSummary statusToNumSummary = fmap getSum . foldMap (fmap Sum . jobTotals) jobTotals :: (Table Text Platform BuildResult, a) -> Table Platform BuildState Int -jobTotals (Table mapping, _) = getSum <$> Table (Map.foldMapWithKey (\(set, platform) (BuildResult buildstate _) -> Map.singleton (platform, buildstate) (Sum 1)) mapping) +jobTotals (Table mapping, _) = getSum <$> Table (Map.foldMapWithKey (\(_, platform) (BuildResult buildstate _) -> Map.singleton (platform, buildstate) (Sum 1)) mapping) details :: Text -> [Text] -> [Text] details summary content = ["
" <> summary <> " ", ""] <> content <> ["
", ""] @@ -251,7 +256,7 @@ printBuildSummary fetchTime summary = Text.unlines $ - header <> totals + headline <> totals <> optionalList "#### Maintained packages with build failure" (maintainedList fails) <> optionalList "#### Maintained packages with failed dependency" (maintainedList failedDeps) <> optionalList "#### Maintained packages with unknown error" (maintainedList unknownErr) @@ -266,10 +271,9 @@ printBuildSummary , "" ] <> printTable "Platform" (\x -> platform x <> " " <> platformIcon x) (\x -> showT x <> " " <> icon x) showT (statusToNumSummary summary) - header = + headline = [ "### [haskell-updates build report from hydra](https://hydra.nixos.org/jobset/nixpkgs/haskell-updates)" - , "*" - <> "evaluation [" + , "*evaluation [" <> showT id <> "](https://hydra.nixos.org/eval/" <> showT id @@ -281,14 +285,14 @@ printBuildSummary <> Text.pack (formatTime defaultTimeLocale "%Y-%m-%d %H:%M UTC" fetchTime) <> "*" ] - jobsByState pred = Map.filter (pred . foldl' min Success . fmap state . fst) summary + jobsByState predicate = Map.filter (predicate . foldl' min Success . fmap state . fst) summary fails = jobsByState (== Failed) failedDeps = jobsByState (== DependencyFailed) unknownErr = jobsByState (\x -> x > DependencyFailed && x < Aborted) withMaintainer = Map.mapMaybe (\(x, m) -> (x,) <$> nonEmpty (Set.toList m)) withoutMaintainer = Map.mapMaybe (\(x, m) -> if Set.null m then Just x else Nothing) - optionalList header list = if null list then mempty else [header] <> list - optionalHideableList header list = if null list then mempty else [header] <> details (showT (length list) <> " job(s)") list + optionalList heading list = if null list then mempty else [heading] <> list + optionalHideableList heading list = if null list then mempty else [heading] <> details (showT (length list) <> " job(s)") list maintainedList = showMaintainedBuild <=< Map.toList . withMaintainer unmaintainedList = showBuild <=< Map.toList . withoutMaintainer showBuild (name, table) = printJob name (table, "") From 461c374bda601ae6666f8ac693d328579112b79f Mon Sep 17 00:00:00 2001 From: "(cdep)illabout" Date: Sat, 8 May 2021 14:13:20 +0900 Subject: [PATCH 114/163] maintainers/scripts/haskell/hydra-report.hs: change Build.buildstatus to Maybe Int The buildstatus may be `null` from Hydra if the Build hasn't finished running yet. --- maintainers/scripts/haskell/hydra-report.hs | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/maintainers/scripts/haskell/hydra-report.hs b/maintainers/scripts/haskell/hydra-report.hs index 9e1641ce8f8..6449e1bbab9 100755 --- a/maintainers/scripts/haskell/hydra-report.hs +++ b/maintainers/scripts/haskell/hydra-report.hs @@ -92,7 +92,7 @@ data Eval = Eval data Build = Build { job :: Text - , buildstatus :: Int + , buildstatus :: Maybe Int , finished :: Int , id :: Int , nixname :: Text @@ -155,7 +155,7 @@ getMaintainerMap = do get c p i e = readProcess c p i <&> \x -> either (error . (<> "Raw:'" <> x <> "'") . (e <>)) Prelude.id . eitherDecodeStrict' . encodeUtf8 . Text.pack $ x -- BuildStates are sorted by subjective importance/concerningness -data BuildState = Failed | DependencyFailed | OutputLimitExceeded | Unknown Int | Aborted | Unfinished | Success deriving (Show, Eq, Ord) +data BuildState = Failed | DependencyFailed | OutputLimitExceeded | Unknown (Maybe Int) | Aborted | Unfinished | Success deriving (Show, Eq, Ord) icon :: BuildState -> Text icon = \case @@ -194,13 +194,14 @@ buildSummary maintainerMap = foldl (Map.unionWith unionSummary) Map.empty . fmap unionSummary (Table l, l') (Table r, r') = (Table $ Map.union l r, l' <> r') toSummary Build{finished, buildstatus, job, id, system} = Map.singleton name (Table (Map.singleton (set, Platform system) (BuildResult state id)), maintainers) where + state :: BuildState state = case (finished, buildstatus) of (0, _) -> Unfinished - (_, 0) -> Success - (_, 7) -> Aborted - (_, 2) -> DependencyFailed - (_, 1) -> Failed - (_, 11) -> OutputLimitExceeded + (_, Just 0) -> Success + (_, Just 7) -> Aborted + (_, Just 2) -> DependencyFailed + (_, Just 1) -> Failed + (_, Just 11) -> OutputLimitExceeded (_, i) -> Unknown i packageName = fromMaybe job (Text.stripSuffix ("." <> system) job) splitted = nonEmpty $ Text.splitOn "." packageName @@ -309,5 +310,5 @@ printMarkBrokenList = do (_, _, buildReport) <- readBuildReports forM_ buildReport \Build{buildstatus, job} -> case (buildstatus, Text.splitOn "." job) of - (1, ["haskellPackages", name, "x86_64-linux"]) -> putStrLn $ " - " <> Text.unpack name + (Just 1, ["haskellPackages", name, "x86_64-linux"]) -> putStrLn $ " - " <> Text.unpack name _ -> pure () From 10d2ea64cdd619598f2b01e81183b4609ab8b4aa Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Sun, 9 May 2021 02:50:19 +0200 Subject: [PATCH 115/163] maintainers/scripts/haskell/hydra-report.hs: Deal with more buildstatus codes --- maintainers/scripts/haskell/hydra-report.hs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/maintainers/scripts/haskell/hydra-report.hs b/maintainers/scripts/haskell/hydra-report.hs index 6449e1bbab9..7e90bbc5588 100755 --- a/maintainers/scripts/haskell/hydra-report.hs +++ b/maintainers/scripts/haskell/hydra-report.hs @@ -155,7 +155,7 @@ getMaintainerMap = do get c p i e = readProcess c p i <&> \x -> either (error . (<> "Raw:'" <> x <> "'") . (e <>)) Prelude.id . eitherDecodeStrict' . encodeUtf8 . Text.pack $ x -- BuildStates are sorted by subjective importance/concerningness -data BuildState = Failed | DependencyFailed | OutputLimitExceeded | Unknown (Maybe Int) | Aborted | Unfinished | Success deriving (Show, Eq, Ord) +data BuildState = Failed | DependencyFailed | OutputLimitExceeded | Unknown (Maybe Int) | TimedOut | Canceled | Unfinished | Success deriving (Show, Eq, Ord) icon :: BuildState -> Text icon = \case @@ -163,7 +163,8 @@ icon = \case DependencyFailed -> ":heavy_exclamation_mark:" OutputLimitExceeded -> ":warning:" Unknown x -> "unknown code " <> showT x - Aborted -> ":no_entry:" + TimedOut -> ":hourglass::no_entry_sign:" + Canceled -> ":no_entry_sign:" Unfinished -> ":hourglass_flowing_sand:" Success -> ":heavy_check_mark:" @@ -198,7 +199,8 @@ buildSummary maintainerMap = foldl (Map.unionWith unionSummary) Map.empty . fmap state = case (finished, buildstatus) of (0, _) -> Unfinished (_, Just 0) -> Success - (_, Just 7) -> Aborted + (_, Just 4) -> Canceled + (_, Just 7) -> TimedOut (_, Just 2) -> DependencyFailed (_, Just 1) -> Failed (_, Just 11) -> OutputLimitExceeded @@ -289,7 +291,7 @@ printBuildSummary jobsByState predicate = Map.filter (predicate . foldl' min Success . fmap state . fst) summary fails = jobsByState (== Failed) failedDeps = jobsByState (== DependencyFailed) - unknownErr = jobsByState (\x -> x > DependencyFailed && x < Aborted) + unknownErr = jobsByState (\x -> x > DependencyFailed && x < TimedOut) withMaintainer = Map.mapMaybe (\(x, m) -> (x,) <$> nonEmpty (Set.toList m)) withoutMaintainer = Map.mapMaybe (\(x, m) -> if Set.null m then Just x else Nothing) optionalList heading list = if null list then mempty else [heading] <> list From 086180140d8b67114a8698a3a361608c0e61fede Mon Sep 17 00:00:00 2001 From: maralorn Date: Sun, 9 May 2021 03:55:09 +0200 Subject: [PATCH 116/163] maintainers/scripts/haskell/hydra-report.hs: Fix typo Co-authored-by: Dennis Gosnell --- maintainers/scripts/haskell/hydra-report.hs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maintainers/scripts/haskell/hydra-report.hs b/maintainers/scripts/haskell/hydra-report.hs index 7e90bbc5588..ae14ae35335 100755 --- a/maintainers/scripts/haskell/hydra-report.hs +++ b/maintainers/scripts/haskell/hydra-report.hs @@ -128,7 +128,7 @@ getBuildReports = runReq defaultHttpConfig do now <- getCurrentTime encodeFile fileName (eval, now, buildReports) where - myReq query option = responseBody <$> req GET query NoReqBody jsonResponse (header "User-Agent" "hydra-report.hs/v1 (nixkpgs;maintainers/scripts/haskell)" <> option) + myReq query option = responseBody <$> req GET query NoReqBody jsonResponse (header "User-Agent" "hydra-report.hs/v1 (nixpkgs;maintainers/scripts/haskell)" <> option) hydraEvalCommand :: FilePath hydraEvalCommand = "hydra-eval-jobs" From 1da75e70f8e760565f564f16469081f2d114f4eb Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Sun, 9 May 2021 15:13:07 +0200 Subject: [PATCH 117/163] maintainers/scripts/haskell/hydra-report.hs: Add links to job and set names --- maintainers/scripts/haskell/hydra-report.hs | 27 ++++++++++++--------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/maintainers/scripts/haskell/hydra-report.hs b/maintainers/scripts/haskell/hydra-report.hs index ae14ae35335..471447e60d5 100755 --- a/maintainers/scripts/haskell/hydra-report.hs +++ b/maintainers/scripts/haskell/hydra-report.hs @@ -141,7 +141,7 @@ handlesParams = ["--eval", "--strict", "--json", "-"] handlesExpression :: String handlesExpression = "with import ./. {}; with lib; zipAttrsWith (_: builtins.head) (mapAttrsToList (_: v: if v ? github then { \"${v.email}\" = v.github; } else {}) (import maintainers/maintainer-list.nix))" -newtype Maintainers = Maintainers {maintainers :: Text} deriving (Generic, ToJSON, FromJSON) +newtype Maintainers = Maintainers {maintainers :: Maybe Text} deriving (Generic, ToJSON, FromJSON) type HydraJobs = Map Text Maintainers type MaintainerMap = Map Text (NonEmpty Text) @@ -150,9 +150,9 @@ getMaintainerMap :: IO MaintainerMap getMaintainerMap = do hydraJobs :: HydraJobs <- get hydraEvalCommand hydraEvalParams "" "Failed to decode hydra-eval-jobs output: " handlesMap :: Map Text Text <- get handlesCommand handlesParams handlesExpression "Failed to decode nix output for lookup of github handles: " - pure $ hydraJobs & Map.mapMaybe (nonEmpty . mapMaybe (`Map.lookup` handlesMap) . Text.splitOn ", " . maintainers) + pure $ hydraJobs & Map.mapMaybe (nonEmpty . mapMaybe (`Map.lookup` handlesMap) . Text.splitOn ", " . fromMaybe "" . maintainers) where - get c p i e = readProcess c p i <&> \x -> either (error . (<> "Raw:'" <> x <> "'") . (e <>)) Prelude.id . eitherDecodeStrict' . encodeUtf8 . Text.pack $ x + get c p i e = readProcess c p i <&> \x -> either (error . (<> " Raw:'" <> take 1000 x <> "'") . (e <>)) Prelude.id . eitherDecodeStrict' . encodeUtf8 . Text.pack $ x -- BuildStates are sorted by subjective importance/concerningness data BuildState = Failed | DependencyFailed | OutputLimitExceeded | Unknown (Maybe Int) | TimedOut | Canceled | Unfinished | Success deriving (Show, Eq, Ord) @@ -231,19 +231,24 @@ printTable name showR showC showE (Table mapping) = joinTable <$> (name : map sh rows = toList $ Set.fromList (fst <$> Map.keys mapping) cols = toList $ Set.fromList (snd <$> Map.keys mapping) -printJob :: Text -> (Table Text Platform BuildResult, Text) -> [Text] -printJob name (Table mapping, maintainers) = +printJob :: Int -> Text -> (Table Text Platform BuildResult, Text) -> [Text] +printJob evalId name (Table mapping, maintainers) = if length sets <= 1 then map printSingleRow sets - else ["- [ ] " <> name <> " " <> maintainers] <> map printRow sets + else ["- [ ] " <> makeJobSearchLink "" name <> " " <> maintainers] <> map printRow sets where - printRow set = " - " <> printState set <> " " <> (if Text.null set then "toplevel" else set) - printSingleRow set = "- [ ] " <> printState set <> " " <> (if Text.null set then "" else set <> ".") <> name <> " " <> maintainers + printRow set = " - " <> printState set <> " " <> makeJobSearchLink set (if Text.null set then "toplevel" else set) + printSingleRow set = "- [ ] " <> printState set <> " " <> makeJobSearchLink set (makePkgName set) <> " " <> maintainers + makePkgName set = (if Text.null set then "" else set <> ".") <> name printState set = Text.intercalate " " $ map (\pf -> maybe "" (label pf) $ Map.lookup (set, pf) mapping) platforms + makeJobSearchLink set linkLabel= makeSearchLink evalId linkLabel (makePkgName set <> ".") -- Append '.' to the search query to prevent e.g. "hspec." matching "hspec-golden.x86_64-linux" sets = toList $ Set.fromList (fst <$> Map.keys mapping) platforms = toList $ Set.fromList (snd <$> Map.keys mapping) label pf (BuildResult s i) = "[[" <> platformIcon pf <> icon s <> "]](https://hydra.nixos.org/build/" <> showT i <> ")" +makeSearchLink :: Int -> Text -> Text -> Text +makeSearchLink evalId linkLabel query = "[" <> linkLabel <> "](" <> "https://hydra.nixos.org/eval/" <> showT evalId <> "?filter=" <> query <> ")" + statusToNumSummary :: StatusSummary -> NumSummary statusToNumSummary = fmap getSum . foldMap (fmap Sum . jobTotals) @@ -273,7 +278,7 @@ printBuildSummary [ "#### Build summary" , "" ] - <> printTable "Platform" (\x -> platform x <> " " <> platformIcon x) (\x -> showT x <> " " <> icon x) showT (statusToNumSummary summary) + <> printTable "Platform" (\x -> makeSearchLink id (platform x <> " " <> platformIcon x) ("." <> platform x)) (\x -> showT x <> " " <> icon x) showT (statusToNumSummary summary) headline = [ "### [haskell-updates build report from hydra](https://hydra.nixos.org/jobset/nixpkgs/haskell-updates)" , "*evaluation [" @@ -298,8 +303,8 @@ printBuildSummary optionalHideableList heading list = if null list then mempty else [heading] <> details (showT (length list) <> " job(s)") list maintainedList = showMaintainedBuild <=< Map.toList . withMaintainer unmaintainedList = showBuild <=< Map.toList . withoutMaintainer - showBuild (name, table) = printJob name (table, "") - showMaintainedBuild (name, (table, maintainers)) = printJob name (table, Text.intercalate " " (fmap ("@" <>) (toList maintainers))) + showBuild (name, table) = printJob id name (table, "") + showMaintainedBuild (name, (table, maintainers)) = printJob id name (table, Text.intercalate " " (fmap ("@" <>) (toList maintainers))) printMaintainerPing :: IO () printMaintainerPing = do From dd8a25528a55a64ee410c1c00e7b5dd9c5471b62 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Sun, 9 May 2021 13:22:46 +0200 Subject: [PATCH 118/163] maintainers/scripts/haskell: Add mark-broken.sh --- maintainers/scripts/haskell/mark-broken.sh | 45 ++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100755 maintainers/scripts/haskell/mark-broken.sh diff --git a/maintainers/scripts/haskell/mark-broken.sh b/maintainers/scripts/haskell/mark-broken.sh new file mode 100755 index 00000000000..ddf2b1243b1 --- /dev/null +++ b/maintainers/scripts/haskell/mark-broken.sh @@ -0,0 +1,45 @@ +#! /usr/bin/env nix-shell +#! nix-shell -i bash -p coreutils git -I nixpkgs=. + +# This script uses the data pulled with +# maintainers/scripts/haskell/hydra-report.hs get-report to produce a list of +# failing builds that get written to the hackage2nix config. Then +# hackage-packages.nix gets regenerated and transitive-broken packages get +# marked as dont-distribute in the config as well. +# This should disable builds for most failing jobs in the haskell-updates jobset. + +set -euo pipefail + +broken_config="pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml" + +tmpfile=$(mktemp) +trap "rm ${tmpfile}" 0 + +echo "Remember that you need to manually run 'maintainers/scripts/haskell/hydra-report.hs get-report' sometime before running this script." +echo "Generating a list of broken builds and displaying for manual confirmation ..." +maintainers/scripts/haskell/hydra-report.hs mark-broken-list | sort -i > $tmpfile + +$EDITOR $tmpfile + +tail -n +3 "$broken_config" >> "$tmpfile" + +cat > "$broken_config" << EOF +broken-packages: + # These packages don't compile. +EOF + +sort -iu "$tmpfile" >> "$broken_config" +maintainers/scripts/haskell/regenerate-hackage-packages.sh +maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh +maintainers/scripts/haskell/regenerate-hackage-packages.sh + +if [[ "${1:-}" == "--do-commit" ]]; then +git add $broken_config +git add pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +git add pkgs/development/haskell-modules/hackage-packages.nix +git commit -F - << EOF +hackage2nix: Mark failing builds broken + +This commit has been generated by maintainers/scripts/haskell/mark-broken.sh +EOF +fi From 9a51c0704f9e8418f04a8ffdd8ce804c0ef8ae64 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Sun, 9 May 2021 13:47:15 +0200 Subject: [PATCH 119/163] maintainers/scripts/haskell: Sort transitive broken case insensitive --- .../regenerate-transitive-broken-packages.sh | 14 +++++++++++++- .../scripts/haskell/transitive-broken-packages.nix | 5 ----- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh b/maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh index ed03ef5eb6a..64ec998bf6b 100755 --- a/maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh +++ b/maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh @@ -1,3 +1,15 @@ #! /usr/bin/env nix-shell #! nix-shell -i bash -p coreutils nix gnused -I nixpkgs=. -echo -e $(nix-instantiate --eval --strict maintainers/scripts/haskell/transitive-broken-packages.nix) | sed 's/\"//' > pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml + +config_file=pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml + +cat > $config_file << EOF +# This file is automatically generated by +# maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh +# It is supposed to list all haskellPackages that cannot evaluate because they +# depend on a dependency marked as broken. +dont-distribute-packages: +EOF + +echo "Regenerating list of transitive broken packages ..." +echo -e $(nix-instantiate --eval --strict maintainers/scripts/haskell/transitive-broken-packages.nix) | sed 's/\"//' | sort -i >> $config_file diff --git a/maintainers/scripts/haskell/transitive-broken-packages.nix b/maintainers/scripts/haskell/transitive-broken-packages.nix index 3ddadea216f..d4ddaa95765 100644 --- a/maintainers/scripts/haskell/transitive-broken-packages.nix +++ b/maintainers/scripts/haskell/transitive-broken-packages.nix @@ -12,10 +12,5 @@ let (getEvaluating (nixpkgs { config.allowBroken = true; }).haskellPackages); in '' - # This file is automatically generated by - # maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh - # It is supposed to list all haskellPackages that cannot evaluate because they - # depend on a dependency marked as broken. - dont-distribute-packages: ${lib.concatMapStringsSep "\n" (x: " - ${x}") brokenDeps} '' From 1ccf343045fd6cba711eb4a6ad1fc3cb86fe7a20 Mon Sep 17 00:00:00 2001 From: Otavio Salvador Date: Mon, 10 May 2021 17:03:29 -0300 Subject: [PATCH 120/163] shellhub-agent: 0.6.4 -> 0.7.0 Signed-off-by: Otavio Salvador --- .../networking/shellhub-agent/default.nix | 11 +- .../shellhub-agent/fix-go-mod-deps.patch | 128 ------------------ 2 files changed, 3 insertions(+), 136 deletions(-) delete mode 100644 pkgs/applications/networking/shellhub-agent/fix-go-mod-deps.patch diff --git a/pkgs/applications/networking/shellhub-agent/default.nix b/pkgs/applications/networking/shellhub-agent/default.nix index 54eb1216b09..7a8f35b76b0 100644 --- a/pkgs/applications/networking/shellhub-agent/default.nix +++ b/pkgs/applications/networking/shellhub-agent/default.nix @@ -9,23 +9,18 @@ buildGoModule rec { pname = "shellhub-agent"; - version = "0.6.4"; + version = "0.7.0"; src = fetchFromGitHub { owner = "shellhub-io"; repo = "shellhub"; rev = "v${version}"; - sha256 = "12g9067knppkci2acc4w9xcismgw2w1zd0f1swbzdnx8bxl3vg9i"; + sha256 = "07gfi0l9l19cy7304v18knbfhs7zqhfglw0jjhcmxa79dg6wzdia"; }; - patches = [ - # Fix missing multierr package on go.mod - ./fix-go-mod-deps.patch - ]; - modRoot = "./agent"; - vendorSha256 = "0z5qvgmmrwwvhpmhjxdvgdfsd60a24q9ld68ggnkv36qln0gw7p4"; + vendorSha256 = "0rcb384yxk1dsip15qh32rkd07i2zzr1k53wcfpnrgi6jpixvsvi"; buildFlagsArray = [ "-ldflags=-s -w -X main.AgentVersion=v${version}" ]; diff --git a/pkgs/applications/networking/shellhub-agent/fix-go-mod-deps.patch b/pkgs/applications/networking/shellhub-agent/fix-go-mod-deps.patch deleted file mode 100644 index 7e99eccb04d..00000000000 --- a/pkgs/applications/networking/shellhub-agent/fix-go-mod-deps.patch +++ /dev/null @@ -1,128 +0,0 @@ -diff --git a/agent/go.mod b/agent/go.mod -index c075083..b79726e 100644 ---- a/agent/go.mod -+++ b/agent/go.mod -@@ -28,6 +28,7 @@ require ( - github.com/pkg/errors v0.9.1 - github.com/shellhub-io/shellhub v0.5.2 - github.com/sirupsen/logrus v1.8.1 -+ go.uber.org/multierr v1.6.0 // indirect - golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 - golang.org/x/net v0.0.0-20210224082022-3d97a244fca7 // indirect - golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073 -diff --git a/agent/go.sum b/agent/go.sum -index e65c9ad..0f9afcd 100644 ---- a/agent/go.sum -+++ b/agent/go.sum -@@ -62,7 +62,6 @@ github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw - github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= - github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= - github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= --github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4= - github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= - github.com/google/go-cmp v0.5.0 h1:/QaMHBdZ26BB3SSst0Iwl10Epc+xhTquomWX0oZEB6w= - github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -@@ -73,7 +72,6 @@ github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= - github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So= - github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= - github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= --github.com/hashicorp/go-cleanhttp v0.5.1 h1:dH3aiDG9Jvb5r5+bYHsikaOUIpcM0xvgMXVoDkXMzJM= - github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= - github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ= - github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= -@@ -87,9 +85,7 @@ github.com/kelseyhightower/envconfig v1.4.0 h1:Im6hONhd3pLkfDFsbRgu68RDNkGF1r3dv - github.com/kelseyhightower/envconfig v1.4.0/go.mod h1:cccZRl6mQpaq41TPp5QxidR+Sa3axMbJDNb//FQX6Gg= - github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= - github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= --github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk= - github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= --github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y= - github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= - github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w= - github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY= -@@ -113,7 +109,6 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN - github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= - github.com/rogpeppe/go-charset v0.0.0-20180617210344-2471d30d28b4/go.mod h1:qgYeAmZ5ZIpBWTGllZSQnw97Dj+woV0toclVaRGI8pc= - github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= --github.com/sirupsen/logrus v1.7.0 h1:ShrD1U9pZB12TX0cVy0DtePoCH97K8EtX+mg7ZARUtM= - github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= - github.com/sirupsen/logrus v1.8.1 h1:dJKuHgqk1NNQlqoA6BTlM1Wf9DOH3NBjQyu0h9+AZZE= - github.com/sirupsen/logrus v1.8.1/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0= -@@ -124,15 +119,18 @@ github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9 - github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= - github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= - github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= --github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w= - github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= --github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= -+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= - github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= - github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= - github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= - github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= - github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= - github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= -+go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw= -+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= -+go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4= -+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= - golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= - golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= - golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -@@ -148,7 +146,6 @@ golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73r - golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= - golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= - golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= --golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3 h1:0GoQqolDA55aaLxZyTzK/Y2ePZzZTUrRacwib7cNsYQ= - golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= - golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= - golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -@@ -169,17 +166,13 @@ golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7w - golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= - golang.org/x/sys v0.0.0-20200831180312-196b9ba8737a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= - golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= --golang.org/x/sys v0.0.0-20201119102817-f84b799fce68 h1:nxC68pudNYkKU6jWhgrqdreuFiOQWj1Fs7T3VrH4Pjw= - golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= - golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073 h1:8qxJSnu+7dRq6upnbntrmriWByIakBuct5OM/MdQC1M= - golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= --golang.org/x/term v0.0.0-20201117132131-f5c789dd3221 h1:/ZHdbVpdR/jk3g30/d4yUL0JU9kksj8+F/bnQUVLGDM= - golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= - golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E= - golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= --golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= - golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= --golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= - golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= - golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k= - golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -@@ -197,14 +190,12 @@ golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roY - golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= - golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= - golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= --golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= - golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= - golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= - golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= - google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= - google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= - google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= --google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55 h1:gSJIx1SDwno+2ElGhA4+qG2zF97qiUzTM+rQ0klBOcE= - google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= - google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo= - google.golang.org/genproto v0.0.0-20210224155714-063164c882e6 h1:bXUwz2WkXXrXgiLxww3vWmoSHLOGv4ipdPdTvKymcKw= -@@ -223,7 +214,6 @@ google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzi - google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= - google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= - google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= --google.golang.org/protobuf v1.24.0 h1:UhZDfRO8JRQru4/+LlLE0BRKGF8L+PICnvYZmx/fEGA= - google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4= - google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c= - google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= -@@ -233,7 +223,6 @@ gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXa - gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= - gopkg.in/go-playground/validator.v9 v9.31.0 h1:bmXmP2RSNtFES+bn4uYuHT7iJFJv7Vj+an+ZQdDaD1M= - gopkg.in/go-playground/validator.v9 v9.31.0/go.mod h1:+c9/zcJMFNgbLvly1L1V+PpxWdVbfP1avr/N00E2vyQ= --gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= - gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= - gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= - gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= From df85615cded844e3a124746c3796b59cc27818b6 Mon Sep 17 00:00:00 2001 From: Kira Bruneau Date: Mon, 10 May 2021 16:43:41 -0400 Subject: [PATCH 121/163] =?UTF-8?q?protontricks:=201.5.0=20=E2=86=92=201.5?= =?UTF-8?q?.1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../protontricks/default.nix | 11 +- .../protontricks/steam-run.patch | 101 ++++++++++-------- 2 files changed, 62 insertions(+), 50 deletions(-) diff --git a/pkgs/tools/package-management/protontricks/default.nix b/pkgs/tools/package-management/protontricks/default.nix index bc161f38f28..0934ef1028d 100644 --- a/pkgs/tools/package-management/protontricks/default.nix +++ b/pkgs/tools/package-management/protontricks/default.nix @@ -12,13 +12,13 @@ buildPythonApplication rec { pname = "protontricks"; - version = "1.5.0"; + version = "1.5.1"; src = fetchFromGitHub { owner = "Matoking"; repo = pname; rev = version; - hash = "sha256-IHgoi5VUN3ORbufkruPb6wR7pTekJFQHhhDrnjOWzWM="; + hash = "sha256-SrBPqGRIsP0+ZWDe96sqjqCpJoY3Sn3VoPpMw7ellC0="; }; patches = [ @@ -26,10 +26,7 @@ buildPythonApplication rec { ./steam-run.patch ]; - preBuild = '' - export SETUPTOOLS_SCM_PRETEND_VERSION="${version}" - ''; - + SETUPTOOLS_SCM_PRETEND_VERSION = version; nativeBuildInputs = [ setuptools_scm ]; propagatedBuildInputs = [ vdf ]; @@ -52,7 +49,7 @@ buildPythonApplication rec { meta = with lib; { description = "A simple wrapper for running Winetricks commands for Proton-enabled games"; homepage = "https://github.com/Matoking/protontricks"; - license = licenses.gpl3; + license = licenses.gpl3Only; maintainers = with maintainers; [ metadark ]; platforms = platforms.linux; }; diff --git a/pkgs/tools/package-management/protontricks/steam-run.patch b/pkgs/tools/package-management/protontricks/steam-run.patch index 5e91de58dbe..76b7b7f6036 100644 --- a/pkgs/tools/package-management/protontricks/steam-run.patch +++ b/pkgs/tools/package-management/protontricks/steam-run.patch @@ -1,5 +1,5 @@ diff --git a/src/protontricks/cli.py b/src/protontricks/cli.py -index 9641970..6a2b268 100755 +index cc65a03..5c3fc7a 100755 --- a/src/protontricks/cli.py +++ b/src/protontricks/cli.py @@ -15,8 +15,8 @@ import sys @@ -10,10 +10,10 @@ index 9641970..6a2b268 100755 - find_steam_path, get_steam_apps, get_steam_lib_paths) +from .steam import (find_proton_app, find_steam_path, get_steam_apps, + get_steam_lib_paths) - from .util import run_command + from .util import run_command, is_flatpak_sandbox from .winetricks import get_winetricks_path -@@ -75,8 +75,7 @@ def main(args=None): +@@ -77,8 +77,7 @@ def main(args=None): "WINE: path to a custom 'wine' executable\n" "WINESERVER: path to a custom 'wineserver' executable\n" "STEAM_RUNTIME: 1 = enable Steam Runtime, 0 = disable Steam " @@ -23,7 +23,7 @@ index 9641970..6a2b268 100755 ), formatter_class=argparse.RawTextHelpFormatter ) -@@ -138,18 +137,9 @@ def main(args=None): +@@ -148,18 +147,9 @@ def main(args=None): ) sys.exit(-1) @@ -44,7 +44,7 @@ index 9641970..6a2b268 100755 else: use_steam_runtime = False logger.info("Steam Runtime disabled.") -@@ -212,7 +202,6 @@ def main(args=None): +@@ -222,7 +212,6 @@ def main(args=None): proton_app=proton_app, steam_app=steam_app, use_steam_runtime=use_steam_runtime, @@ -52,7 +52,7 @@ index 9641970..6a2b268 100755 command=[winetricks_path, "--gui"], use_bwrap=use_bwrap ) -@@ -282,7 +271,6 @@ def main(args=None): +@@ -292,7 +281,6 @@ def main(args=None): proton_app=proton_app, steam_app=steam_app, use_steam_runtime=use_steam_runtime, @@ -60,7 +60,7 @@ index 9641970..6a2b268 100755 use_bwrap=use_bwrap, command=[winetricks_path] + args.winetricks_command) elif args.command: -@@ -292,7 +280,6 @@ def main(args=None): +@@ -302,7 +290,6 @@ def main(args=None): steam_app=steam_app, command=args.command, use_steam_runtime=use_steam_runtime, @@ -69,21 +69,21 @@ index 9641970..6a2b268 100755 # Pass the command directly into the shell *without* # escaping it diff --git a/src/protontricks/steam.py b/src/protontricks/steam.py -index 8554e24..509afb6 100644 +index f9fb9ec..e1e588a 100644 --- a/src/protontricks/steam.py +++ b/src/protontricks/steam.py -@@ -13,8 +13,8 @@ from .util import lower_dict +@@ -12,8 +12,8 @@ from .util import lower_dict + __all__ = ( "COMMON_STEAM_DIRS", "SteamApp", "find_steam_path", - "find_steam_proton_app", "find_proton_app", -- "find_legacy_steam_runtime_path", "find_appid_proton_prefix", -- "get_steam_lib_paths", "get_steam_apps", "get_custom_proton_installations" -+ "find_appid_proton_prefix", "get_steam_lib_paths", -+ "get_steam_apps", "get_custom_proton_installations" - ) - - COMMON_STEAM_DIRS = [ -@@ -283,37 +283,6 @@ def find_steam_path(): +- "find_legacy_steam_runtime_path", "get_appinfo_sections", +- "get_proton_appid", "find_steam_proton_app", "find_appid_proton_prefix", ++ "get_appinfo_sections", "get_proton_appid", ++ "find_steam_proton_app", "find_appid_proton_prefix", + "find_proton_app", "get_steam_lib_paths", "get_compat_tool_dirs", + "get_proton_installations", "get_custom_proton_installations", + "find_current_steamid3", "get_appid_from_shortcut", +@@ -286,37 +286,6 @@ def find_steam_path(): return None, None @@ -122,10 +122,31 @@ index 8554e24..509afb6 100644 APPINFO_STRUCT_SECTION = " Date: Mon, 10 May 2021 22:52:18 +0200 Subject: [PATCH 122/163] chromium: 90.0.4430.93 -> 90.0.4430.212 https://chromereleases.googleblog.com/2021/05/stable-channel-update-for-desktop.html This update includes 19 security fixes. CVEs: CVE-2021-30506 CVE-2021-30507 CVE-2021-30508 CVE-2021-30509 CVE-2021-30510 CVE-2021-30511 CVE-2021-30512 CVE-2021-30513 CVE-2021-30514 CVE-2021-30515 CVE-2021-30516 CVE-2021-30517 CVE-2021-30518 CVE-2021-30519 CVE-2021-30520 --- .../networking/browsers/chromium/upstream-info.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/networking/browsers/chromium/upstream-info.json b/pkgs/applications/networking/browsers/chromium/upstream-info.json index 3b41f63351b..cbd45bfbd19 100644 --- a/pkgs/applications/networking/browsers/chromium/upstream-info.json +++ b/pkgs/applications/networking/browsers/chromium/upstream-info.json @@ -1,8 +1,8 @@ { "stable": { - "version": "90.0.4430.93", - "sha256": "0zimr975vp0v12zz1nqjwag3f0q147wrmdhpzgi4yf089rgwfbjk", - "sha256bin64": "1vifcrrfv69i0q7qnnml43xr0c20bi22hfw6lygq3k2x70zdzgl6", + "version": "90.0.4430.212", + "sha256": "17nmhrkl81qqvzbh861k2mmifncx4wg1mv1fmn52f8gzn461vqdb", + "sha256bin64": "1y33c5829s22yfj0qmsj8fpcxnjhcm3fsxz7744csfsa9cy4fjr7", "deps": { "gn": { "version": "2021-02-09", From 86b41bde723d180612d9549442a5a9f06359dd88 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Mon, 10 May 2021 23:10:28 +0200 Subject: [PATCH 123/163] hackage2nix: Mark failing builds broken This commit has been generated by maintainers/scripts/haskell/mark-broken.sh --- .../configuration-hackage2nix/broken.yaml | 30 ++++++----- .../transitive-broken.yaml | 3 ++ .../haskell-modules/hackage-packages.nix | 51 +++++++++++-------- 3 files changed, 50 insertions(+), 34 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index c3f8c09952e..e624ed24a6b 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -216,6 +216,7 @@ broken-packages: - atom-msp430 - atomo - atp-haskell + - ats-pkg - ats-setup - ats-storable - attempt @@ -342,6 +343,7 @@ broken-packages: - bindings-hamlib - bindings-hdf5 - bindings-K8055 + - bindings-levmar - bindings-libftdi - bindings-libg15 - bindings-libpci @@ -1008,6 +1010,7 @@ broken-packages: - digestive-foundation-lucid - digestive-functors-aeson - digestive-functors-happstack + - digest-pure - DigitalOcean - digitalocean-kzs - digits @@ -1647,6 +1650,7 @@ broken-packages: - grakn - grapefruit-frp - Graph500 + - Graphalyze - graphbuilder - graphene - graphics-drawingcombinators @@ -2026,6 +2030,7 @@ broken-packages: - hinterface - hipchat-hs - hipe + - Hipmunk - hipsql-api - hircules - Hish @@ -2316,6 +2321,7 @@ broken-packages: - hwsl2 - hx - HXQ + - hxt-cache - hxt-pickle-utils - hyakko - hydra-hs @@ -3111,6 +3117,8 @@ broken-packages: - network-dns - networked-game - network-house + - network-metrics + - network-msg - network-msgpack-rpc - network-packet-linux - network-server @@ -3147,6 +3155,7 @@ broken-packages: - nix-freeze-tree - nixfromnpm - nixpkgs-update + - nix-tools - nkjp - nlp-scores - nm @@ -3266,6 +3275,7 @@ broken-packages: - orc - orchestrate - OrchestrateDB + - ordered - order-statistics - ordinal - Ordinary @@ -3362,6 +3372,7 @@ broken-packages: - partly - passage - passman + - passman-core - PasswordGenerator - passwords - pasta @@ -3777,6 +3788,9 @@ broken-packages: - refined-http-api-data - reflection-extras - reflex-basic-host + - reflex-dom-contrib + - reflex-dom-helper + - reflex-dom-helpers - reflex-dom-retractable - reflex-dom-svg - reflex-dynamic-containers @@ -3784,6 +3798,7 @@ broken-packages: - reflex-gadt-api - reflex-gi-gtk - reflex-gloss + - reflex-jsx - reflex-libtelnet - reflex-orphans - reflex-sdl2 @@ -3868,6 +3883,7 @@ broken-packages: - rfc-prelude - rhbzquery - ribbit + - ribosome - RichConditional - ridley - riemann @@ -4603,12 +4619,14 @@ broken-packages: - threepenny-gui-contextmenu - threepenny-gui-flexbox - thrift + - Thrift - throttled-io-loop - th-sccs - th-tc - th-to-exp - th-traced - thumbnail-plus + - tianbar - TicTacToe - tictactoe3d - tidal-midi @@ -5223,15 +5241,3 @@ broken-packages: - ztar - Zwaluw - zxcvbn-dvorak - - ordered - - Hipmunk - - hxt-cache - - Graphalyze - - ribosome - - Thrift - - bindings-levmar - - network-msg - - reflex-dom-helper - - network-metrics - - ats-pkg - - digest-pure diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 5b23793a9f1..4d40181e8d6 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -302,6 +302,7 @@ dont-distribute-packages: - buildbox-tools - buildwrapper - bulletproofs + - bulmex - burnt-explorer - bus-pirate - buster-gtk @@ -629,6 +630,7 @@ dont-distribute-packages: - diagrams-html5 - diagrams-pandoc - diagrams-pgf + - diagrams-reflex - diagrams-wx - DifferenceLogic - difference-monoid @@ -2182,6 +2184,7 @@ dont-distribute-packages: - parse-help - parsestar - partial-lens + - passman-cli - patch-image - patterns - pcap-enumerator diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 6bc723606b8..fddbbb240ad 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -7002,6 +7002,7 @@ self: { ]; description = "A natural language generator (specifically, an FB-LTAG surface realiser)"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "GenSmsPdu" = callPackage @@ -10327,6 +10328,7 @@ self: { testHaskellDepends = [ base ]; description = "Useful functions for Hipmunk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HipmunkPlayground" = callPackage @@ -10493,6 +10495,7 @@ self: { ]; description = "A search and indexing engine"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "Holumbus-Storage" = callPackage @@ -17956,7 +17959,6 @@ self: { ]; description = "Command-line tool for maintaining the Semantique database"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; }) {}; "Semigroup" = callPackage @@ -18772,6 +18774,7 @@ self: { ]; description = "Static code analysis using graph-theoretic techniques"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "Southpaw" = callPackage @@ -22047,7 +22050,6 @@ self: { ]; description = "interconversion between aeson and bson"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "abides" = callPackage @@ -45864,7 +45866,6 @@ self: { libraryHaskellDepends = [ base bson ghc-prim text ]; description = "Generic functionality for BSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "bson-generics" = callPackage @@ -45876,7 +45877,6 @@ self: { libraryHaskellDepends = [ base bson ghc-prim ]; description = "Generics functionality for BSON"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "bson-lens" = callPackage @@ -45888,7 +45888,6 @@ self: { libraryHaskellDepends = [ base bson lens text ]; description = "BSON lenses"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "bson-mapping" = callPackage @@ -46477,6 +46476,7 @@ self: { ]; description = "Reflex infused with bulma (css)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bumper" = callPackage @@ -53865,6 +53865,7 @@ self: { ]; description = "neovim package manager"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "chronograph" = callPackage @@ -67008,7 +67009,6 @@ self: { testHaskellDepends = [ aeson base bson hspec QuickCheck ]; description = "ISO-4217 Currency Codes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "currency-convert" = callPackage @@ -74234,6 +74234,7 @@ self: { ]; description = "reflex backend for diagrams drawing EDSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-rubiks-cube" = callPackage @@ -93486,7 +93487,6 @@ self: { ]; description = "Print Forex quotes in Ledger format"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "forger" = callPackage @@ -98872,6 +98872,7 @@ self: { ]; description = "Companion tools for use with the GenI surface realiser"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "geniconvert" = callPackage @@ -98949,6 +98950,7 @@ self: { ]; description = "Simple HTTP server for GenI results"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "genprog" = callPackage @@ -99754,7 +99756,6 @@ self: { libraryHaskellDepends = [ aeson base bson bytestring lens text ]; description = "GeoJSON data types including JSON/BSON conversion"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "geolite-csv" = callPackage @@ -135232,6 +135233,7 @@ self: { ]; description = "cassandra database interface"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hscd" = callPackage @@ -160249,6 +160251,7 @@ self: { libraryHaskellDepends = [ base bindings-levmar hmatrix vector ]; description = "An implementation of the Levenberg-Marquardt algorithm"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "levmar-chart" = callPackage @@ -160262,6 +160265,7 @@ self: { libraryHaskellDepends = [ base Chart colour data-accessor levmar ]; description = "Plots the results of the Levenberg-Marquardt algorithm in a chart"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lex-applicative" = callPackage @@ -167288,6 +167292,7 @@ self: { testHaskellDepends = [ base bytestring Cabal ]; description = "Library for talking to the mDNSResponder daemon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "maam" = callPackage @@ -175217,7 +175222,6 @@ self: { ]; description = "Mollie API client for Haskell http://www.mollie.com"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "monad-abort-fd" = callPackage @@ -176874,7 +176878,6 @@ self: { ]; description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "mongodb-queue" = callPackage @@ -176895,7 +176898,6 @@ self: { ]; description = "message queue using MongoDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "mongrel2-handler" = callPackage @@ -180488,6 +180490,7 @@ self: { ]; description = "Send an email to all MusicBrainz editors"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "musicw" = callPackage @@ -185619,6 +185622,8 @@ self: { ]; description = "cabal/stack to nix translation tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nix-tree" = callPackage @@ -195229,6 +195234,7 @@ self: { ]; description = "Deterministic password generator command line interface"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "passman-core" = callPackage @@ -195254,6 +195260,8 @@ self: { doHaddock = false; description = "Deterministic password generator core"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "password" = callPackage @@ -197589,7 +197597,6 @@ self: { ]; description = "Parses a Persist Model file and produces Audit Models"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "persistent-cereal" = callPackage @@ -197811,7 +197818,6 @@ self: { ]; description = "Backend for the persistent library using mongoDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "persistent-mtl" = callPackage @@ -201018,7 +201024,6 @@ self: { testHaskellDepends = [ base monad-control mongoDB pipes text ]; description = "Stream results from MongoDB"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "pipes-network" = callPackage @@ -208759,7 +208764,6 @@ self: { ]; description = "ITProTV's custom prelude"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "prometheus" = callPackage @@ -209232,6 +209236,7 @@ self: { ]; description = "neovim project manager"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "proto-lens" = callPackage @@ -217339,6 +217344,8 @@ self: { ]; description = "A playground for experimenting with infrastructure and common code for reflex applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-dom-core" = callPackage @@ -217414,6 +217421,8 @@ self: { testHaskellDepends = [ base ]; description = "Html tag helpers for reflex-dom"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-dom-pandoc" = callPackage @@ -217661,6 +217670,8 @@ self: { ]; description = "Use jsx-like syntax in Reflex"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-libtelnet" = callPackage @@ -239522,7 +239533,6 @@ self: { ]; description = "DEPRECATED! You should use standard Snap >= 0.9 \"environments\" functionality. It provided ability to easly read configuration based on given app environment given at command line, envs are defined in app configuration file"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "snaplet-fay" = callPackage @@ -239744,7 +239754,6 @@ self: { ]; description = "Minimalistic MongoDB Snaplet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "snaplet-mysql-simple" = callPackage @@ -245105,6 +245114,7 @@ self: { ]; description = "Statsd UDP client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "statsd-datadog" = callPackage @@ -259050,6 +259060,8 @@ self: { ]; description = "A desktop bar based on WebKit"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) gtk3; inherit (pkgs) webkitgtk;}; "tibetan-utils" = callPackage @@ -287416,7 +287428,6 @@ self: { testHaskellDepends = [ base MonadRandom random yu-utils ]; description = "Auth module for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "yu-core" = callPackage @@ -287429,7 +287440,6 @@ self: { testHaskellDepends = [ base blaze-markup hspec yu-utils ]; description = "The core of Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "yu-launch" = callPackage @@ -287445,7 +287455,6 @@ self: { ]; description = "The launcher for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "yu-tool" = callPackage @@ -287463,7 +287472,6 @@ self: { ]; description = "Tool for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "yu-utils" = callPackage @@ -287487,7 +287495,6 @@ self: { ]; description = "Utils for Yu"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "yuiGrid" = callPackage From 0e9fcd6e85bdcd09454841cdabfd9aabf979cf29 Mon Sep 17 00:00:00 2001 From: "Robert T. McGibbon" Date: Mon, 10 May 2021 17:11:52 -0400 Subject: [PATCH 124/163] python3Packages.tablib: fix build --- pkgs/development/python-modules/tablib/default.nix | 2 ++ 1 file changed, 2 insertions(+) diff --git a/pkgs/development/python-modules/tablib/default.nix b/pkgs/development/python-modules/tablib/default.nix index 5216fc7d0d9..b6754e15ad5 100644 --- a/pkgs/development/python-modules/tablib/default.nix +++ b/pkgs/development/python-modules/tablib/default.nix @@ -2,6 +2,7 @@ , odfpy , openpyxl , pandas +, setuptools-scm , pytest , pytestcov , pyyaml @@ -20,6 +21,7 @@ buildPythonPackage rec { sha256 = "f83cac08454f225a34a305daa20e2110d5e6335135d505f93bc66583a5f9c10d"; }; + nativeBuildInputs = [ setuptools-scm ]; propagatedBuildInputs = [ xlwt openpyxl pyyaml xlrd odfpy ]; checkInputs = [ pytest pytestcov unicodecsv pandas ]; From ce5c22b83df5cc93dc777efad4b27d27c28ff75d Mon Sep 17 00:00:00 2001 From: Hunter Jones Date: Mon, 10 May 2021 16:12:58 -0500 Subject: [PATCH 125/163] stellarsolver: set platform to linux --- .../libraries/science/astronomy/stellarsolver/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/libraries/science/astronomy/stellarsolver/default.nix b/pkgs/development/libraries/science/astronomy/stellarsolver/default.nix index f55c72bd209..c3a63c637c3 100644 --- a/pkgs/development/libraries/science/astronomy/stellarsolver/default.nix +++ b/pkgs/development/libraries/science/astronomy/stellarsolver/default.nix @@ -25,6 +25,6 @@ mkDerivation rec { description = "Astrometric plate solving library"; license = licenses.gpl3Plus; maintainers = with maintainers; [ hjones2199 ]; - platforms = [ "x86_64-linux" ]; + platforms = platforms.linux; }; } From edb5f5ee8c9d539d96630ea1ef43f235d4650bdc Mon Sep 17 00:00:00 2001 From: Florian Beeres Date: Mon, 10 May 2021 23:16:52 +0200 Subject: [PATCH 126/163] vimPlugins: update --- pkgs/misc/vim-plugins/generated.nix | 48 ++++++++++++++--------------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index b3805d4cfc8..0f3bc21de49 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -257,12 +257,12 @@ let barbar-nvim = buildVimPluginFrom2Nix { pname = "barbar-nvim"; - version = "2021-05-06"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "romgrk"; repo = "barbar.nvim"; - rev = "566a7ef96e6e935c6e84ddfb73e3a50a7b196638"; - sha256 = "0caglapjgnghp9j1vyk162ch66bhcpgidp2radfiayh5mnifpqv2"; + rev = "1e7347964ceab49c5ed7e1224de328cdd8b90919"; + sha256 = "00p1h7nznrhjfddxzxamyjkf9cgdjw9f8zhzs366k8gfva5fh4r3"; }; meta.homepage = "https://github.com/romgrk/barbar.nvim/"; }; @@ -1220,12 +1220,12 @@ let diffview-nvim = buildVimPluginFrom2Nix { pname = "diffview-nvim"; - version = "2021-05-08"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "sindrets"; repo = "diffview.nvim"; - rev = "daf0134615e488e04223f5bb2377112bf274f481"; - sha256 = "0njdhp3xp00dh4892b7vvgxwnd70ql1aa099vpy33ra3lzvy6jn0"; + rev = "272a474abf7d1b64d5dcaf21f80d6fdc7b623ead"; + sha256 = "14y9gj9054dr2jiz2d1w9y03jh1mp4r04vyabj6nsjk2fg84dz38"; }; meta.homepage = "https://github.com/sindrets/diffview.nvim/"; }; @@ -1499,12 +1499,12 @@ let friendly-snippets = buildVimPluginFrom2Nix { pname = "friendly-snippets"; - version = "2021-05-09"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "rafamadriz"; repo = "friendly-snippets"; - rev = "10135fd89dd433191672b34d7ab2b4bc682bfa5e"; - sha256 = "09h8vbyyynbiyaiainb0jfbny7cprl7rjpfz5nfl7jq8lsmc0x42"; + rev = "83de9287ad388f55b7d74f66b8ea5b89bb6abf24"; + sha256 = "13jp8bg85yyxyl390ymrp6qasg4p6a57x08m2l9ld8wiq33ps6yp"; }; meta.homepage = "https://github.com/rafamadriz/friendly-snippets/"; }; @@ -1847,12 +1847,12 @@ let hologram-nvim = buildVimPluginFrom2Nix { pname = "hologram-nvim"; - version = "2021-05-01"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "edluffy"; repo = "hologram.nvim"; - rev = "31108af1a9a4fc842656c6a319ce3decc3baf8e8"; - sha256 = "0kgbcggx5kr0h95f2gwpfr1h3wbv73pis8dkmjgmr6gpj70zsk7v"; + rev = "975e9fbd0c154deb9c4e212490fb31cfa4257c98"; + sha256 = "0xfwwmzmwj9s67jwr7bpazhbwdqpva7yzy4xsdx1l8pmaszni977"; }; meta.homepage = "https://github.com/edluffy/hologram.nvim/"; }; @@ -2136,12 +2136,12 @@ let julia-vim = buildVimPluginFrom2Nix { pname = "julia-vim"; - version = "2021-04-26"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "JuliaEditorSupport"; repo = "julia-vim"; - rev = "b437dae505b0fbb6aac92a9aad8f4fb68ea1259b"; - sha256 = "1l2kiaa44hd7x9a0w1x5kwfvqnkkzi9i7qnjnhch083chmjjy13d"; + rev = "ce59786999f4715b5c806a3a2162a1cfcf5e9cfd"; + sha256 = "1c9qyx5zd7ynpm2inws7kkig1zvs6j6j2gg5kl63ngvlcsihd0qk"; }; meta.homepage = "https://github.com/JuliaEditorSupport/julia-vim/"; }; @@ -2412,12 +2412,12 @@ let lsp-trouble-nvim = buildVimPluginFrom2Nix { pname = "lsp-trouble-nvim"; - version = "2021-05-09"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "folke"; repo = "lsp-trouble.nvim"; - rev = "0c9ca5e10c2e5dd8d8479e864e12383b1d614273"; - sha256 = "096af9qdz15kqjq9alajjdr6n3r2az2673imyva0mcwpwc007pl5"; + rev = "1dd72c22403519c160b0c694762091971bcf191e"; + sha256 = "1831ywvbl51zd8m5rkpq59dw6s55snsyv94n28vl316cm65q28ji"; }; meta.homepage = "https://github.com/folke/lsp-trouble.nvim/"; }; @@ -2460,12 +2460,12 @@ let lualine-nvim = buildVimPluginFrom2Nix { pname = "lualine-nvim"; - version = "2021-05-09"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "hoob3rt"; repo = "lualine.nvim"; - rev = "82826ef66111f1bbdcc6f8e5bc2b19d7e0542229"; - sha256 = "03wbgqhhyjc7fjhmdmywkirlwy78ziagpvjar4gvjl41rbjn7fgp"; + rev = "11280b44f2f3812b60e99b7e07e4d37bee418cb0"; + sha256 = "0ifbkjsgjilczmqn2lpkw4jl648hns06klx07md9y3sc5i5jqjjq"; }; meta.homepage = "https://github.com/hoob3rt/lualine.nvim/"; }; @@ -3240,12 +3240,12 @@ let nvim-dap = buildVimPluginFrom2Nix { pname = "nvim-dap"; - version = "2021-05-07"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "mfussenegger"; repo = "nvim-dap"; - rev = "f0c43dca363a52acf2b8e5a62363f2def40139f8"; - sha256 = "0dmzk93d7xpiyvavsg7s3snfrcpnsyl2is87bild6vj9l13hl7pb"; + rev = "7c6d12132339d7ef4136dabdd316a20e9c7dd8cf"; + sha256 = "1hjf67pn1brrfyl4lyqg4y7112r8p3ak85iimgb9pqgrifr3xpzm"; }; meta.homepage = "https://github.com/mfussenegger/nvim-dap/"; }; From 04af46573a86a009e73393698c25282f8bb8cac9 Mon Sep 17 00:00:00 2001 From: Florian Beeres Date: Mon, 10 May 2021 10:59:10 +0200 Subject: [PATCH 127/163] vimPlugins.vim_current_word: init at 2021-01-27 --- pkgs/misc/vim-plugins/generated.nix | 12 ++++++++++++ pkgs/misc/vim-plugins/vim-plugin-names | 1 + 2 files changed, 13 insertions(+) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index 0f3bc21de49..a0eb16763f7 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -8850,6 +8850,18 @@ let meta.homepage = "https://github.com/dag/vim2hs/"; }; + vim_current_word = buildVimPluginFrom2Nix { + pname = "vim_current_word"; + version = "2021-01-27"; + src = fetchFromGitHub { + owner = "dominikduda"; + repo = "vim_current_word"; + rev = "84ae9300de73cf878c805a6228a58d408b6b829d"; + sha256 = "0k0wq3aqrbwrqyfz36qdqzyq7cw16d34yvw0gvzyg7iany0z0r6r"; + }; + meta.homepage = "https://github.com/dominikduda/vim_current_word/"; + }; + vimacs = buildVimPluginFrom2Nix { pname = "vimacs"; version = "2016-03-24"; diff --git a/pkgs/misc/vim-plugins/vim-plugin-names b/pkgs/misc/vim-plugins/vim-plugin-names index c647a6bfd5c..50b26968f8c 100644 --- a/pkgs/misc/vim-plugins/vim-plugin-names +++ b/pkgs/misc/vim-plugins/vim-plugin-names @@ -95,6 +95,7 @@ digitaltoad/vim-pug direnv/direnv.vim dleonard0/pony-vim-syntax dmix/elvish.vim +dominikduda/vim_current_word dpelle/vim-LanguageTool dracula/vim as dracula-vim drewtempelmeyer/palenight.vim From aacc6f2e1b41bedad577f2830bb3ba26eab74700 Mon Sep 17 00:00:00 2001 From: Robin Gloster Date: Mon, 10 May 2021 16:23:51 -0500 Subject: [PATCH 128/163] i3status-rust: fix themes and icon handling also enables the pulseaudio feature --- pkgs/applications/window-managers/i3/status-rust.nix | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/pkgs/applications/window-managers/i3/status-rust.nix b/pkgs/applications/window-managers/i3/status-rust.nix index 6ee1be41262..7a58db2bbd9 100644 --- a/pkgs/applications/window-managers/i3/status-rust.nix +++ b/pkgs/applications/window-managers/i3/status-rust.nix @@ -30,8 +30,19 @@ rustPlatform.buildRustPackage rec { cargoBuildFlags = [ "--features=notmuch" "--features=maildir" + "--features=pulseaudio" ]; + prePatch = '' + substituteInPlace src/util.rs \ + --replace "/usr/share/i3status-rust" "$out/share" + ''; + + postInstall = '' + mkdir -p $out/share + cp -R files/* $out/share + ''; + postFixup = '' wrapProgram $out/bin/i3status-rs --prefix PATH : "${ethtool}/bin" ''; From f4839bfc43864ded5ba47ba1adcae67e3a9e456c Mon Sep 17 00:00:00 2001 From: Andrey Kuznetsov Date: Tue, 11 May 2021 00:35:08 +0300 Subject: [PATCH 129/163] nym: fix build on darwin --- pkgs/applications/networking/nym/default.nix | 7 +++++-- pkgs/top-level/all-packages.nix | 4 +++- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/pkgs/applications/networking/nym/default.nix b/pkgs/applications/networking/nym/default.nix index 9251862ba6e..1dc41f3af97 100644 --- a/pkgs/applications/networking/nym/default.nix +++ b/pkgs/applications/networking/nym/default.nix @@ -1,8 +1,11 @@ -{ lib +{ stdenv +, lib , rustPlatform , fetchFromGitHub , pkg-config , openssl +, Security +, libiconv }: rustPlatform.buildRustPackage rec { @@ -20,7 +23,7 @@ rustPlatform.buildRustPackage rec { nativeBuildInputs = [ pkg-config ]; - buildInputs = [ openssl ]; + buildInputs = [ openssl ] ++ lib.optionals stdenv.isDarwin [ Security libiconv ]; patches = [ ./ignore-networking-tests.patch ]; checkType = "debug"; diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 24fbb63792b..13073bf6a9c 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -7146,7 +7146,9 @@ in nylon = callPackage ../tools/networking/nylon { }; - nym = callPackage ../applications/networking/nym { }; + nym = callPackage ../applications/networking/nym { + inherit (darwin.apple_sdk.frameworks) Security; + }; nzbget = callPackage ../tools/networking/nzbget { }; From c8eef2ab2173e6b2546627b7fd43ee83da281762 Mon Sep 17 00:00:00 2001 From: Andrey Kuznetsov Date: Sat, 8 May 2021 09:28:16 +0000 Subject: [PATCH 130/163] atuin: init at 0.7.1 --- pkgs/tools/misc/atuin/default.nix | 25 +++++++++++++++++++++++++ pkgs/top-level/all-packages.nix | 2 ++ 2 files changed, 27 insertions(+) create mode 100644 pkgs/tools/misc/atuin/default.nix diff --git a/pkgs/tools/misc/atuin/default.nix b/pkgs/tools/misc/atuin/default.nix new file mode 100644 index 00000000000..75a5fc57410 --- /dev/null +++ b/pkgs/tools/misc/atuin/default.nix @@ -0,0 +1,25 @@ +{ lib +, fetchFromGitHub +, rustPlatform +}: + +rustPlatform.buildRustPackage rec { + pname = "atuin"; + version = "0.7.1"; + + src = fetchFromGitHub { + owner = "ellie"; + repo = pname; + rev = "v${version}"; + sha256 = "sha256-jjGP8YeHnEr0f9RONwA6wZT872C0jXTvSRdt9zAu6KE="; + }; + + cargoSha256 = "0vy6q3hjp374lyg00zxim8aplh83iq3f4rrmpz5vnpwbag1fdql3"; + + meta = with lib; { + description = "Replacement for a shell history which records additional commands context with optional encrypted synchronization between machines"; + homepage = "https://github.com/ellie/atuin"; + license = licenses.mit; + maintainers = [ maintainers.onsails ]; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 544d2f71825..a9f6329844a 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -156,6 +156,8 @@ in antsimulator = callPackage ../games/antsimulator { }; + atuin = callPackage ../tools/misc/atuin { }; + fiche = callPackage ../servers/fiche { }; fishnet = callPackage ../servers/fishnet { }; From 8f6e36b7be337524b3c5027c1797f487ee0fb962 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 00:04:58 +0200 Subject: [PATCH 131/163] hackage2nix: Mark failing builds broken This commit has been generated by maintainers/scripts/haskell/mark-broken.sh --- .../configuration-hackage2nix/broken.yaml | 13 +++++++++ .../transitive-broken.yaml | 3 ++ .../haskell-modules/hackage-packages.nix | 29 +++++++++++++++++++ 3 files changed, 45 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index e624ed24a6b..70cf1599894 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -3,6 +3,7 @@ broken-packages: - 3dmodels - AAI - abcnotation + - abeson - abides - abnf - AbortT-transformers @@ -428,6 +429,8 @@ broken-packages: - brotli - browscap - bsd-sysctl + - bson-generic + - bson-generics - bsparse - btree-concurrent - buffer @@ -1388,6 +1391,7 @@ broken-packages: - foreign-var - forest - forest-fire + - forex2ledger - for-free - forger - ForkableT @@ -1524,6 +1528,7 @@ broken-packages: - genvalidity-persistent - GeocoderOpenCage - geodetic-types + - geojson-types - geom2d - GeomPredicates-SSE - geo-resolver @@ -2938,6 +2943,7 @@ broken-packages: - MoeDict - moesocks - mohws + - mollie-api-haskell - monadacme - monad-atom - monad-atom-simple @@ -2981,6 +2987,7 @@ broken-packages: - Monatron - mondo - money + - mongodb-queue - monitor - mono-foldable - monoid @@ -3427,6 +3434,7 @@ broken-packages: - persistent-discover - persistent-equivalence - persistent-migration + - persistent-mongoDB - persistent-mysql-haskell - persistent-odbc - persistent-protobuf @@ -4020,6 +4028,7 @@ broken-packages: - selenium - selinux - semantic-source + - Semantique - semdoc - semialign-extras - semibounded-lattices @@ -4237,9 +4246,11 @@ broken-packages: - snaplet-amqp - snaplet-css-min - snaplet-customauth + - snaplet-environments - snaplet-fay - snaplet-hslogger - snaplet-influxdb + - snaplet-mongodb-minimalistic - snaplet-persistent - snaplet-postgresql-simple - snaplet-sass @@ -5209,6 +5220,8 @@ broken-packages: - yi-spolsky - yoda - yst + - yu-core + - yu-tool - yxdb-utils - z3-encoding - z85 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index 4d40181e8d6..5e6f9510011 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -2209,6 +2209,7 @@ dont-distribute-packages: - periodic-server - perm - PermuteEffects + - persistent-audit - persistent-hssqlppp - persistent-map - persona-idp @@ -2309,6 +2310,7 @@ dont-distribute-packages: - progressbar - project-m36 - prologue + - prolude - prometheus-effect - propane - proplang @@ -3272,6 +3274,7 @@ dont-distribute-packages: - yoko - york-lava - yql + - yu-launch - yuuko - zasni-gerna - zephyr diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index fddbbb240ad..853c3b1ccb2 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -17959,6 +17959,8 @@ self: { ]; description = "Command-line tool for maintaining the Semantique database"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Semigroup" = callPackage @@ -22050,6 +22052,8 @@ self: { ]; description = "interconversion between aeson and bson"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "abides" = callPackage @@ -45866,6 +45870,8 @@ self: { libraryHaskellDepends = [ base bson ghc-prim text ]; description = "Generic functionality for BSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bson-generics" = callPackage @@ -45877,6 +45883,8 @@ self: { libraryHaskellDepends = [ base bson ghc-prim ]; description = "Generics functionality for BSON"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bson-lens" = callPackage @@ -93487,6 +93495,8 @@ self: { ]; description = "Print Forex quotes in Ledger format"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forger" = callPackage @@ -99756,6 +99766,8 @@ self: { libraryHaskellDepends = [ aeson base bson bytestring lens text ]; description = "GeoJSON data types including JSON/BSON conversion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "geolite-csv" = callPackage @@ -175222,6 +175234,8 @@ self: { ]; description = "Mollie API client for Haskell http://www.mollie.com"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-abort-fd" = callPackage @@ -176898,6 +176912,8 @@ self: { ]; description = "message queue using MongoDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mongrel2-handler" = callPackage @@ -197597,6 +197613,7 @@ self: { ]; description = "Parses a Persist Model file and produces Audit Models"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "persistent-cereal" = callPackage @@ -197818,6 +197835,8 @@ self: { ]; description = "Backend for the persistent library using mongoDB"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-mtl" = callPackage @@ -208764,6 +208783,7 @@ self: { ]; description = "ITProTV's custom prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "prometheus" = callPackage @@ -239533,6 +239553,8 @@ self: { ]; description = "DEPRECATED! You should use standard Snap >= 0.9 \"environments\" functionality. It provided ability to easly read configuration based on given app environment given at command line, envs are defined in app configuration file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-fay" = callPackage @@ -239754,6 +239776,8 @@ self: { ]; description = "Minimalistic MongoDB Snaplet"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-mysql-simple" = callPackage @@ -287440,6 +287464,8 @@ self: { testHaskellDepends = [ base blaze-markup hspec yu-utils ]; description = "The core of Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yu-launch" = callPackage @@ -287455,6 +287481,7 @@ self: { ]; description = "The launcher for Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "yu-tool" = callPackage @@ -287472,6 +287499,8 @@ self: { ]; description = "Tool for Yu"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yu-utils" = callPackage From f564565424951e703c4893fb214e6f0edfd60dfd Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 00:08:33 +0200 Subject: [PATCH 132/163] haskellPackages.large-hashable: Dontdistribute on arm --- pkgs/development/haskell-modules/configuration-arm.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/development/haskell-modules/configuration-arm.nix b/pkgs/development/haskell-modules/configuration-arm.nix index 233d962d365..b783b466ec7 100644 --- a/pkgs/development/haskell-modules/configuration-arm.nix +++ b/pkgs/development/haskell-modules/configuration-arm.nix @@ -67,7 +67,7 @@ self: super: { half = dontCheck super.half; # https://github.com/factisresearch/large-hashable/issues/17 - large-hashable = markBroken super.large-hashable; + large-hashable = markBroken (dontDistribute super.large-hashable); } // lib.optionalAttrs pkgs.stdenv.hostPlatform.isAarch32 { # AARCH32-SPECIFIC OVERRIDES From 28baff3660302765595050afca113a8c1f24e524 Mon Sep 17 00:00:00 2001 From: misuzu Date: Tue, 11 May 2021 01:40:30 +0300 Subject: [PATCH 133/163] spandsp: build on darwin (#122447) --- pkgs/development/libraries/spandsp/3.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/libraries/spandsp/3.nix b/pkgs/development/libraries/spandsp/3.nix index b3522afdf86..ceb53e05744 100644 --- a/pkgs/development/libraries/spandsp/3.nix +++ b/pkgs/development/libraries/spandsp/3.nix @@ -17,8 +17,8 @@ stdenv.mkDerivation rec { meta = { description = "A portable and modular SIP User-Agent with audio and video support"; homepage = "https://github.com/freeswitch/spandsp"; - platforms = with lib.platforms; linux; - maintainers = with lib.maintainers; [ ajs124 ]; + platforms = with lib.platforms; unix; + maintainers = with lib.maintainers; [ ajs124 misuzu ]; license = lib.licenses.gpl2; }; } From 40eeb2c6d37028396c49f49ba43bc60211b40bdb Mon Sep 17 00:00:00 2001 From: Justin Bedo Date: Mon, 10 May 2021 08:09:08 +1000 Subject: [PATCH 134/163] octopus: 0.7.3 -> 0.7.4 --- .../science/biology/octopus/default.nix | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) diff --git a/pkgs/applications/science/biology/octopus/default.nix b/pkgs/applications/science/biology/octopus/default.nix index b61a0764f2c..95912d3a7c3 100644 --- a/pkgs/applications/science/biology/octopus/default.nix +++ b/pkgs/applications/science/biology/octopus/default.nix @@ -1,28 +1,16 @@ -{lib, stdenv, fetchpatch, fetchFromGitHub, cmake, boost, gmp, htslib, zlib, xz, pkg-config}: +{lib, stdenv, fetchFromGitHub, cmake, boost, gmp, htslib, zlib, xz, pkg-config}: stdenv.mkDerivation rec { pname = "octopus"; - version = "0.7.3"; + version = "0.7.4"; src = fetchFromGitHub { owner = "luntergroup"; repo = "octopus"; rev = "v${version}"; - sha256 = "sha256-sPOBZ0YrEdjMNVye/xwqwA5IpsLy2jWN3sm/ce1fLg4="; + sha256 = "sha256-FAogksVxUlzMlC0BqRu22Vchj6VX+8yNlHRLyb3g1sE="; }; - patches = [ - # Backport TZ patchs (https://github.com/luntergroup/octopus/issues/149) - (fetchpatch { - url = "https://github.com/luntergroup/octopus/commit/3dbd8cc33616129ad356e99a4dae82e4f6702250.patch"; - sha256 = "sha256-UCufVU9x+L1zCEhkr/48KFYRvh8w26w8Jr+O+wULKK8="; - }) - (fetchpatch { - url = "https://github.com/luntergroup/octopus/commit/af5a66a2792bd098fb53eb79fb4822625f09305e.patch"; - sha256 = "sha256-r8jv6EZHfTWVLYUBau3F+ilOd9IeH8rmatorEY5LXP4="; - }) - ]; - nativeBuildInputs = [ cmake pkg-config ]; buildInputs = [ boost gmp htslib zlib xz ]; From 942debeac6e6e03fed0bcfd11322044f9bcfdba2 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 00:46:47 +0200 Subject: [PATCH 135/163] haskellPackages: Deactivate build for packages broken by relying on webkitgtk --- .../configuration-hackage2nix/main.yaml | 19 +++++++++++++++++++ .../haskell-modules/hackage-packages.nix | 17 +++++++++++++++++ 2 files changed, 36 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 885ab784f53..6149ff514a7 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -359,3 +359,22 @@ dont-distribute-packages: - tensorflow-mnist - yices-easy - yices-painless + + # These packages don‘t build because they use removed webkitgtk24x-gtk3. + - dialog + - ghcjs-dom-webkit + - gi-webkit + - hs-mesos + - jsaddle-webkitgtk + - jsc + - lambdacat + - manatee-all + - manatee-browser + - manatee-reader + - markup-preview + - spike + - web-browser-in-haskell + - webkit + - webkitgtk3 + - webkitgtk3-javascriptcore + - websnap diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 853c3b1ccb2..f9922c58ed4 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -74345,6 +74345,7 @@ self: { ]; description = "Simple dialog-based user interfaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dialogflow-fulfillment" = callPackage @@ -101716,6 +101717,7 @@ self: { ]; description = "DOM library that supports both GHCJS and WebKitGTK"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ghcjs-fetch" = callPackage @@ -103404,6 +103406,7 @@ self: { doHaddock = false; description = "WebKit bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk24x-gtk3;}; "gi-webkit2" = callPackage @@ -133997,6 +134000,7 @@ self: { tasty-quickcheck ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {mesos = null; inherit (pkgs) protobuf;}; "hs-multiaddr" = callPackage @@ -151339,6 +151343,7 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jsaddle-wkwebview" = callPackage @@ -151373,6 +151378,7 @@ self: { ]; description = "High level interface for webkit-javascriptcore"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jsmw" = callPackage @@ -156353,6 +156359,7 @@ self: { ]; description = "Webkit Browser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "lambdacms-core" = callPackage @@ -168334,6 +168341,7 @@ self: { doHaddock = false; description = "Virtual package to install all Manatee packages"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-anything" = callPackage @@ -168374,6 +168382,7 @@ self: { ]; description = "Browser extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-core" = callPackage @@ -168592,6 +168601,7 @@ self: { ]; description = "Feed reader extension for Manatee"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "manatee-template" = callPackage @@ -169233,6 +169243,7 @@ self: { ]; description = "A simple markup document preview (markdown, textile, reStructuredText)"; license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; }) {}; "marmalade-upload" = callPackage @@ -242226,6 +242237,7 @@ self: { executablePkgconfigDepends = [ libsoup ]; description = "Experimental web browser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libsoup;}; "spine" = callPackage @@ -276946,6 +276958,7 @@ self: { libraryHaskellDepends = [ base gtk webkit ]; description = "Web Browser In Haskell"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "web-css" = callPackage @@ -277825,6 +277838,7 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the Webkit library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {webkit = null;}; "webkit-javascriptcore" = callPackage @@ -277876,6 +277890,7 @@ self: { libraryToolDepends = [ gtk2hs-buildtools ]; description = "Binding to the Webkit library"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk24x-gtk3;}; "webkitgtk3-javascriptcore" = callPackage @@ -277890,6 +277905,7 @@ self: { libraryPkgconfigDepends = [ webkitgtk24x-gtk3 ]; description = "JavaScriptCore FFI from webkitgtk"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) webkitgtk24x-gtk3;}; "webmention" = callPackage @@ -278009,6 +278025,7 @@ self: { executableHaskellDepends = [ base filepath gtk webkit ]; description = "Transforms URLs to PNGs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "websockets" = callPackage From 8e89366c2b85f852720ea51844d6dce36b1edeeb Mon Sep 17 00:00:00 2001 From: ptrhlm Date: Tue, 11 May 2021 00:54:08 +0200 Subject: [PATCH 136/163] termite: fix vte patch "expose-function-for-getting-the-selected-text" (#122467) ZHF: #122042 --- ...vte-0005-expose-function-for-getting-the-selected-text.patch | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/applications/terminal-emulators/termite/vte-ng-modified-patches/vte-0005-expose-function-for-getting-the-selected-text.patch b/pkgs/applications/terminal-emulators/termite/vte-ng-modified-patches/vte-0005-expose-function-for-getting-the-selected-text.patch index 0a2c5272226..fe04434f4a2 100644 --- a/pkgs/applications/terminal-emulators/termite/vte-ng-modified-patches/vte-0005-expose-function-for-getting-the-selected-text.patch +++ b/pkgs/applications/terminal-emulators/termite/vte-ng-modified-patches/vte-0005-expose-function-for-getting-the-selected-text.patch @@ -21,7 +21,7 @@ +vte_terminal_get_selection(VteTerminal *terminal) noexcept +{ + g_return_val_if_fail(VTE_IS_TERMINAL(terminal), NULL); -+ return g_strdup (IMPL(terminal)->m_selection[VTE_SELECTION_PRIMARY]->str); ++ return g_strdup (IMPL(terminal)->m_selection[vte::to_integral(vte::platform::ClipboardType::PRIMARY)]->str); +} + /** From ccca3fc2508359580bdd3c246d3b69735fd4001e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sandro=20J=C3=A4ckel?= Date: Tue, 11 May 2021 01:09:34 +0200 Subject: [PATCH 137/163] topgrade: 6.8.0 -> 6.9.0 --- pkgs/tools/misc/topgrade/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/tools/misc/topgrade/default.nix b/pkgs/tools/misc/topgrade/default.nix index ff0661de46a..a06a0004a89 100644 --- a/pkgs/tools/misc/topgrade/default.nix +++ b/pkgs/tools/misc/topgrade/default.nix @@ -2,16 +2,16 @@ rustPlatform.buildRustPackage rec { pname = "topgrade"; - version = "6.8.0"; + version = "6.9.0"; src = fetchFromGitHub { owner = "r-darwish"; repo = pname; rev = "v${version}"; - sha256 = "sha256-PPOsb9bne0q/WGAL3W2RGo/0yxyz/XXU3xYXKcCIqX0="; + sha256 = "sha256-FW0vGwMHUgFSMggZoT+koSkub4xSKeQ+PNlvFjGIy7o="; }; - cargoSha256 = "sha256-IirU/4hE+jo5A9pB7RnePhqcbCZXBCe0Ki6i7eEWIbk="; + cargoSha256 = "sha256-+JNQITHP5rwbfavBeb4/IUo5FThhKcKDRwGeT5m6k5k="; buildInputs = lib.optional stdenv.isDarwin Foundation; From 0d3bc3db3e5c1a72487eed9fa2b95559e874787c Mon Sep 17 00:00:00 2001 From: Andrey Kuznetsov Date: Tue, 11 May 2021 02:11:49 +0300 Subject: [PATCH 138/163] nym: all platforms --- pkgs/applications/networking/nym/default.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkgs/applications/networking/nym/default.nix b/pkgs/applications/networking/nym/default.nix index 1dc41f3af97..b7bffcd694e 100644 --- a/pkgs/applications/networking/nym/default.nix +++ b/pkgs/applications/networking/nym/default.nix @@ -39,6 +39,6 @@ rustPlatform.buildRustPackage rec { homepage = "https://nymtech.net"; license = licenses.asl20; maintainers = [ maintainers.ehmry ]; - platforms = with platforms; intersectLists (linux ++ darwin) (concatLists [ x86 x86_64 aarch64 arm ]); + platforms = platforms.all; }; } From 71ed7c0d012c93d18bd3422d2e7616d13632d500 Mon Sep 17 00:00:00 2001 From: Vladyslav Burzakovskyy Date: Tue, 11 May 2021 02:16:26 +0300 Subject: [PATCH 139/163] kratos: 0.6.0-alpha.1 -> 0.6.0-alpha.2 (#122499) --- pkgs/applications/misc/kratos/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/applications/misc/kratos/default.nix b/pkgs/applications/misc/kratos/default.nix index 7f7b89618eb..65b32c45863 100644 --- a/pkgs/applications/misc/kratos/default.nix +++ b/pkgs/applications/misc/kratos/default.nix @@ -2,13 +2,13 @@ buildGoModule rec { pname = "kratos"; - version = "0.6.0-alpha.1"; + version = "0.6.0-alpha.2"; src = fetchFromGitHub { owner = "ory"; repo = "kratos"; rev = "v${version}"; - sha256 = "0lnrm7ma203b5a0vxgm9zqsbs3nigx0kng5zymrjvrzll1gd79wm"; + sha256 = "0zg6afzqi5fmr7hmy1cd7fknd1bcplz3h0f7z67l75v8k2n73md1"; }; vendorSha256 = "16qg44k97l6719hib8vbv0j15x6gvs9d6738d2y990a2qiqbsqpw"; From 50946891ce8a0dae66a6fcbe8b2bd222fe57d452 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 00:46:47 +0200 Subject: [PATCH 140/163] haskellPackages: Deactivate build for packages broken by relying on webkitqt --- .../haskell-modules/configuration-hackage2nix/main.yaml | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 6149ff514a7..b8687e76d39 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -360,11 +360,18 @@ dont-distribute-packages: - yices-easy - yices-painless - # These packages don‘t build because they use removed webkitgtk24x-gtk3. + # These packages don‘t build because they use deprecated webkit versions. + - diagrams-hsqml - dialog - ghcjs-dom-webkit - gi-webkit - hs-mesos + - hsqml + - hsqml-datamodel + - hsqml-demo-manic + - hsqml-demo-notes + - hsqml-demo-samples + - hstorchat - jsaddle-webkitgtk - jsc - lambdacat From 7be8a048040c8d4f59a548b79a345d0b101be57e Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 01:32:26 +0200 Subject: [PATCH 141/163] haskellPackages.large-hashable: Move to unsupported-platforms --- pkgs/development/haskell-modules/configuration-arm.nix | 3 --- .../haskell-modules/configuration-hackage2nix/main.yaml | 1 + 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-arm.nix b/pkgs/development/haskell-modules/configuration-arm.nix index b783b466ec7..af4893afe54 100644 --- a/pkgs/development/haskell-modules/configuration-arm.nix +++ b/pkgs/development/haskell-modules/configuration-arm.nix @@ -66,9 +66,6 @@ self: super: { # https://github.com/ekmett/half/issues/35 half = dontCheck super.half; - # https://github.com/factisresearch/large-hashable/issues/17 - large-hashable = markBroken (dontDistribute super.large-hashable); - } // lib.optionalAttrs pkgs.stdenv.hostPlatform.isAarch32 { # AARCH32-SPECIFIC OVERRIDES diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index b8687e76d39..26d4bac5482 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -260,6 +260,7 @@ unsupported-platforms: hommage-ds: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] HSoM: [ x86_64-darwin ] iwlib: [ x86_64-darwin ] + large-hashable: [ aarch64-linux ] # https://github.com/factisresearch/large-hashable/issues/17 libmodbus: [ x86_64-darwin ] libsystemd-journal: [ x86_64-darwin ] libtelnet: [ x86_64-darwin ] From 0c1fc3f74decfd79d5ce3316d4ac7fca38a081a6 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 01:33:18 +0200 Subject: [PATCH 142/163] haskellPackages: Deactivate more broken builds --- .../configuration-hackage2nix/broken.yaml | 5 +++++ .../haskell-modules/hackage-packages.nix | 13 +++++++++++++ 2 files changed, 18 insertions(+) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 70cf1599894..87fdeb4da2d 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -334,6 +334,7 @@ broken-packages: - bindings-apr - bindings-bfd - bindings-cctools + - bindings-common - bindings-dc1394 - bindings-eskit - bindings-EsounD @@ -1006,6 +1007,7 @@ broken-packages: - diet - diff - diffcabal + - differential - DifferentialEvolution - diffmap - difftodo @@ -2127,6 +2129,7 @@ broken-packages: - houseman - hp2any-core - hpack-convert + - hpapi - hpasteit - HPath - hpc-coveralls @@ -5232,7 +5235,9 @@ broken-packages: - zendesk-api - zenhack-prelude - zeno + - zeromq4-clone-pattern - zeromq4-conduit + - zeromq4-patterns - zeromq-haskell - zettelkast - ZFS diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index f9922c58ed4..24d9f052fff 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -40906,6 +40906,8 @@ self: { libraryHaskellDepends = [ base ]; description = "This package is obsolete. Look for bindings-DSL instead."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bindings-dc1394" = callPackage @@ -74683,6 +74685,8 @@ self: { ]; description = "Finds out whether an entity comes from different distributions (statuses)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diffmap" = callPackage @@ -132616,6 +132620,8 @@ self: { librarySystemDepends = [ papi ]; description = "Binding for the PAPI library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) papi;}; "hpaste" = callPackage @@ -158222,6 +158228,9 @@ self: { ]; description = "Efficiently hash (large) Haskell values"; license = lib.licenses.bsd3; + platforms = [ + "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; maintainers = with lib.maintainers; [ sternenseemann ]; }) {}; @@ -288065,6 +288074,8 @@ self: { ]; description = "Haskell implementation of the ZeroMQ clone pattern"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zeromq4-conduit" = callPackage @@ -288129,6 +288140,8 @@ self: { ]; description = "Haskell implementation of several ZeroMQ patterns"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zeromq4-simple" = callPackage From 69bc4fb5b3639567a24b1b739f0487ab08d2398d Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 01:42:13 +0200 Subject: [PATCH 143/163] haskellPackages: Disable more builds to fix eval errors --- .../configuration-hackage2nix/main.yaml | 20 ++++++++---- .../haskell-modules/hackage-packages.nix | 31 +++++++++++++++++++ 2 files changed, 45 insertions(+), 6 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 26d4bac5482..97623de8425 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -227,14 +227,15 @@ package-maintainers: - pinboard-notes-backup unsupported-platforms: + Allure: [ x86_64-darwin ] alsa-mixer: [ x86_64-darwin ] alsa-pcm: [ x86_64-darwin ] alsa-seq: [ x86_64-darwin ] AWin32Console: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] barbly: [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ] bdcs-api: [ x86_64-darwin ] - bindings-sane: [ x86_64-darwin ] bindings-directfb: [ x86_64-darwin ] + bindings-sane: [ x86_64-darwin ] cut-the-crap: [ x86_64-darwin ] d3d11binding: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] DirectSound: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] @@ -244,8 +245,9 @@ unsupported-platforms: Euterpea: [ x86_64-darwin ] freenect: [ x86_64-darwin ] FTGL: [ x86_64-darwin ] - gi-dbusmenugtk3: [ x86_64-darwin ] + ghcjs-dom-hello: [ x86_64-darwin ] gi-dbusmenu: [ x86_64-darwin ] + gi-dbusmenugtk3: [ x86_64-darwin ] gi-ggit: [ x86_64-darwin ] gi-ibus: [ x86_64-darwin ] gi-ostree: [ x86_64-darwin ] @@ -258,8 +260,11 @@ unsupported-platforms: HFuse: [ x86_64-darwin ] hidapi: [ x86_64-darwin ] hommage-ds: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] + hpapi: [ x86_64-darwin ] HSoM: [ x86_64-darwin ] iwlib: [ x86_64-darwin ] + jsaddle-webkit2gtk: [ x86_64-darwin ] + LambdaHack: [ x86_64-darwin ] large-hashable: [ aarch64-linux ] # https://github.com/factisresearch/large-hashable/issues/17 libmodbus: [ x86_64-darwin ] libsystemd-journal: [ x86_64-darwin ] @@ -269,10 +274,10 @@ unsupported-platforms: lio-fs: [ x86_64-darwin ] logging-facade-journald: [ x86_64-darwin ] midi-alsa: [ x86_64-darwin ] - mpi-hs: [ aarch64-linux, x86_64-darwin ] mpi-hs-binary: [ aarch64-linux, x86_64-darwin ] mpi-hs-cereal: [ aarch64-linux, x86_64-darwin ] mpi-hs-store: [ aarch64-linux, x86_64-darwin ] + mpi-hs: [ aarch64-linux, x86_64-darwin ] mplayer-spot: [ aarch64-linux ] oculus: [ x86_64-darwin ] pam: [ x86_64-darwin ] @@ -282,7 +287,9 @@ unsupported-platforms: posix-api: [ x86_64-darwin ] Raincat: [ x86_64-darwin ] reactivity: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] + reflex-dom-fragment-shader-canvas: [ x86_64-darwin ] reflex-dom: [ x86_64-darwin ] + reflex-localize-dom: [ x86_64-darwin ] rtlsdr: [ x86_64-darwin ] rubberband: [ x86_64-darwin ] sbv: [ aarch64-linux ] @@ -293,21 +300,22 @@ unsupported-platforms: termonad: [ x86_64-darwin ] tokyotyrant-haskell: [ x86_64-darwin ] udev: [ x86_64-darwin ] + verifiable-expressions: [ aarch64-linux ] vrpn: [ x86_64-darwin ] + vulkan-utils: [ x86_64-darwin ] vulkan: [ i686-linux, armv7l-linux, x86_64-darwin ] VulkanMemoryAllocator: [ i686-linux, armv7l-linux, x86_64-darwin ] - vulkan-utils: [ x86_64-darwin ] webkit2gtk3-javascriptcore: [ x86_64-darwin ] Win32-console: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] Win32-dhcp-server: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] Win32-errors: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] Win32-extras: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] Win32-junction-point: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] Win32-notify: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] Win32-security: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-services: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] Win32-services-wrapper: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] + Win32-services: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] + Win32: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] xattr: [ x86_64-darwin ] xgboost-haskell: [ aarch64-linux, armv7l-linux ] XInput: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 24d9f052fff..faa3042a2e5 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -954,6 +954,9 @@ self: { ]; description = "Near-future Sci-Fi roguelike and tactical squad combat game"; license = lib.licenses.agpl3Plus; + platforms = [ + "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" + ]; }) {}; "AndroidViewHierarchyImporter" = callPackage @@ -12224,6 +12227,9 @@ self: { ]; description = "A game engine library for tactical squad ASCII roguelike dungeon crawlers"; license = lib.licenses.bsd3; + platforms = [ + "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" + ]; }) {}; "LambdaINet" = callPackage @@ -74050,6 +74056,7 @@ self: { ]; description = "HsQML (Qt5) backend for Diagrams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "diagrams-html5" = callPackage @@ -101683,6 +101690,9 @@ self: { ]; description = "GHCJS DOM Hello World, an example package"; license = lib.licenses.mit; + platforms = [ + "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" + ]; }) {}; "ghcjs-dom-jsaddle" = callPackage @@ -132620,6 +132630,9 @@ self: { librarySystemDepends = [ papi ]; description = "Binding for the PAPI library"; license = lib.licenses.bsd3; + platforms = [ + "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" + ]; hydraPlatforms = lib.platforms.none; broken = true; }) {inherit (pkgs) papi;}; @@ -137677,6 +137690,7 @@ self: { ]; description = "Haskell binding for Qt Quick"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {qt5 = null;}; "hsqml-datamodel" = callPackage @@ -137689,6 +137703,7 @@ self: { libraryPkgconfigDepends = [ qt5 ]; description = "HsQML (Qt5) data model"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {qt5 = null;}; "hsqml-datamodel-vinyl" = callPackage @@ -137721,6 +137736,7 @@ self: { ]; description = "HsQML-based clone of Pipe Mania"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsqml-demo-morris" = callPackage @@ -137758,6 +137774,7 @@ self: { ]; description = "Sticky notes example program implemented in HsQML"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsqml-demo-samples" = callPackage @@ -137772,6 +137789,7 @@ self: { executableHaskellDepends = [ base hsqml OpenGL OpenGLRaw text ]; description = "HsQML sample programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hsqml-morris" = callPackage @@ -138064,6 +138082,7 @@ self: { ]; description = "Distributed instant messaging over Tor"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "hstox" = callPackage @@ -151331,6 +151350,9 @@ self: { ]; description = "Interface for JavaScript that works with GHCJS and GHC"; license = lib.licenses.mit; + platforms = [ + "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" + ]; }) {}; "jsaddle-webkitgtk" = callPackage @@ -217445,6 +217467,9 @@ self: { executableHaskellDepends = [ base reflex-dom text ]; description = "A reflex-dom widget to draw on a canvas with a fragment shader program"; license = lib.licenses.mit; + platforms = [ + "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" + ]; }) {}; "reflex-dom-helpers" = callPackage @@ -217762,6 +217787,9 @@ self: { ]; description = "Helper widgets for reflex-localize"; license = lib.licenses.mit; + platforms = [ + "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" + ]; }) {}; "reflex-monad-auth" = callPackage @@ -273052,6 +273080,9 @@ self: { ]; description = "An intermediate language for Hoare logic style verification"; license = lib.licenses.asl20; + platforms = [ + "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; }) {}; "verify" = callPackage From f7413609015ff8191ed607b64c5e975dea9af400 Mon Sep 17 00:00:00 2001 From: Fabian Affolter Date: Mon, 10 May 2021 23:15:04 +0200 Subject: [PATCH 144/163] python3Packages.pyinsteon: 1.0.10 -> 1.0.11 --- pkgs/development/python-modules/pyinsteon/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/pyinsteon/default.nix b/pkgs/development/python-modules/pyinsteon/default.nix index cfe5112ab22..be746ae2793 100644 --- a/pkgs/development/python-modules/pyinsteon/default.nix +++ b/pkgs/development/python-modules/pyinsteon/default.nix @@ -17,14 +17,14 @@ buildPythonPackage rec { pname = "pyinsteon"; - version = "1.0.10"; + version = "1.0.11"; disabled = pythonOlder "3.6"; src = fetchFromGitHub { owner = pname; repo = pname; rev = version; - sha256 = "sha256-8b/PvMFHvYGVWw6ycLnL8n972cn+1QW/VTMiblMPam4="; + sha256 = "sha256-dT01nKXDjkFSIf2BmrIcC8a9n00hlyd59oPwXn1CBaw="; }; propagatedBuildInputs = [ From b590df0f18275505a6323a69d0a04e9fc6d2859c Mon Sep 17 00:00:00 2001 From: "Robert T. McGibbon" Date: Mon, 10 May 2021 17:55:56 -0400 Subject: [PATCH 145/163] python3Packages.agate-excel: fix build --- .../python-modules/agate-excel/default.nix | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/pkgs/development/python-modules/agate-excel/default.nix b/pkgs/development/python-modules/agate-excel/default.nix index af98bbded8c..752c905ee8e 100644 --- a/pkgs/development/python-modules/agate-excel/default.nix +++ b/pkgs/development/python-modules/agate-excel/default.nix @@ -1,5 +1,5 @@ { lib, fetchPypi, buildPythonPackage -, agate, openpyxl, xlrd, nose +, agate, openpyxl, xlrd, pytestCheckHook }: buildPythonPackage rec { @@ -13,11 +13,12 @@ buildPythonPackage rec { propagatedBuildInputs = [ agate openpyxl xlrd ]; - checkInputs = [ nose ]; + checkInputs = [ pytestCheckHook ]; - checkPhase = '' - nosetests - ''; + disabledTests = [ + # See https://github.com/wireservice/agate-excel/issues/45 + "test_ambiguous_date" + ]; meta = with lib; { description = "Adds read support for excel files to agate"; From ac5ef3c55ff886e3318f5c2b806b1b33201afd50 Mon Sep 17 00:00:00 2001 From: "Robert T. McGibbon" Date: Mon, 10 May 2021 18:08:04 -0400 Subject: [PATCH 146/163] python3Packages.pytest-bdd: 4.0.1 -> 4.0.2 --- .../python-modules/pytest-bdd/default.nix | 23 +++++++++++++------ 1 file changed, 16 insertions(+), 7 deletions(-) diff --git a/pkgs/development/python-modules/pytest-bdd/default.nix b/pkgs/development/python-modules/pytest-bdd/default.nix index e71b3e7350a..b087cd6f459 100644 --- a/pkgs/development/python-modules/pytest-bdd/default.nix +++ b/pkgs/development/python-modules/pytest-bdd/default.nix @@ -1,4 +1,4 @@ -{ lib, buildPythonPackage, fetchFromGitHub +{ lib, buildPythonPackage, fetchFromGitHub, fetchpatch , execnet , glob2 , Mako @@ -7,29 +7,38 @@ , parse-type , py , pytest +, pytestCheckHook , six }: buildPythonPackage rec { pname = "pytest-bdd"; - version = "4.0.1"; + version = "4.0.2"; # tests are not included in pypi tarball src = fetchFromGitHub { owner = "pytest-dev"; repo = pname; rev = version; - sha256 = "1yqzz44as4pxffmg4hk9lijvnvlc2chg1maq1fbj5i4k4jpagvjz"; + sha256 = "0pxx4c8lm68rw0jshbr09fnadg8zz8j73q0qi49yw9s7yw86bg5l"; }; + patches = [ + # Fixed compatibility with pytest > 6.1 + (fetchpatch { + url = "https://github.com/pytest-dev/pytest-bdd/commit/e1dc0cad9a1c1ba563ccfbc24f9993d83ac59293.patch"; + sha256 = "1p3gavh6nir2a8crd5wdf0prfrg0hmgar9slvn8a21ils3k5pm5y"; + }) + ]; + + buildInputs = [ pytest ]; propagatedBuildInputs = [ glob2 Mako parse parse-type py six ]; - # Tests require extra dependencies - checkInputs = [ execnet mock pytest ]; - checkPhase = '' - PATH=$PATH:$out/bin pytest + checkInputs = [ pytestCheckHook execnet mock ]; + preCheck = '' + export PATH=$PATH:$out/bin ''; meta = with lib; { From 6af00835f78f4042d407766511cc7bd2fbff70d6 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 01:48:15 +0200 Subject: [PATCH 147/163] haskellPackages.reflex-dom: Deactivate arm-build --- .../haskell-modules/configuration-hackage2nix/main.yaml | 2 +- pkgs/development/haskell-modules/hackage-packages.nix | 4 +--- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 97623de8425..1ddef107f19 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -288,7 +288,7 @@ unsupported-platforms: Raincat: [ x86_64-darwin ] reactivity: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] reflex-dom-fragment-shader-canvas: [ x86_64-darwin ] - reflex-dom: [ x86_64-darwin ] + reflex-dom: [ x86_64-darwin, aarch64-linux ] reflex-localize-dom: [ x86_64-darwin ] rtlsdr: [ x86_64-darwin ] rubberband: [ x86_64-darwin ] diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index faa3042a2e5..604e3f717e6 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -217367,9 +217367,7 @@ self: { ]; description = "Functional Reactive Web Apps with Reflex"; license = lib.licenses.bsd3; - platforms = [ - "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" - ]; + platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ]; maintainers = with lib.maintainers; [ maralorn ]; }) {}; From 39c0dd99a48032cde3c951e61efaa78074e24960 Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 01:56:48 +0200 Subject: [PATCH 148/163] tamarin-prover: Mark broken --- pkgs/applications/science/logic/tamarin-prover/default.nix | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/pkgs/applications/science/logic/tamarin-prover/default.nix b/pkgs/applications/science/logic/tamarin-prover/default.nix index d217e2b9b50..a77f2dbac44 100644 --- a/pkgs/applications/science/logic/tamarin-prover/default.nix +++ b/pkgs/applications/science/logic/tamarin-prover/default.nix @@ -92,4 +92,8 @@ mkDerivation (common "tamarin-prover" src // { tamarin-prover-term tamarin-prover-theory ]; + + # tamarin-prover 1.6 is incompatible with maude 3.1. + hydraPlatforms = lib.platforms.none; + broken = true; }) From aaa16732ce3d3001e238eb4074cd68b8f300f77f Mon Sep 17 00:00:00 2001 From: David Date: Sat, 8 May 2021 13:18:00 +0200 Subject: [PATCH 149/163] rebar3: add rebar3WithPlugins --- doc/languages-frameworks/beam.section.md | 4 + pkgs/development/beam-modules/default.nix | 2 +- .../tools/build-managers/rebar3/default.nix | 153 +++++++++++------- .../rebar3/global-plugins.patch | 14 ++ .../build-managers/rebar3/skip-plugins.patch | 54 +++++++ pkgs/top-level/all-packages.nix | 2 +- 6 files changed, 167 insertions(+), 62 deletions(-) create mode 100644 pkgs/development/tools/build-managers/rebar3/global-plugins.patch create mode 100644 pkgs/development/tools/build-managers/rebar3/skip-plugins.patch diff --git a/doc/languages-frameworks/beam.section.md b/doc/languages-frameworks/beam.section.md index b5d39595c10..947968db15e 100644 --- a/doc/languages-frameworks/beam.section.md +++ b/doc/languages-frameworks/beam.section.md @@ -24,6 +24,10 @@ Many Erlang/OTP distributions available in `beam.interpreters` have versions wit We provide a version of Rebar3, under `rebar3`. We also provide a helper to fetch Rebar3 dependencies from a lockfile under `fetchRebar3Deps`. +We also provide a version on Rebar3 with plugins included, under `rebar3WithPlugins`. This package is a function which takes two arguments: `plugins`, a list of nix derivations to include as plugins (loaded only when specified in `rebar.config`), and `globalPlugins`, which should always be loaded by rebar3. Example: `rebar3WithPlugins { globalPlugins = [beamPackages.pc]; }`. + +When adding a new plugin it is important that the `packageName` attribute is the same as the atom used by rebar3 to refer to the plugin. + ### Mix & Erlang.mk {#build-tools-other} Erlang.mk works exactly as expected. There is a bootstrap process that needs to be run, which is supported by the `buildErlangMk` derivation. diff --git a/pkgs/development/beam-modules/default.nix b/pkgs/development/beam-modules/default.nix index 6bf9e45e622..19b5c122d9e 100644 --- a/pkgs/development/beam-modules/default.nix +++ b/pkgs/development/beam-modules/default.nix @@ -18,8 +18,8 @@ let inherit callPackage erlang; beamPackages = self; + inherit (callPackage ../tools/build-managers/rebar3 { }) rebar3 rebar3WithPlugins; rebar = callPackage ../tools/build-managers/rebar { }; - rebar3 = callPackage ../tools/build-managers/rebar3 { }; # rebar3 port compiler plugin is required by buildRebar3 pc = callPackage ./pc { }; diff --git a/pkgs/development/tools/build-managers/rebar3/default.nix b/pkgs/development/tools/build-managers/rebar3/default.nix index b9070a42764..b44a8c08ffa 100644 --- a/pkgs/development/tools/build-managers/rebar3/default.nix +++ b/pkgs/development/tools/build-managers/rebar3/default.nix @@ -1,71 +1,104 @@ { lib, stdenv, fetchFromGitHub, - fetchHex, erlang, - tree }: + fetchHex, erlang, makeWrapper }: let version = "3.15.1"; + owner = "erlang"; + deps = import ./rebar-deps.nix { inherit fetchHex fetchFromGitHub; }; + rebar3 = stdenv.mkDerivation rec { + pname = "rebar3"; + inherit version erlang; - # Dependencies should match the ones in: - # https://github.com/erlang/rebar3/blob/${version}/rebar.lock - # `sha256` could also be taken from https://hex.pm - Checksum - deps = import ./rebar-deps.nix { inherit fetchHex; }; -in -stdenv.mkDerivation rec { - pname = "rebar3"; - inherit version erlang; + # How to obtain `sha256`: + # nix-prefetch-url --unpack https://github.com/erlang/rebar3/archive/${version}.tar.gz + src = fetchFromGitHub { + inherit owner; + repo = pname; + rev = version; + sha256 = "1pcy5m79g0l9l3d8lkbx6cq1w87z1g3sa6wwvgbgraj2v3wkyy5g"; + }; + + bootstrapper = ./rebar3-nix-bootstrap; + + buildInputs = [ erlang ]; + + postPatch = '' + mkdir -p _checkouts _build/default/lib/ + + ${toString (lib.mapAttrsToList (k: v: '' + cp -R --no-preserve=mode ${v} _checkouts/${k} + '') deps)} + + # Bootstrap script expects the dependencies in _build/default/lib + # TODO: Make it accept checkouts? + for i in _checkouts/* ; do + ln -s $(pwd)/$i $(pwd)/_build/default/lib/ + done + ''; + + buildPhase = '' + HOME=. escript bootstrap + ''; + + installPhase = '' + mkdir -p $out/bin + cp rebar3 $out/bin/rebar3 + ''; + + meta = { + homepage = "https://github.com/rebar/rebar3"; + description = "Erlang build tool that makes it easy to compile and test Erlang applications, port drivers and releases"; + + longDescription = '' + rebar is a self-contained Erlang script, so it's easy to distribute or + even embed directly in a project. Where possible, rebar uses standard + Erlang/OTP conventions for project structures, thus minimizing the amount + of build configuration work. rebar also provides dependency management, + enabling application writers to easily re-use common libraries from a + variety of locations (hex.pm, git, hg, and so on). + ''; + + platforms = lib.platforms.unix; + maintainers = lib.teams.beam.members; + license = lib.licenses.asl20; + }; - # How to obtain `sha256`: - # nix-prefetch-url --unpack https://github.com/erlang/rebar3/archive/${version}.tar.gz - src = fetchFromGitHub { - owner = "erlang"; - repo = pname; - rev = version; - sha256 = "1pcy5m79g0l9l3d8lkbx6cq1w87z1g3sa6wwvgbgraj2v3wkyy5g"; }; + rebar3WithPlugins = { plugins ? [ ], globalPlugins ? [ ] }: + let + pluginLibDirs = map (p: "${p}/lib/erlang/lib") (lib.unique (plugins ++ globalPlugins)); + globalPluginNames = lib.unique (map (p: p.packageName) globalPlugins); + rebar3Patched = (rebar3.overrideAttrs (old: { - bootstrapper = ./rebar3-nix-bootstrap; + # skip-plugins.patch is necessary because otherwise rebar3 will always + # try to fetch plugins if they are not already present in _build. + # + # global-deps.patch makes it possible to use REBAR_GLOBAL_PLUGINS to + # instruct rebar3 to always load a certain plugin. It is necessary since + # REBAR_GLOBAL_CONFIG_DIR doesn't seem to work for this. + patches = [ ./skip-plugins.patch ./global-plugins.patch ]; + })); + in stdenv.mkDerivation { + pname = "rebar3-with-plugins"; + inherit (rebar3) version bootstrapper; + nativeBuildInputs = [ erlang makeWrapper ]; + unpackPhase = "true"; - buildInputs = [ erlang tree ]; + # Here we extract the rebar3 escript (like `rebar3_prv_local_install.erl`) and + # add plugins to the code path. - postPatch = '' - mkdir -p _checkouts - mkdir -p _build/default/lib/ - - ${toString (lib.mapAttrsToList (k: v: '' - cp -R --no-preserve=mode ${v} _checkouts/${k} - '') deps)} - - # Bootstrap script expects the dependencies in _build/default/lib - # TODO: Make it accept checkouts? - for i in _checkouts/* ; do - ln -s $(pwd)/$i $(pwd)/_build/default/lib/ - done - ''; - - buildPhase = '' - HOME=. escript bootstrap - ''; - - installPhase = '' - mkdir -p $out/bin - cp rebar3 $out/bin/rebar3 - ''; - - meta = { - homepage = "https://github.com/rebar/rebar3"; - description = "Erlang build tool that makes it easy to compile and test Erlang applications, port drivers and releases"; - - longDescription = '' - rebar is a self-contained Erlang script, so it's easy to distribute or - even embed directly in a project. Where possible, rebar uses standard - Erlang/OTP conventions for project structures, thus minimizing the amount - of build configuration work. rebar also provides dependency management, - enabling application writers to easily re-use common libraries from a - variety of locations (hex.pm, git, hg, and so on). + installPhase = '' + erl -noshell -eval ' + {ok, Escript} = escript:extract("${rebar3Patched}/bin/rebar3", []), + {archive, Archive} = lists:keyfind(archive, 1, Escript), + {ok, _} = zip:extract(Archive, [{cwd, "'$out/lib'"}]), + init:stop(0) + ' + mkdir -p $out/bin + makeWrapper ${erlang}/bin/erl $out/bin/rebar3 \ + --set REBAR_GLOBAL_PLUGINS "${toString globalPluginNames}" \ + --suffix-each ERL_LIBS ":" "$out/lib ${toString pluginLibDirs}" \ + --add-flags "+sbtu +A1 -noshell -boot start_clean -s rebar3 main -extra" ''; - - platforms = lib.platforms.unix; - maintainers = lib.teams.beam.members; - license = lib.licenses.asl20; - }; -} + }; +in { inherit rebar3 rebar3WithPlugins; } diff --git a/pkgs/development/tools/build-managers/rebar3/global-plugins.patch b/pkgs/development/tools/build-managers/rebar3/global-plugins.patch new file mode 100644 index 00000000000..9a8bb48f988 --- /dev/null +++ b/pkgs/development/tools/build-managers/rebar3/global-plugins.patch @@ -0,0 +1,14 @@ +diff --git a/src/rebar_plugins.erl b/src/rebar_plugins.erl +index f2d22233..bee2cf18 100644 +--- a/src/rebar_plugins.erl ++++ b/src/rebar_plugins.erl +@@ -30,7 +30,8 @@ project_plugins_install(State) -> + top_level_install(State) -> + Profiles = rebar_state:current_profiles(State), + lists:foldl(fun(Profile, StateAcc) -> +- Plugins = rebar_state:get(State, {plugins, Profile}, []), ++ Plugins = rebar_state:get(State, {plugins, Profile}, []) ++ ++ [list_to_atom(P) || P <- string:lexemes(os:getenv("REBAR_GLOBAL_PLUGINS", ""), " ")], + handle_plugins(Profile, Plugins, StateAcc) + end, State, Profiles). + diff --git a/pkgs/development/tools/build-managers/rebar3/skip-plugins.patch b/pkgs/development/tools/build-managers/rebar3/skip-plugins.patch new file mode 100644 index 00000000000..3ee1656c9ed --- /dev/null +++ b/pkgs/development/tools/build-managers/rebar3/skip-plugins.patch @@ -0,0 +1,54 @@ +diff --git a/src/rebar_plugins.erl b/src/rebar_plugins.erl +index f2d22233..c61fa553 100644 +--- a/src/rebar_plugins.erl ++++ b/src/rebar_plugins.erl +@@ -106,31 +106,9 @@ handle_plugins(Profile, Plugins, State, Upgrade) -> + State3 = rebar_state:set(State2, deps_dir, DepsDir), + rebar_state:lock(State3, Locks). + +-handle_plugin(Profile, Plugin, State, Upgrade) -> ++handle_plugin(_Profile, Plugin, State, _Upgrade) -> + try +- {Apps, State2} = rebar_prv_install_deps:handle_deps_as_profile(Profile, State, [Plugin], Upgrade), +- {no_cycle, Sorted} = rebar_prv_install_deps:find_cycles(Apps), +- ToBuild = rebar_prv_install_deps:cull_compile(Sorted, []), +- +- %% Add already built plugin deps to the code path +- ToBuildPaths = [rebar_app_info:ebin_dir(A) || A <- ToBuild], +- PreBuiltPaths = [Ebin || A <- Apps, +- Ebin <- [rebar_app_info:ebin_dir(A)], +- not lists:member(Ebin, ToBuildPaths)], +- code:add_pathsa(PreBuiltPaths), +- +- %% Build plugin and its deps +- build_plugins(ToBuild, Apps, State2), +- +- %% Add newly built deps and plugin to code path +- State3 = rebar_state:update_all_plugin_deps(State2, Apps), +- NewCodePaths = [rebar_app_info:ebin_dir(A) || A <- ToBuild], +- +- %% Store plugin code paths so we can remove them when compiling project apps +- State4 = rebar_state:update_code_paths(State3, all_plugin_deps, PreBuiltPaths++NewCodePaths), +- rebar_paths:set_paths([plugins], State4), +- +- {plugin_providers(Plugin), State4} ++ {plugin_providers(Plugin), State} + catch + ?WITH_STACKTRACE(C,T,S) + ?DEBUG("~p ~p ~p", [C, T, S]), +@@ -138,15 +116,6 @@ handle_plugin(Profile, Plugin, State, Upgrade) -> + {[], State} + end. + +-build_plugins(MustBuildApps, AllApps, State) -> +- State1 = rebar_state:deps_to_build(State, MustBuildApps), +- State2 = rebar_state:all_deps(State1, AllApps), +- State3 = rebar_state:set(State2, deps_dir, ?DEFAULT_PLUGINS_DIR), +- {Args, Extra} = rebar_state:command_parsed_args(State), +- State4 = rebar_state:command_parsed_args(State3, {[{deps_only, true}|Args], Extra}), +- rebar_prv_compile:do(State4), +- ok. +- + plugin_providers({Plugin, _, _, _}) when is_atom(Plugin) -> + validate_plugin(Plugin); + plugin_providers({Plugin, _, _}) when is_atom(Plugin) -> diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 67f7e4fffc8..e7cfe7eaf95 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -11855,7 +11855,7 @@ in erlang_nox = beam_nox.interpreters.erlang; inherit (beam.packages.erlang) - rebar rebar3 + rebar rebar3 rebar3WithPlugins fetchHex beamPackages relxExe; From dcc075ce21152964f8107e0ddf5140723e881e2b Mon Sep 17 00:00:00 2001 From: David Date: Sat, 8 May 2021 13:47:27 +0200 Subject: [PATCH 150/163] buildRebar3: use rebar3WithPlugins --- .../development/beam-modules/build-rebar3.nix | 13 +++--- .../tools/build-managers/rebar3/default.nix | 2 +- .../rebar3/rebar3-nix-bootstrap | 41 +------------------ 3 files changed, 8 insertions(+), 48 deletions(-) diff --git a/pkgs/development/beam-modules/build-rebar3.nix b/pkgs/development/beam-modules/build-rebar3.nix index 2e2f0a50b31..651c024db09 100644 --- a/pkgs/development/beam-modules/build-rebar3.nix +++ b/pkgs/development/beam-modules/build-rebar3.nix @@ -1,4 +1,4 @@ -{ stdenv, writeText, erlang, rebar3, openssl, libyaml, +{ stdenv, writeText, erlang, rebar3WithPlugins, openssl, libyaml, pc, lib }: { name, version @@ -19,7 +19,10 @@ with lib; let debugInfoFlag = lib.optionalString (enableDebugInfo || erlang.debugInfo) "debug-info"; - ownPlugins = buildPlugins ++ (if compilePorts then [pc] else []); + rebar3 = rebar3WithPlugins { + plugins = buildPlugins; + globalPlugins = (if compilePorts then [pc] else []); + }; shell = drv: stdenv.mkDerivation { name = "interactive-shell-${drv.name}"; @@ -36,13 +39,9 @@ let inherit version; buildInputs = buildInputs ++ [ erlang rebar3 openssl libyaml ]; - propagatedBuildInputs = unique (beamDeps ++ ownPlugins); + propagatedBuildInputs = unique beamDeps; dontStrip = true; - # The following are used by rebar3-nix-bootstrap - inherit compilePorts; - buildPlugins = ownPlugins; - inherit src; setupHook = writeText "setupHook.sh" '' diff --git a/pkgs/development/tools/build-managers/rebar3/default.nix b/pkgs/development/tools/build-managers/rebar3/default.nix index b44a8c08ffa..16b630f36b9 100644 --- a/pkgs/development/tools/build-managers/rebar3/default.nix +++ b/pkgs/development/tools/build-managers/rebar3/default.nix @@ -4,7 +4,7 @@ let version = "3.15.1"; owner = "erlang"; - deps = import ./rebar-deps.nix { inherit fetchHex fetchFromGitHub; }; + deps = import ./rebar-deps.nix { inherit fetchHex; }; rebar3 = stdenv.mkDerivation rec { pname = "rebar3"; inherit version erlang; diff --git a/pkgs/development/tools/build-managers/rebar3/rebar3-nix-bootstrap b/pkgs/development/tools/build-managers/rebar3/rebar3-nix-bootstrap index f1deed1df35..8bfbb8fb685 100755 --- a/pkgs/development/tools/build-managers/rebar3/rebar3-nix-bootstrap +++ b/pkgs/development/tools/build-managers/rebar3/rebar3-nix-bootstrap @@ -26,9 +26,7 @@ -record(data, {version , debug_info = false - , compile_ports , erl_libs - , plugins , root , name}). @@ -42,7 +40,6 @@ main(Args) -> -spec do_the_bootstrap(#data{}) -> ok. do_the_bootstrap(RequiredData) -> ok = bootstrap_configs(RequiredData), - ok = bootstrap_plugins(RequiredData), ok = bootstrap_libs(RequiredData). %% @doc @@ -68,22 +65,8 @@ parse_args(Args0) -> bootstrap_configs(RequiredData)-> io:format("Boostrapping app and rebar configurations~n"), ok = if_single_app_project_update_app_src_version(RequiredData), - ok = if_compile_ports_add_pc_plugin(RequiredData), ok = if_debug_info_add(RequiredData). --spec bootstrap_plugins(#data{}) -> ok. -bootstrap_plugins(#data{plugins = Plugins}) -> - io:format("Bootstrapping rebar3 plugins~n"), - Target = "_build/default/plugins/", - Paths = string:tokens(Plugins, " "), - CopiableFiles = - lists:foldl(fun(Path, Acc) -> - gather_dependency(Path) ++ Acc - end, [], Paths), - lists:foreach(fun (Path) -> - ok = link_app(Path, Target) - end, CopiableFiles). - -spec bootstrap_libs(#data{}) -> ok. bootstrap_libs(#data{erl_libs = ErlLibs}) -> io:format("Bootstrapping dependent libraries~n"), @@ -152,10 +135,9 @@ fixup_app_name(FileName) -> gather_required_data_from_the_environment(ArgData) -> {ok, ArgData#data{ version = guard_env("version") , erl_libs = get_env("ERL_LIBS", []) - , plugins = get_env("buildPlugins", []) , root = code:root_dir() , name = guard_env("name") - , compile_ports = nix2bool(get_env("compilePorts", ""))}}. + }}. -spec nix2bool(any()) -> boolean(). nix2bool("1") -> @@ -209,27 +191,6 @@ add_debug_info(Config) -> {erl_opts, [debug_info | ExistingOpts]}) end. - -%% @doc -%% If the compile ports flag is set, rewrite the rebar config to -%% include the 'pc' plugin. --spec if_compile_ports_add_pc_plugin(#data{}) -> ok. -if_compile_ports_add_pc_plugin(#data{compile_ports = true}) -> - ConfigTerms = add_pc_to_plugins(read_rebar_config()), - Text = lists:map(fun(Term) -> io_lib:format("~tp.~n", [Term]) end, - ConfigTerms), - file:write_file("rebar.config", Text); -if_compile_ports_add_pc_plugin(_) -> - ok. - --spec add_pc_to_plugins([term()]) -> [term()]. -add_pc_to_plugins(Config) -> - PluginList = case lists:keysearch(plugins, 1, Config) of - {value, {plugins, ExistingPluginList}} -> ExistingPluginList; - _ -> [] - end, - lists:keystore(plugins, 1, Config, {plugins, [pc | PluginList]}). - -spec read_rebar_config() -> [term()]. read_rebar_config() -> case file:consult("rebar.config") of From 81310256a99929d2f65f5198aad6503e4e2e855f Mon Sep 17 00:00:00 2001 From: Martin Weinelt Date: Mon, 10 May 2021 23:16:19 +0200 Subject: [PATCH 151/163] home-assistant: 2021.5.1 -> 2021.5.2 --- pkgs/servers/home-assistant/component-packages.nix | 4 ++-- pkgs/servers/home-assistant/default.nix | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pkgs/servers/home-assistant/component-packages.nix b/pkgs/servers/home-assistant/component-packages.nix index 923e18bd586..afaef82d372 100644 --- a/pkgs/servers/home-assistant/component-packages.nix +++ b/pkgs/servers/home-assistant/component-packages.nix @@ -2,7 +2,7 @@ # Do not edit! { - version = "2021.5.1"; + version = "2021.5.2"; components = { "abode" = ps: with ps; [ abodepy ]; "accuweather" = ps: with ps; [ accuweather ]; @@ -375,7 +375,7 @@ "hvv_departures" = ps: with ps; [ ]; # missing inputs: pygti "hydrawise" = ps: with ps; [ hydrawiser ]; "hyperion" = ps: with ps; [ hyperion-py ]; - "ialarm" = ps: with ps; [ ]; # missing inputs: pyialarm + "ialarm" = ps: with ps; [ pyialarm ]; "iammeter" = ps: with ps; [ ]; # missing inputs: iammeter "iaqualink" = ps: with ps; [ iaqualink ]; "icloud" = ps: with ps; [ pyicloud ]; diff --git a/pkgs/servers/home-assistant/default.nix b/pkgs/servers/home-assistant/default.nix index 5383ae33d13..11bf2c744d3 100644 --- a/pkgs/servers/home-assistant/default.nix +++ b/pkgs/servers/home-assistant/default.nix @@ -114,7 +114,7 @@ let extraBuildInputs = extraPackages py.pkgs; # Don't forget to run parse-requirements.py after updating - hassVersion = "2021.5.1"; + hassVersion = "2021.5.2"; in with py.pkgs; buildPythonApplication rec { pname = "homeassistant"; @@ -133,7 +133,7 @@ in with py.pkgs; buildPythonApplication rec { owner = "home-assistant"; repo = "core"; rev = version; - sha256 = "0bipjfkz4zqhy84jgrn3qxvs4nxya3j08lcsq3xa31xfz8wnpxwj"; + sha256 = "1v1ah0kdkhx0pkma2qnk56iv00r2lb4i3sfpwlcr64gfkpzpakv8"; }; # leave this in, so users don't have to constantly update their downstream patch handling From 206f155928ca63ff297ce50bedb6c8198483e8a0 Mon Sep 17 00:00:00 2001 From: Martin Weinelt Date: Tue, 11 May 2021 01:03:29 +0200 Subject: [PATCH 152/163] python3Packages.pysonos: 0.0.44 -> 0.0.45 --- pkgs/development/python-modules/pysonos/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/development/python-modules/pysonos/default.nix b/pkgs/development/python-modules/pysonos/default.nix index 3219bd53ac1..e4296a4f0b5 100644 --- a/pkgs/development/python-modules/pysonos/default.nix +++ b/pkgs/development/python-modules/pysonos/default.nix @@ -14,7 +14,7 @@ buildPythonPackage rec { pname = "pysonos"; - version = "0.0.44"; + version = "0.0.45"; disabled = !isPy3k; @@ -23,7 +23,7 @@ buildPythonPackage rec { owner = "amelchio"; repo = pname; rev = "v${version}"; - sha256 = "108818mkb037zs4ikilrskfppcbmqslsm6zaxmy8pphjh7c299mz"; + sha256 = "0wzmrd9ja5makvsgf0ckil99wr8vw91dml8fi9miiq4la0100q0n"; }; propagatedBuildInputs = [ ifaddr requests xmltodict ]; From 2a11ad94c62ba6c6ab29e0a7398ea7a0b4093d6b Mon Sep 17 00:00:00 2001 From: Malte Brandy Date: Tue, 11 May 2021 02:06:17 +0200 Subject: [PATCH 153/163] haskellPackages.reflex-dom-*: Remove more aarch64 builds --- .../haskell-modules/configuration-hackage2nix/main.yaml | 4 ++-- pkgs/development/haskell-modules/hackage-packages.nix | 8 ++------ 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 1ddef107f19..cc33944d1ee 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -287,9 +287,9 @@ unsupported-platforms: posix-api: [ x86_64-darwin ] Raincat: [ x86_64-darwin ] reactivity: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - reflex-dom-fragment-shader-canvas: [ x86_64-darwin ] + reflex-dom-fragment-shader-canvas: [ x86_64-darwin, aarch64-linux ] reflex-dom: [ x86_64-darwin, aarch64-linux ] - reflex-localize-dom: [ x86_64-darwin ] + reflex-localize-dom: [ x86_64-darwin, aarch64-linux ] rtlsdr: [ x86_64-darwin ] rubberband: [ x86_64-darwin ] sbv: [ aarch64-linux ] diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 604e3f717e6..d04023b09e8 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -217465,9 +217465,7 @@ self: { executableHaskellDepends = [ base reflex-dom text ]; description = "A reflex-dom widget to draw on a canvas with a fragment shader program"; license = lib.licenses.mit; - platforms = [ - "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" - ]; + platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ]; }) {}; "reflex-dom-helpers" = callPackage @@ -217785,9 +217783,7 @@ self: { ]; description = "Helper widgets for reflex-localize"; license = lib.licenses.mit; - platforms = [ - "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux" - ]; + platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ]; }) {}; "reflex-monad-auth" = callPackage From 4b9a7b96dc36ae87da93152c8f57c91823ae9969 Mon Sep 17 00:00:00 2001 From: "R. RyanTM" Date: Tue, 11 May 2021 00:34:00 +0000 Subject: [PATCH 154/163] agi: 1.1.0-dev-20210506 -> 1.1.0-dev-20210507 --- pkgs/tools/graphics/agi/default.nix | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkgs/tools/graphics/agi/default.nix b/pkgs/tools/graphics/agi/default.nix index b7cfefe70cb..9c9356371b6 100644 --- a/pkgs/tools/graphics/agi/default.nix +++ b/pkgs/tools/graphics/agi/default.nix @@ -14,11 +14,11 @@ stdenv.mkDerivation rec { pname = "agi"; - version = "1.1.0-dev-20210506"; + version = "1.1.0-dev-20210507"; src = fetchzip { url = "https://github.com/google/agi-dev-releases/releases/download/v${version}/agi-${version}-linux.zip"; - sha256 = "sha256-VB9AL2h+e+92lhsfdYHbSgv5AIrgEPJsa74VGncDHGo="; + sha256 = "sha256-Tbxbsh40Lel4kGnCIWyNRge15Y71ao+oUixClBdj4f4="; }; nativeBuildInputs = [ From b8a7603c6d3582bdaf24688579014429a70cfc2e Mon Sep 17 00:00:00 2001 From: Evils Date: Sun, 9 May 2021 02:30:09 +0200 Subject: [PATCH 155/163] pycflow2dot: init at 0.2.3 --- .../python-modules/pycflow2dot/default.nix | 41 +++++++++++++++++++ pkgs/top-level/all-packages.nix | 2 + pkgs/top-level/python-packages.nix | 4 ++ 3 files changed, 47 insertions(+) create mode 100644 pkgs/development/python-modules/pycflow2dot/default.nix diff --git a/pkgs/development/python-modules/pycflow2dot/default.nix b/pkgs/development/python-modules/pycflow2dot/default.nix new file mode 100644 index 00000000000..db1ac8fabb2 --- /dev/null +++ b/pkgs/development/python-modules/pycflow2dot/default.nix @@ -0,0 +1,41 @@ +{ lib +, buildPythonPackage +, fetchPypi +, cflow +, graphviz +, pydot +, networkx +, which +}: + +buildPythonPackage rec { + pname = "pycflow2dot"; + version = "0.2.3"; + + src = fetchPypi { + inherit pname version; + sha256 = "1zm8x2pd0q6zza0fw7hg9g1qvybfnjq6ql9b8mh2fc45l7l25655"; + }; + + propagatedBuildInputs = [ + cflow + graphviz + pydot + networkx + which + ]; + + pythonImportsCheck = [ "pycflow2dot" ]; + checkPhase = '' + cd tests + export PATH=$out/bin:$PATH + make all + ''; + + meta = with lib; { + description = "Layout C call graphs from cflow using GraphViz dot"; + homepage = "https://github.com/johnyf/pycflow2dot"; + license = licenses.gpl3Plus; + maintainers = with maintainers; [ evils ]; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index e7cfe7eaf95..d592008e241 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -7820,6 +7820,8 @@ in pycangjie = pythonPackages.pycangjie; + pycflow2dot = with python.pkgs; toPythonApplication pycflow2dot; + pydb = callPackage ../development/tools/pydb { }; pydf = callPackage ../applications/misc/pydf { }; diff --git a/pkgs/top-level/python-packages.nix b/pkgs/top-level/python-packages.nix index f4f6a4d6e36..0d75625019b 100644 --- a/pkgs/top-level/python-packages.nix +++ b/pkgs/top-level/python-packages.nix @@ -5410,6 +5410,10 @@ in { pycfdns = callPackage ../development/python-modules/pycfdns { }; + pycflow2dot = callPackage ../development/python-modules/pycflow2dot { + inherit (pkgs) graphviz; + }; + pychannels = callPackage ../development/python-modules/pychannels { }; pychart = callPackage ../development/python-modules/pychart { }; From 63872607cd5f5c550189b0788eb59224c614e996 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Tue, 11 May 2021 09:22:26 +0800 Subject: [PATCH 156/163] vimPlugins: update --- pkgs/misc/vim-plugins/generated.nix | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index a0eb16763f7..705e7ec7902 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -389,12 +389,12 @@ let chadtree = buildVimPluginFrom2Nix { pname = "chadtree"; - version = "2021-05-10"; + version = "2021-05-11"; src = fetchFromGitHub { owner = "ms-jpq"; repo = "chadtree"; - rev = "d6ddb11b13a28f858344cdfafbe4d76fe032803a"; - sha256 = "0wr6m0i0lj5dpp0rbqyx534jnwpmrrywjq55xai5z799dh4in42k"; + rev = "2ccce5fa035176b51fa628ba6c672dedf78813e8"; + sha256 = "0nrxxwf4wy6g5222qf4bjbyai8gym1k0b4wdyjpldfk5pdxd81zg"; }; meta.homepage = "https://github.com/ms-jpq/chadtree/"; }; @@ -702,12 +702,12 @@ let context_filetype-vim = buildVimPluginFrom2Nix { pname = "context_filetype-vim"; - version = "2021-03-04"; + version = "2021-05-11"; src = fetchFromGitHub { owner = "Shougo"; repo = "context_filetype.vim"; - rev = "f5e4ed8f7847cd5474017459c2a0f2dfd2bf971c"; - sha256 = "039mnsd6k0sgs8l1a8ngl3y817c8g657nv8v9bdw9h8l5a934cb2"; + rev = "39a552866c83946127f244912b6d408525f03364"; + sha256 = "0m2w4f3bn8miplxb9q76fcipdkc9lbfyp47193q57s555b1g0x0k"; }; meta.homepage = "https://github.com/Shougo/context_filetype.vim/"; }; @@ -1503,8 +1503,8 @@ let src = fetchFromGitHub { owner = "rafamadriz"; repo = "friendly-snippets"; - rev = "83de9287ad388f55b7d74f66b8ea5b89bb6abf24"; - sha256 = "13jp8bg85yyxyl390ymrp6qasg4p6a57x08m2l9ld8wiq33ps6yp"; + rev = "9178101a99226fb4a973fd88ba6e84972c7b0a94"; + sha256 = "1dy9b5ipzs412sz31mqqrr6rfjs24569pw17z9b3z40dipmzg1x8"; }; meta.homepage = "https://github.com/rafamadriz/friendly-snippets/"; }; @@ -7087,12 +7087,12 @@ let vim-matchup = buildVimPluginFrom2Nix { pname = "vim-matchup"; - version = "2021-05-09"; + version = "2021-05-10"; src = fetchFromGitHub { owner = "andymass"; repo = "vim-matchup"; - rev = "2032562ba91b9904fdbaac8a586d93fc69d5aec6"; - sha256 = "1d38dx5s89113iglbji3q4va3hnjqa6cx141faldp283v39y2qv2"; + rev = "ea2612d87a38ef2261f66063571eef06689bbb8e"; + sha256 = "0a7dxvl8p3n8kfm1abm1k2r9l6s230585521scgh8y1sh88zkpay"; }; meta.homepage = "https://github.com/andymass/vim-matchup/"; }; From 28ed9e7f3c934bccdcd716a9364b4d4e87088602 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Tue, 11 May 2021 09:25:08 +0800 Subject: [PATCH 157/163] vimPlugins.Shade-nvim: init at 2021-04-29 --- pkgs/misc/vim-plugins/generated.nix | 12 ++++++++++++ pkgs/misc/vim-plugins/vim-plugin-names | 1 + 2 files changed, 13 insertions(+) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index 705e7ec7902..d391f145b48 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -4127,6 +4127,18 @@ let meta.homepage = "https://github.com/osyo-manga/shabadou.vim/"; }; + Shade-nvim = buildVimPluginFrom2Nix { + pname = "Shade-nvim"; + version = "2021-04-29"; + src = fetchFromGitHub { + owner = "sunjon"; + repo = "Shade.nvim"; + rev = "0196387bba50b8d36cec99cd6483583ff2dedb42"; + sha256 = "0831k71gm8rpl54x63v7mgp9i1fgxydp2wig3yyd98dc7z9d8f48"; + }; + meta.homepage = "https://github.com/sunjon/Shade.nvim/"; + }; + ShowMultiBase = buildVimPluginFrom2Nix { pname = "ShowMultiBase"; version = "2010-10-18"; diff --git a/pkgs/misc/vim-plugins/vim-plugin-names b/pkgs/misc/vim-plugins/vim-plugin-names index 50b26968f8c..292f30997da 100644 --- a/pkgs/misc/vim-plugins/vim-plugin-names +++ b/pkgs/misc/vim-plugins/vim-plugin-names @@ -596,6 +596,7 @@ steelsojka/completion-buffers stefandtw/quickfix-reflector.vim stephpy/vim-yaml sunaku/vim-dasht +sunjon/Shade.nvim svermeulen/vim-subversive t9md/vim-choosewin t9md/vim-smalls From 8e5211de812c1e2b8eb8c6069cdd9e95983efad0 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Tue, 11 May 2021 09:33:11 +0800 Subject: [PATCH 158/163] vimPlugins.floating-nvim: init at 2021-05-08 --- pkgs/misc/vim-plugins/generated.nix | 12 ++++++++++++ pkgs/misc/vim-plugins/vim-plugin-names | 1 + 2 files changed, 13 insertions(+) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index d391f145b48..f7890b076ca 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -1473,6 +1473,18 @@ let meta.homepage = "https://github.com/ncm2/float-preview.nvim/"; }; + floating-nvim = buildVimPluginFrom2Nix { + pname = "floating-nvim"; + version = "2021-05-08"; + src = fetchFromGitHub { + owner = "fhill2"; + repo = "floating.nvim"; + rev = "c47af010aa8e88758995858f0ed2771a99cd3e98"; + sha256 = "0cvs6c903bq4jk4l197vvdrk8q85rl7z7iy7cvd5m4k7yd937r50"; + }; + meta.homepage = "https://github.com/fhill2/floating.nvim/"; + }; + floobits-neovim = buildVimPluginFrom2Nix { pname = "floobits-neovim"; version = "2018-08-01"; diff --git a/pkgs/misc/vim-plugins/vim-plugin-names b/pkgs/misc/vim-plugins/vim-plugin-names index 292f30997da..fec94771389 100644 --- a/pkgs/misc/vim-plugins/vim-plugin-names +++ b/pkgs/misc/vim-plugins/vim-plugin-names @@ -131,6 +131,7 @@ fatih/vim-go fcpg/vim-osc52 FelikZ/ctrlp-py-matcher fenetikm/falcon +fhill2/floating.nvim fiatjaf/neuron.vim fisadev/vim-isort flazz/vim-colorschemes From 7cda01fcb817f58af5022cf8804c57018646136f Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Tue, 11 May 2021 09:37:03 +0800 Subject: [PATCH 159/163] vimPlugins.fwatch-nvim: init at 2021-04-26 --- pkgs/misc/vim-plugins/generated.nix | 12 ++++++++++++ pkgs/misc/vim-plugins/vim-plugin-names | 1 + 2 files changed, 13 insertions(+) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index f7890b076ca..349cc7c42b6 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -1545,6 +1545,18 @@ let meta.homepage = "https://github.com/shumphrey/fugitive-gitlab.vim/"; }; + fwatch-nvim = buildVimPluginFrom2Nix { + pname = "fwatch-nvim"; + version = "2021-04-26"; + src = fetchFromGitHub { + owner = "rktjmp"; + repo = "fwatch.nvim"; + rev = "5fd6bff00d7fa432cdc847819563dad90bcf649d"; + sha256 = "1jc3kv0w3767593p9capif3p0msf8ac5xal170757ghfiy2jhsp9"; + }; + meta.homepage = "https://github.com/rktjmp/fwatch.nvim/"; + }; + fzf-lsp-nvim = buildVimPluginFrom2Nix { pname = "fzf-lsp-nvim"; version = "2021-02-04"; diff --git a/pkgs/misc/vim-plugins/vim-plugin-names b/pkgs/misc/vim-plugins/vim-plugin-names index fec94771389..58a8bb61890 100644 --- a/pkgs/misc/vim-plugins/vim-plugin-names +++ b/pkgs/misc/vim-plugins/vim-plugin-names @@ -531,6 +531,7 @@ rhysd/vim-grammarous rhysd/vim-operator-surround RishabhRD/nvim-lsputils RishabhRD/popfix +rktjmp/fwatch.nvim@main rktjmp/lush.nvim@main rmagatti/auto-session@main rodjek/vim-puppet From ee4520e789864f3441f3ec488e16d9f548b22ca5 Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Tue, 11 May 2021 09:41:59 +0800 Subject: [PATCH 160/163] vimPlugins.aurora: init at 2021-05-10 --- pkgs/misc/vim-plugins/generated.nix | 12 ++++++++++++ pkgs/misc/vim-plugins/vim-plugin-names | 1 + 2 files changed, 13 insertions(+) diff --git a/pkgs/misc/vim-plugins/generated.nix b/pkgs/misc/vim-plugins/generated.nix index 349cc7c42b6..459f768a379 100644 --- a/pkgs/misc/vim-plugins/generated.nix +++ b/pkgs/misc/vim-plugins/generated.nix @@ -183,6 +183,18 @@ let meta.homepage = "https://github.com/vmchale/ats-vim/"; }; + aurora = buildVimPluginFrom2Nix { + pname = "aurora"; + version = "2021-05-10"; + src = fetchFromGitHub { + owner = "ray-x"; + repo = "aurora"; + rev = "bf185b9c5aaaad7cfd20f29f92d3b77164f8f1e7"; + sha256 = "17ir0daw3rsfgprgvrskip2r19g15z05spdk14dz105nrgv4hh4y"; + }; + meta.homepage = "https://github.com/ray-x/aurora/"; + }; + auto-git-diff = buildVimPluginFrom2Nix { pname = "auto-git-diff"; version = "2019-09-23"; diff --git a/pkgs/misc/vim-plugins/vim-plugin-names b/pkgs/misc/vim-plugins/vim-plugin-names index 58a8bb61890..8dd07b20256 100644 --- a/pkgs/misc/vim-plugins/vim-plugin-names +++ b/pkgs/misc/vim-plugins/vim-plugin-names @@ -521,6 +521,7 @@ raghur/fruzzy raghur/vim-ghost Raimondi/delimitMate rakr/vim-one +ray-x/aurora rbgrouleff/bclose.vim rbong/vim-flog rhysd/committia.vim From e97d557475a2f7a8da811256b7df769514560d1f Mon Sep 17 00:00:00 2001 From: fortuneteller2k Date: Tue, 11 May 2021 11:35:33 +0800 Subject: [PATCH 161/163] zfsUnstable: 2.1.0-rc4 -> 2.1.0-rc5 --- pkgs/os-specific/linux/zfs/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/os-specific/linux/zfs/default.nix b/pkgs/os-specific/linux/zfs/default.nix index e10be635b1c..6db953ae4ef 100644 --- a/pkgs/os-specific/linux/zfs/default.nix +++ b/pkgs/os-specific/linux/zfs/default.nix @@ -203,12 +203,12 @@ in { zfsUnstable = common { # check the release notes for compatible kernels - kernelCompatible = kernel.kernelAtLeast "3.10" && kernel.kernelOlder "5.12"; + kernelCompatible = kernel.kernelAtLeast "3.10" && kernel.kernelOlder "5.13"; # this package should point to a version / git revision compatible with the latest kernel release - version = "2.1.0-rc4"; + version = "2.1.0-rc5"; - sha256 = "sha256-eakOEA7LCJOYDsZH24Y5JbEd2wh1KfCN+qX3QxQZ4e8="; + sha256 = "sha256-cj0P2bw6sTO+Y74pYn/WEpBuVGMMYCreJQjUdC3DMTE="; isUnstable = true; }; From 768075ffb90da1dc66e5e4603a77b76b5a67d343 Mon Sep 17 00:00:00 2001 From: "R. RyanTM" Date: Tue, 11 May 2021 04:13:56 +0000 Subject: [PATCH 162/163] golangci-lint: 1.39.0 -> 1.40.0 --- pkgs/development/tools/golangci-lint/default.nix | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pkgs/development/tools/golangci-lint/default.nix b/pkgs/development/tools/golangci-lint/default.nix index 83bc3f473d3..647e8b58490 100644 --- a/pkgs/development/tools/golangci-lint/default.nix +++ b/pkgs/development/tools/golangci-lint/default.nix @@ -2,16 +2,16 @@ buildGoModule rec { pname = "golangci-lint"; - version = "1.39.0"; + version = "1.40.0"; src = fetchFromGitHub { owner = "golangci"; repo = "golangci-lint"; rev = "v${version}"; - sha256 = "0c9yka27k4v1waijk7mn7k31l5a373sclykypflchy7xnlrsa18v"; + sha256 = "sha256-/AKDwX4W9MCPXNy2izSGTugLV8DVX4A2djZla8bqDCs="; }; - vendorSha256 = "1685iv1lsal462c8xqvs76x9dwvbwazrak902j0p12s0fyb66lpl"; + vendorSha256 = "sha256-HkVt0Nkq7+gvn5VNeROAmuhlCFGYx2niWb1NwJfLtRc="; doCheck = false; From f93d83d21b6a2d485006c4832f4850545ab7824e Mon Sep 17 00:00:00 2001 From: sterni <0rpkxez4ksa01gb3typccl0i@systemli.org> Date: Tue, 11 May 2021 06:54:15 +0200 Subject: [PATCH 163/163] ocamlPackages: cohttp: 2.5.0 -> 4.0.0; conduit: 2.2.2 -> 4.0.0 (#118144) * ocamlPackages.x509: 0.12.0 -> 0.13.0 https://github.com/mirleft/ocaml-x509/releases/tag/v0.13.0 * ocamlPackages.tls{,-mirage}: 0.12.8 -> 0.13.1 https://github.com/mirleft/ocaml-tls/releases/tag/v0.13.0 https://github.com/mirleft/ocaml-tls/releases/tag/v0.13.1 * ocamlPackages.ca-certs: 0.2.0 -> 0.2.1 Adds support for NIX_SSL_CERT_FILE, so we can finally run its test suite! https://github.com/mirage/ca-certs/releases/tag/v0.2.1 * ocamlPackages.dns*: 4.6.3 -> 5.0.0 * jackline: unstable-2020-09-03 -> unstable-2021-04-23 Compatibility with tls >= 0.13.0 * ocamlPackages.ca-certs-nss: init at 3.64.0.1 * ocamlPackages.conduit: 2.2.2 -> 2.3.0 https://github.com/mirage/ocaml-conduit/releases/tag/v2.3.0 * ocamlPackages.curly: fix tests with new ca-certs behavior * ocamlPackages.cohttp: 2.5.0 -> 4.0.0 ocamlPackages.cohttp-lwt-unix: add description https://github.com/mirage/ocaml-cohttp/releases/tag/v4.0.0 * ocamlPackages.mirage{,-runtime,-types*}: 3.10.1 -> 3.10.3 Adjust to a few changed dependencies: https://github.com/mirage/mirage/releases/tag/v3.10.2 https://github.com/mirage/mirage/releases/tag/v3.10.3 * ocamlPackages.conduit*: 2.3.0 -> 4.0.0 https://github.com/mirage/ocaml-conduit/releases/tag/v4.0.0 * ocamlPackages.cohttp-lwt-unix: disable tests * ocamlPackages.dns*: 5.0.0 -> 5.0.1 https://github.com/mirage/ocaml-dns/releases/tag/v5.0.1 * ocamlPackages.awa*: 0.0.1 -> 0.0.3 https://github.com/mirage/awa-ssh/releases/tag/v0.0.2 https://github.com/mirage/awa-ssh/releases/tag/v0.0.3 * ocamlPackages.optint: 0.0.4 -> 0.1.0 https://github.com/mirage/optint/releases/tag/v0.0.5 https://github.com/mirage/optint/releases/tag/v0.1.0 * ocamlPackages.decompress: 1.3.0 -> 1.4.0 https://github.com/mirage/decompress/releases/tag/v1.4.0 * ocamlPackages.checkseum: 0.2.1 -> 0.3.1 https://github.com/mirage/checkseum/releases/tag/v0.3.0 https://github.com/mirage/checkseum/releases/tag/v0.3.1 * ocamlPackages.checkseum: allow compilation with ocaml-freestanding * ocamlPackages.carton: 0.4.0 -> 0.4.1 https://github.com/mirage/ocaml-git/releases/tag/carton-v0.4.1 * ocamlPackages.mimic: 0.0.2 -> 0.0.3 * Upstream changed. * https://github.com/dinosaure/mimic/releases/tag/0.0.3 * ocamlPackages.letsencrypt: 0.2.4 -> 0.2.5 * ocamlPackages.paf: 0.0.1 -> 0.0.3 * ocamlPackages.git-cohttp-mirage: remove at 3.3.3 Will be replaced by git-paf 3.4.0. * ocamlPackages.git*: 3.3.3 -> 3.4.0 ocamlPackages.git-paf: init at 3.4.0 https://github.com/mirage/ocaml-git/releases/tag/3.4.0 * ocamlPackages.irmin*: 2.5.3 -> 2.6.0 https://github.com/mirage/irmin/releases/tag/2.6.0 --- .../instant-messengers/jackline/default.nix | 6 +- .../development/ocaml-modules/awa/default.nix | 4 +- .../ocaml-modules/ca-certs-nss/default.nix | 55 ++++++++++++++ .../ocaml-modules/ca-certs/default.nix | 12 ++-- .../ocaml-modules/carton/default.nix | 6 +- .../ocaml-modules/checkseum/default.nix | 39 +++++++--- .../checkseum/makefile-no-opam.patch | 12 ++++ .../ocaml-modules/cohttp/async.nix | 72 ++++++++++++++----- .../ocaml-modules/cohttp/default.nix | 13 ++-- .../ocaml-modules/cohttp/lwt-unix.nix | 25 ++++--- pkgs/development/ocaml-modules/cohttp/lwt.nix | 25 ++++--- .../ocaml-modules/cohttp/mirage.nix | 3 + .../ocaml-modules/conduit/async.nix | 18 ++--- .../ocaml-modules/conduit/default.nix | 10 +-- .../ocaml-modules/conduit/lwt-unix.nix | 27 +++++-- .../ocaml-modules/conduit/mirage.nix | 7 +- .../ocaml-modules/curly/default.nix | 6 +- .../ocaml-modules/decompress/default.nix | 4 +- .../development/ocaml-modules/dns/certify.nix | 4 +- .../development/ocaml-modules/dns/default.nix | 4 +- .../ocaml-modules/git/cohttp-mirage.nix | 18 ----- .../development/ocaml-modules/git/default.nix | 13 ++-- pkgs/development/ocaml-modules/git/paf.nix | 49 +++++++++++++ pkgs/development/ocaml-modules/git/unix.nix | 11 ++- .../ocaml-modules/irmin/containers.nix | 4 +- pkgs/development/ocaml-modules/irmin/git.nix | 4 +- .../ocaml-modules/irmin/graphql.nix | 3 +- pkgs/development/ocaml-modules/irmin/http.nix | 5 +- .../ocaml-modules/irmin/mirage-git.nix | 4 +- pkgs/development/ocaml-modules/irmin/ppx.nix | 4 +- pkgs/development/ocaml-modules/irmin/unix.nix | 6 +- .../ocaml-modules/letsencrypt/default.nix | 4 +- .../ocaml-modules/mimic/default.nix | 14 ++-- .../ocaml-modules/mirage/runtime.nix | 4 +- .../ocaml-modules/optint/default.nix | 6 +- .../development/ocaml-modules/paf/default.nix | 6 +- .../development/ocaml-modules/tls/default.nix | 12 ++-- pkgs/development/ocaml-modules/tls/mirage.nix | 5 +- .../ocaml-modules/x509/default.nix | 4 +- pkgs/top-level/ocaml-packages.nix | 4 +- 40 files changed, 371 insertions(+), 161 deletions(-) create mode 100644 pkgs/development/ocaml-modules/ca-certs-nss/default.nix create mode 100644 pkgs/development/ocaml-modules/checkseum/makefile-no-opam.patch delete mode 100644 pkgs/development/ocaml-modules/git/cohttp-mirage.nix create mode 100644 pkgs/development/ocaml-modules/git/paf.nix diff --git a/pkgs/applications/networking/instant-messengers/jackline/default.nix b/pkgs/applications/networking/instant-messengers/jackline/default.nix index 4c067e384f9..89d4931a2fe 100644 --- a/pkgs/applications/networking/instant-messengers/jackline/default.nix +++ b/pkgs/applications/networking/instant-messengers/jackline/default.nix @@ -4,7 +4,7 @@ with ocamlPackages; buildDunePackage rec { pname = "jackline"; - version = "unstable-2020-09-03"; + version = "unstable-2021-04-23"; minimumOCamlVersion = "4.08"; @@ -13,8 +13,8 @@ buildDunePackage rec { src = fetchFromGitHub { owner = "hannesm"; repo = "jackline"; - rev = "dd5f19636c9b99b72c348f0f639452d87b7c017c"; - sha256 = "076smdgig4nwvqsqxa6gsl0c3daq5agwgzp4n2y8xxm3qiq91y89"; + rev = "861c59bb7cd27ad5c7558ff94cb0d0e8dca249e5"; + sha256 = "00waw5qr0n70i9l9b25r9ryfi836x4qrj046bb4k9qa4d0p8q1sa"; }; nativeBuildInpts = [ diff --git a/pkgs/development/ocaml-modules/awa/default.nix b/pkgs/development/ocaml-modules/awa/default.nix index 49d614cda88..14f99bb6f8d 100644 --- a/pkgs/development/ocaml-modules/awa/default.nix +++ b/pkgs/development/ocaml-modules/awa/default.nix @@ -8,14 +8,14 @@ buildDunePackage rec { pname = "awa"; - version = "0.0.1"; + version = "0.0.3"; minimumOCamlVersion = "4.07"; useDune2 = true; src = fetchurl { url = "https://github.com/mirage/awa-ssh/releases/download/v${version}/awa-v${version}.tbz"; - sha256 = "c1d604645517b191184a5800f5c48a6a9a3e5a2fce4a0e2ecfeee74586301400"; + sha256 = "5a7927363ffe672cccf12d5425386e84f6f553a17ffec2b01ae5dc28180c831a"; }; nativeBuildInputs = [ ppx_sexp_conv ppx_cstruct ]; diff --git a/pkgs/development/ocaml-modules/ca-certs-nss/default.nix b/pkgs/development/ocaml-modules/ca-certs-nss/default.nix new file mode 100644 index 00000000000..5e6691a9feb --- /dev/null +++ b/pkgs/development/ocaml-modules/ca-certs-nss/default.nix @@ -0,0 +1,55 @@ +{ lib +, buildDunePackage +, fetchurl +, rresult +, mirage-crypto +, mirage-clock +, x509 +, logs +, fmt +, hex +, bos +, astring +, cmdliner +, alcotest +}: + +buildDunePackage rec { + pname = "ca-certs-nss"; + version = "3.64.0.1"; + + minimumOCamlVersion = "4.07"; + + src = fetchurl { + url = "https://github.com/mirage/ca-certs-nss/releases/download/v${version}/ca-certs-nss-v${version}.tbz"; + sha256 = "909c64076491647471f785527bfdd9a886a34504edabf88542b43f27b86067f9"; + }; + + useDune2 = true; + + propagatedBuildInputs = [ + rresult + mirage-crypto + mirage-clock + x509 + ]; + + buildInputs = [ + logs + fmt + hex + bos + astring + cmdliner + ]; + + doCheck = true; + checkInputs = [ alcotest ]; + + meta = with lib; { + license = licenses.isc; + description = "X.509 trust anchors extracted from Mozilla's NSS"; + maintainers = [ maintainers.sternenseemann ]; + homepage = "https://github.com/mirage/ca-certs-nss"; + }; +} diff --git a/pkgs/development/ocaml-modules/ca-certs/default.nix b/pkgs/development/ocaml-modules/ca-certs/default.nix index dacc181f751..acf869dbd27 100644 --- a/pkgs/development/ocaml-modules/ca-certs/default.nix +++ b/pkgs/development/ocaml-modules/ca-certs/default.nix @@ -1,24 +1,28 @@ { lib, buildDunePackage, fetchurl , bos, fpath, rresult, ptime, mirage-crypto, x509, astring, logs +, cacert, alcotest }: buildDunePackage rec { pname = "ca-certs"; - version = "0.2.0"; + version = "0.2.1"; minimumOCamlVersion = "4.07"; src = fetchurl { url = "https://github.com/mirage/ca-certs/releases/download/v${version}/ca-certs-v${version}.tbz"; - sha256 = "15jfb5zvahs90jsfs7ridqihlka5198z2xrvplj8ddchxfmpx868"; + sha256 = "d43109496a5129feff967d557c556af96f8b10456896a405c43b7cf0c35d0af3"; }; useDune2 = true; propagatedBuildInputs = [ bos fpath rresult ptime mirage-crypto x509 astring logs ]; - # tests need access to network and systemwide ca cert chain - doCheck = false; + doCheck = true; + checkInputs = [ + cacert # for /etc/ssl/certs/ca-bundle.crt + alcotest + ]; meta = with lib; { description = "Detect root CA certificates from the operating system"; diff --git a/pkgs/development/ocaml-modules/carton/default.nix b/pkgs/development/ocaml-modules/carton/default.nix index 31b864e29d3..c10537d5d50 100644 --- a/pkgs/development/ocaml-modules/carton/default.nix +++ b/pkgs/development/ocaml-modules/carton/default.nix @@ -7,19 +7,19 @@ buildDunePackage rec { pname = "carton"; - version = "0.4.0"; + version = "0.4.1"; useDune2 = true; minimumOCamlVersion = "4.08"; src = fetchurl { url = "https://github.com/mirage/ocaml-git/releases/download/${pname}-v${version}/${pname}-${pname}-v${version}.tbz"; - sha256 = "777f9692b83cd63570c17527a32c5045818ab9242d923cbbde72fc23d0da0140"; + sha256 = "d16aad5560d9ab1e3b4d93d2e8fdea638c216ff47338fb630a8aefd22b452665"; }; # remove changelogs for mimic and the git* packages postPatch = '' - rm CHANGES.md CHANGES.mimic.md + rm CHANGES.md ''; buildInputs = [ diff --git a/pkgs/development/ocaml-modules/checkseum/default.nix b/pkgs/development/ocaml-modules/checkseum/default.nix index 81009981047..527afec33eb 100644 --- a/pkgs/development/ocaml-modules/checkseum/default.nix +++ b/pkgs/development/ocaml-modules/checkseum/default.nix @@ -1,23 +1,46 @@ -{ lib, fetchurl, buildDunePackage, dune-configurator +{ lib, fetchurl, buildDunePackage, dune-configurator, pkg-config , bigarray-compat, optint -, fmt, rresult -, alcotest +, fmt, rresult, bos, fpath, astring, alcotest +, withFreestanding ? false +, ocaml-freestanding }: buildDunePackage rec { - version = "0.2.1"; + version = "0.3.1"; pname = "checkseum"; useDune2 = true; + minimumOCamlVersion = "4.07"; + src = fetchurl { url = "https://github.com/mirage/checkseum/releases/download/v${version}/checkseum-v${version}.tbz"; - sha256 = "1swb44c64pcs4dh9ka9lig6d398qwwkd3kkiajicww6qk7jbh3n5"; + sha256 = "b9e4d054e17618b1faed8c0eb15afe0614b2f093e58b59a180bda4500a5d2da1"; }; - buildInputs = [ dune-configurator fmt rresult ]; - propagatedBuildInputs = [ bigarray-compat optint ]; - checkInputs = lib.optionals doCheck [ alcotest ]; + patches = [ + ./makefile-no-opam.patch + ]; + + nativeBuildInputs = [ + dune-configurator + pkg-config + ]; + propagatedBuildInputs = [ + bigarray-compat + optint + ] ++ lib.optionals withFreestanding [ + ocaml-freestanding + ]; + + checkInputs = [ + alcotest + bos + astring + fmt + fpath + rresult + ]; doCheck = true; diff --git a/pkgs/development/ocaml-modules/checkseum/makefile-no-opam.patch b/pkgs/development/ocaml-modules/checkseum/makefile-no-opam.patch new file mode 100644 index 00000000000..49fb41b2e00 --- /dev/null +++ b/pkgs/development/ocaml-modules/checkseum/makefile-no-opam.patch @@ -0,0 +1,12 @@ +diff --git a/freestanding/Makefile b/freestanding/Makefile +index d535050..bb286bd 100644 +--- a/freestanding/Makefile ++++ b/freestanding/Makefile +@@ -1,4 +1,6 @@ +-PKG_CONFIG_PATH := $(shell opam config var prefix)/lib/pkgconfig ++ifneq (, $(shell command -v opam)) ++PKG_CONFIG_PATH ?= $(shell opam var prefix)/lib/pkgconfig ++endif + + EXISTS := $(shell PKG_CONFIG_PATH=$(PKG_CONFIG_PATH) pkg-config --exists ocaml-freestanding; echo $$?) + diff --git a/pkgs/development/ocaml-modules/cohttp/async.nix b/pkgs/development/ocaml-modules/cohttp/async.nix index 21e22533f1b..060d2c6fb6a 100644 --- a/pkgs/development/ocaml-modules/cohttp/async.nix +++ b/pkgs/development/ocaml-modules/cohttp/async.nix @@ -1,22 +1,60 @@ -{ lib, buildDunePackage, async, cohttp, conduit-async, uri, ppx_sexp_conv -, logs, magic-mime }: +{ lib +, buildDunePackage +, ppx_sexp_conv +, base +, async +, async_kernel +, async_unix +, cohttp +, conduit-async +, uri +, uri-sexp +, logs +, fmt +, sexplib0 +, ipaddr +, magic-mime +, ounit +, mirage-crypto +, core +}: -if !lib.versionAtLeast cohttp.version "0.99" then - cohttp -else if !lib.versionAtLeast async.version "0.13" then - throw "cohttp-async needs async-0.13 (hence OCaml >= 4.08)" -else +buildDunePackage { + pname = "cohttp-async"; - buildDunePackage { - pname = "cohttp-async"; - useDune2 = true; - inherit (cohttp) version src; + inherit (cohttp) + version + src + minimumOCamlVersion + useDune2 + ; - buildInputs = [ ppx_sexp_conv ]; + buildInputs = [ ppx_sexp_conv ]; - propagatedBuildInputs = [ async cohttp conduit-async logs magic-mime uri ]; + propagatedBuildInputs = [ + cohttp + conduit-async + async_kernel + async_unix + async + base + magic-mime + logs + fmt + sexplib0 + uri + uri-sexp + ipaddr + ]; - meta = cohttp.meta // { - description = "CoHTTP implementation for the Async concurrency library"; - }; - } + doCheck = true; + checkInputs = [ + ounit + mirage-crypto + core + ]; + + meta = cohttp.meta // { + description = "CoHTTP implementation for the Async concurrency library"; + }; +} diff --git a/pkgs/development/ocaml-modules/cohttp/default.nix b/pkgs/development/ocaml-modules/cohttp/default.nix index 1cbc43bc280..c1dc973d0ee 100644 --- a/pkgs/development/ocaml-modules/cohttp/default.nix +++ b/pkgs/development/ocaml-modules/cohttp/default.nix @@ -1,25 +1,24 @@ { lib, fetchurl, buildDunePackage -, ppx_fields_conv, ppx_sexp_conv, stdlib-shims -, base64, fieldslib, jsonm, re, stringext, uri-sexp +, ppx_sexp_conv, base64, jsonm, re, stringext, uri-sexp , ocaml, fmt, alcotest }: buildDunePackage rec { pname = "cohttp"; - version = "2.5.5"; + version = "4.0.0"; useDune2 = true; - minimumOCamlVersion = "4.04.1"; + minimumOCamlVersion = "4.08"; src = fetchurl { url = "https://github.com/mirage/ocaml-cohttp/releases/download/v${version}/cohttp-v${version}.tbz"; - sha256 = "0ywmql4lp6ps2gd064ixbjzsdnnn5vk3pipm005sswl553qqwaim"; + sha256 = "bd7aa4cd2c82744990ed7c49e3ee7a40324c64cb3d8509804809155e2bacd1d2"; }; - buildInputs = [ jsonm ppx_fields_conv ppx_sexp_conv ]; + buildInputs = [ jsonm ppx_sexp_conv ]; - propagatedBuildInputs = [ base64 fieldslib re stringext uri-sexp stdlib-shims ]; + propagatedBuildInputs = [ base64 re stringext uri-sexp ]; doCheck = lib.versionAtLeast ocaml.version "4.05"; checkInputs = [ fmt alcotest ]; diff --git a/pkgs/development/ocaml-modules/cohttp/lwt-unix.nix b/pkgs/development/ocaml-modules/cohttp/lwt-unix.nix index 845df2a3f54..57885b0e65e 100644 --- a/pkgs/development/ocaml-modules/cohttp/lwt-unix.nix +++ b/pkgs/development/ocaml-modules/cohttp/lwt-unix.nix @@ -1,19 +1,28 @@ { lib, buildDunePackage, cohttp-lwt -, conduit-lwt-unix, ppx_sexp_conv -, cmdliner, fmt, magic-mime +, conduit-lwt-unix, conduit-lwt, ppx_sexp_conv +, cmdliner, fmt, logs, magic-mime +, ounit +, cacert }: -if !lib.versionAtLeast cohttp-lwt.version "0.99" -then cohttp-lwt -else - buildDunePackage { pname = "cohttp-lwt-unix"; - inherit (cohttp-lwt) version src meta; + inherit (cohttp-lwt) version src; useDune2 = true; buildInputs = [ cmdliner ppx_sexp_conv ]; - propagatedBuildInputs = [ cohttp-lwt conduit-lwt-unix fmt magic-mime ]; + propagatedBuildInputs = [ + cohttp-lwt conduit-lwt conduit-lwt-unix fmt logs magic-mime + ]; + + # TODO(@sternenseemann): fail for unknown reason + # https://github.com/mirage/ocaml-cohttp/issues/675#issuecomment-830692742 + doCheck = false; + checkInputs = [ ounit cacert ]; + + meta = cohttp-lwt.meta // { + description = "CoHTTP implementation for Unix and Windows using Lwt"; + }; } diff --git a/pkgs/development/ocaml-modules/cohttp/lwt.nix b/pkgs/development/ocaml-modules/cohttp/lwt.nix index 36831d94613..158aa3b27b2 100644 --- a/pkgs/development/ocaml-modules/cohttp/lwt.nix +++ b/pkgs/development/ocaml-modules/cohttp/lwt.nix @@ -1,16 +1,21 @@ -{ lib, buildDunePackage, cohttp, ocaml_lwt, uri, ppx_sexp_conv, logs }: - -if !lib.versionAtLeast cohttp.version "0.99" -then cohttp -else if !lib.versionAtLeast ppx_sexp_conv.version "0.13" -then throw "cohttp-lwt is not available for ppx_sexp_conv version ${ppx_sexp_conv.version}" -else +{ lib, buildDunePackage, cohttp, ocaml_lwt, uri, ppx_sexp_conv, logs, sexplib0 }: buildDunePackage { pname = "cohttp-lwt"; - inherit (cohttp) version src useDune2 meta; + inherit (cohttp) + version + src + useDune2 + minimumOCamlVersion + ; - buildInputs = [ uri ppx_sexp_conv ]; + buildInputs = [ ppx_sexp_conv ]; - propagatedBuildInputs = [ cohttp ocaml_lwt logs ]; + propagatedBuildInputs = [ + cohttp ocaml_lwt logs sexplib0 uri + ]; + + meta = cohttp.meta // { + description = "CoHTTP implementation using the Lwt concurrency library"; + }; } diff --git a/pkgs/development/ocaml-modules/cohttp/mirage.nix b/pkgs/development/ocaml-modules/cohttp/mirage.nix index e7b172349cb..d2d3e945645 100644 --- a/pkgs/development/ocaml-modules/cohttp/mirage.nix +++ b/pkgs/development/ocaml-modules/cohttp/mirage.nix @@ -2,6 +2,7 @@ , mirage-flow, mirage-channel, mirage-kv , conduit, conduit-mirage, lwt , astring, magic-mime +, ppx_sexp_conv }: buildDunePackage { @@ -9,6 +10,8 @@ buildDunePackage { inherit (cohttp) version src minimumOCamlVersion useDune2; + nativeBuildInputs = [ ppx_sexp_conv ]; + propagatedBuildInputs = [ mirage-flow mirage-channel conduit conduit-mirage mirage-kv lwt cohttp cohttp-lwt astring magic-mime diff --git a/pkgs/development/ocaml-modules/conduit/async.nix b/pkgs/development/ocaml-modules/conduit/async.nix index c15ad0520fb..e78cb2bc516 100644 --- a/pkgs/development/ocaml-modules/conduit/async.nix +++ b/pkgs/development/ocaml-modules/conduit/async.nix @@ -1,17 +1,17 @@ -{ lib, buildDunePackage, async, async_ssl, ppx_sexp_conv, conduit }: - -if !lib.versionAtLeast conduit.version "1.0" -then conduit -else +{ lib, buildDunePackage, async, async_ssl, ppx_sexp_conv, ppx_here, uri, conduit }: buildDunePackage { pname = "conduit-async"; - useDune2 = true; - inherit (conduit) version src; + inherit (conduit) + version + src + minimumOCamlVersion + useDune2 + ; - buildInputs = [ ppx_sexp_conv ]; + buildInputs = [ ppx_sexp_conv ppx_here ]; - propagatedBuildInputs = [ async async_ssl conduit ]; + propagatedBuildInputs = [ async async_ssl conduit uri ]; meta = conduit.meta // { description = "A network connection establishment library for Async"; diff --git a/pkgs/development/ocaml-modules/conduit/default.nix b/pkgs/development/ocaml-modules/conduit/default.nix index 8c9b757f87c..96f5bf43d21 100644 --- a/pkgs/development/ocaml-modules/conduit/default.nix +++ b/pkgs/development/ocaml-modules/conduit/default.nix @@ -5,18 +5,18 @@ buildDunePackage rec { pname = "conduit"; - version = "2.2.2"; + version = "4.0.0"; useDune2 = true; - minimumOCamlVersion = "4.07"; + minimumOCamlVersion = "4.03"; src = fetchurl { - url = "https://github.com/mirage/ocaml-conduit/releases/download/v2.2.2/conduit-v2.2.2.tbz"; - sha256 = "1zb83w2pq9c8xrappfxa6y5q93772f5dj22x78camsm77a2c2z55"; + url = "https://github.com/mirage/ocaml-conduit/releases/download/v${version}/conduit-v${version}.tbz"; + sha256 = "74b29d72bf47adc5d5c4cae6130ad5a2a4923118b9c571331bd1cb3c56decd2a"; }; buildInputs = [ ppx_sexp_conv ]; - propagatedBuildInputs = [ astring ipaddr ipaddr-sexp sexplib uri ]; + propagatedBuildInputs = [ astring ipaddr ipaddr-sexp sexplib uri logs ]; meta = { description = "A network connection establishment library"; diff --git a/pkgs/development/ocaml-modules/conduit/lwt-unix.nix b/pkgs/development/ocaml-modules/conduit/lwt-unix.nix index ab6449b50a1..ce6016012d7 100644 --- a/pkgs/development/ocaml-modules/conduit/lwt-unix.nix +++ b/pkgs/development/ocaml-modules/conduit/lwt-unix.nix @@ -1,18 +1,31 @@ { buildDunePackage -, conduit-lwt, ppx_sexp_conv, ocaml_lwt, uri, ipaddr, ipaddr-sexp -, lwt_ssl, tls +, conduit-lwt, ppx_sexp_conv, ocaml_lwt, uri, ipaddr, ipaddr-sexp, ca-certs, logs +, lwt_ssl, tls, lwt_log, ssl }: buildDunePackage { pname = "conduit-lwt-unix"; - inherit (conduit-lwt) version src minimumOCamlVersion; - - useDune2 = true; + inherit (conduit-lwt) version src minimumOCamlVersion useDune2; buildInputs = [ ppx_sexp_conv ]; - propagatedBuildInputs = - [ conduit-lwt ocaml_lwt uri ipaddr ipaddr-sexp tls lwt_ssl ]; + propagatedBuildInputs = [ + conduit-lwt + ocaml_lwt + uri + ipaddr + ipaddr-sexp + tls + ca-certs + logs + lwt_ssl + ]; + + doCheck = true; + checkInputs = [ + lwt_log + ssl + ]; meta = conduit-lwt.meta // { description = "A network connection establishment library for Lwt_unix"; diff --git a/pkgs/development/ocaml-modules/conduit/mirage.nix b/pkgs/development/ocaml-modules/conduit/mirage.nix index 6100908f785..d1f636be93c 100644 --- a/pkgs/development/ocaml-modules/conduit/mirage.nix +++ b/pkgs/development/ocaml-modules/conduit/mirage.nix @@ -1,7 +1,8 @@ { buildDunePackage, conduit-lwt -, ppx_sexp_conv, sexplib, cstruct, mirage-stack, mirage-flow +, ppx_sexp_conv, sexplib, uri, cstruct, mirage-stack, mirage-flow , mirage-flow-combinators, mirage-random, mirage-time, mirage-clock , dns-client, vchan, xenstore, tls, tls-mirage, ipaddr, ipaddr-sexp +, tcpip, ca-certs-nss }: buildDunePackage { @@ -12,10 +13,10 @@ buildDunePackage { nativeBuildInputs = [ ppx_sexp_conv ]; propagatedBuildInputs = [ - sexplib cstruct mirage-stack mirage-clock mirage-flow + sexplib uri cstruct mirage-stack mirage-clock mirage-flow mirage-flow-combinators mirage-random mirage-time dns-client conduit-lwt vchan xenstore tls tls-mirage - ipaddr ipaddr-sexp + ipaddr ipaddr-sexp tcpip ca-certs-nss ]; meta = conduit-lwt.meta // { diff --git a/pkgs/development/ocaml-modules/curly/default.nix b/pkgs/development/ocaml-modules/curly/default.nix index 1c48b509c41..20197e207af 100644 --- a/pkgs/development/ocaml-modules/curly/default.nix +++ b/pkgs/development/ocaml-modules/curly/default.nix @@ -1,5 +1,6 @@ { stdenv, lib, buildDunePackage, fetchurl, ocaml -, result, alcotest, cohttp-lwt-unix, odoc, curl }: +, result, alcotest, cohttp-lwt-unix, odoc, curl, cacert +}: buildDunePackage rec { pname = "curly"; @@ -15,8 +16,9 @@ buildDunePackage rec { }; propagatedBuildInputs = [ result ]; - checkInputs = [ alcotest cohttp-lwt-unix ]; + checkInputs = [ alcotest cohttp-lwt-unix cacert ]; # test dependencies are only available for >= 4.08 + # https://github.com/mirage/ca-certs/issues/16 doCheck = lib.versionAtLeast ocaml.version "4.08" # Some test fails in macOS sandbox # > Fatal error: exception Unix.Unix_error(Unix.EPERM, "bind", "") diff --git a/pkgs/development/ocaml-modules/decompress/default.nix b/pkgs/development/ocaml-modules/decompress/default.nix index d2cba68d732..505ffe3c425 100644 --- a/pkgs/development/ocaml-modules/decompress/default.nix +++ b/pkgs/development/ocaml-modules/decompress/default.nix @@ -4,7 +4,7 @@ }: buildDunePackage rec { - version = "1.3.0"; + version = "1.4.0"; pname = "decompress"; minimumOCamlVersion = "4.07"; @@ -13,7 +13,7 @@ buildDunePackage rec { src = fetchurl { url = "https://github.com/mirage/decompress/releases/download/v${version}/decompress-v${version}.tbz"; - sha256 = "de149896939be13fedec46a4581121d5ab74850a2241d08e6aa8ae4bb18c52c4"; + sha256 = "d1669e07446d73dd5e16f020d4a1682abcbb1b7a1e3bf19b805429636c26a19b"; }; buildInputs = [ cmdliner ]; diff --git a/pkgs/development/ocaml-modules/dns/certify.nix b/pkgs/development/ocaml-modules/dns/certify.nix index 1835114d707..31b39d18225 100644 --- a/pkgs/development/ocaml-modules/dns/certify.nix +++ b/pkgs/development/ocaml-modules/dns/certify.nix @@ -1,6 +1,6 @@ { buildDunePackage, dns, dns-tsig, dns-mirage, randomconv, x509 , mirage-random, mirage-time, mirage-clock, mirage-stack -, logs, mirage-crypto-pk, mirage-crypto-rng, tls, lwt +, logs, mirage-crypto-pk, mirage-crypto-rng, mirage-crypto-ec, lwt }: buildDunePackage { @@ -21,7 +21,7 @@ buildDunePackage { logs mirage-crypto-pk mirage-crypto-rng - tls + mirage-crypto-ec lwt ]; diff --git a/pkgs/development/ocaml-modules/dns/default.nix b/pkgs/development/ocaml-modules/dns/default.nix index 4f0b95da6cb..8a5115f10f0 100644 --- a/pkgs/development/ocaml-modules/dns/default.nix +++ b/pkgs/development/ocaml-modules/dns/default.nix @@ -4,14 +4,14 @@ buildDunePackage rec { pname = "dns"; - version = "4.6.3"; + version = "5.0.1"; useDune2 = true; minimumOCamlVersion = "4.07"; src = fetchurl { url = "https://github.com/mirage/ocaml-dns/releases/download/v${version}/dns-v${version}.tbz"; - sha256 = "0g7xw43jm5hv0w9lsnhhi0w3243mxl615cdsvz29yh39fcqvqsdy"; + sha256 = "72c0a1a91c8e409bd448c8e0ea28d16d13177c326aea403ee1c30ddcb5969adc"; }; propagatedBuildInputs = [ rresult astring fmt logs ptime domain-name gmap cstruct ipaddr lru duration metrics ]; diff --git a/pkgs/development/ocaml-modules/git/cohttp-mirage.nix b/pkgs/development/ocaml-modules/git/cohttp-mirage.nix deleted file mode 100644 index d3088400641..00000000000 --- a/pkgs/development/ocaml-modules/git/cohttp-mirage.nix +++ /dev/null @@ -1,18 +0,0 @@ -{ lib, buildDunePackage -, git, mimic, cohttp-mirage, cohttp, cohttp-lwt -, fmt, lwt, result, rresult, uri -}: - -buildDunePackage { - pname = "git-cohttp-mirage"; - - inherit (git) version src minimumOCamlVersion useDune2; - - propagatedBuildInputs = [ - git mimic cohttp-mirage cohttp cohttp-lwt fmt lwt result rresult uri - ]; - - meta = git.meta // { - description = "A package to use HTTP-based ocaml-git with MirageOS backend"; - }; -} diff --git a/pkgs/development/ocaml-modules/git/default.nix b/pkgs/development/ocaml-modules/git/default.nix index b8d73178d09..954e4956c81 100644 --- a/pkgs/development/ocaml-modules/git/default.nix +++ b/pkgs/development/ocaml-modules/git/default.nix @@ -1,30 +1,35 @@ { stdenv, lib, fetchurl, buildDunePackage , alcotest, mtime, mirage-crypto-rng, tls, git-binary , angstrom, astring, cstruct, decompress, digestif, encore, duff, fmt, checkseum -, fpath, ke, logs, lwt, ocamlgraph, uri, rresult, base64 +, fpath, ke, logs, lwt, ocamlgraph, uri, rresult, base64, hxd , result, bigstringaf, optint, mirage-flow, domain-name, emile , mimic, carton, carton-lwt, carton-git, ipaddr, psq, crowbar, alcotest-lwt }: buildDunePackage rec { pname = "git"; - version = "3.3.3"; + version = "3.4.0"; minimumOCamlVersion = "4.08"; useDune2 = true; src = fetchurl { url = "https://github.com/mirage/ocaml-git/releases/download/${version}/git-${version}.tbz"; - sha256 = "0j8pw9w74bfhrjsqr8zm8g7h1az94z9vg7qgc6z6649zm9yjiax3"; + sha256 = "6eef1240c7c85a8e495b82ef863c509ad41d75e0c45cf73c34ed1bdafd03413f"; }; + # remove changelog for the carton package + postPatch = '' + rm CHANGES.carton.md + ''; + buildInputs = [ base64 ]; propagatedBuildInputs = [ angstrom astring checkseum cstruct decompress digestif encore duff fmt fpath ke logs lwt ocamlgraph uri rresult result bigstringaf optint mirage-flow - domain-name emile mimic carton carton-lwt carton-git ipaddr psq + domain-name emile mimic carton carton-lwt carton-git ipaddr psq hxd ]; checkInputs = [ alcotest alcotest-lwt mtime mirage-crypto-rng tls git-binary crowbar diff --git a/pkgs/development/ocaml-modules/git/paf.nix b/pkgs/development/ocaml-modules/git/paf.nix new file mode 100644 index 00000000000..cf0272ddf3b --- /dev/null +++ b/pkgs/development/ocaml-modules/git/paf.nix @@ -0,0 +1,49 @@ +{ lib, buildDunePackage +, git +, mimic +, paf +, ca-certs-nss +, cohttp +, cohttp-lwt +, fmt +, ipaddr +, logs +, lwt +, mirage-clock +, mirage-stack +, mirage-time +, result +, rresult +, tls +, uri +}: + +buildDunePackage { + pname = "git-paf"; + + inherit (git) version src minimumOCamlVersion useDune2; + + propagatedBuildInputs = [ + git + mimic + paf + ca-certs-nss + cohttp + cohttp-lwt + fmt + lwt + result + rresult + ipaddr + logs + mirage-clock + mirage-stack + mirage-time + tls + uri + ]; + + meta = git.meta // { + description = "A package to use HTTP-based ocaml-git with MirageOS backend"; + }; +} diff --git a/pkgs/development/ocaml-modules/git/unix.nix b/pkgs/development/ocaml-modules/git/unix.nix index f4cea472886..3e5f464cea0 100644 --- a/pkgs/development/ocaml-modules/git/unix.nix +++ b/pkgs/development/ocaml-modules/git/unix.nix @@ -6,7 +6,8 @@ , tcpip, awa-mirage, mirage-flow , alcotest, alcotest-lwt, base64, cstruct , ke, mirage-crypto-rng, ocurl, git-binary -, ptime +, ptime, mimic, ca-certs-nss, tls, tls-mirage +, cacert }: buildDunePackage { @@ -24,10 +25,14 @@ buildDunePackage { fmt bos fpath uri digestif logs lwt astring cohttp-lwt-unix decompress domain-name ipaddr mtime mirage-flow + cstruct ptime mimic ca-certs-nss + tls tls-mirage ]; checkInputs = [ - alcotest alcotest-lwt base64 cstruct ke - mirage-crypto-rng ocurl git-binary ptime + alcotest alcotest-lwt base64 ke + mirage-crypto-rng git-binary + cohttp-lwt-unix + cacert # sets up NIX_SSL_CERT_FILE ]; doCheck = true; diff --git a/pkgs/development/ocaml-modules/irmin/containers.nix b/pkgs/development/ocaml-modules/irmin/containers.nix index 761e9bf5619..76383099a41 100644 --- a/pkgs/development/ocaml-modules/irmin/containers.nix +++ b/pkgs/development/ocaml-modules/irmin/containers.nix @@ -1,6 +1,6 @@ { buildDunePackage , irmin, irmin-unix, irmin-git, ppx_irmin, lwt, mtime -, alcotest, alcotest-lwt +, alcotest, alcotest-lwt, cacert }: buildDunePackage { @@ -18,7 +18,7 @@ buildDunePackage { doCheck = true; checkInputs = [ - alcotest alcotest-lwt + alcotest alcotest-lwt cacert ]; meta = ppx_irmin.meta // { diff --git a/pkgs/development/ocaml-modules/irmin/git.nix b/pkgs/development/ocaml-modules/irmin/git.nix index a6c1e8af8fa..d477c932928 100644 --- a/pkgs/development/ocaml-modules/irmin/git.nix +++ b/pkgs/development/ocaml-modules/irmin/git.nix @@ -1,7 +1,7 @@ { lib, buildDunePackage , git, irmin, irmin-test, ppx_irmin, git-cohttp-unix, git-unix , digestif, cstruct, fmt, astring, fpath, logs, lwt, uri -, mtime, alcotest +, mtime, alcotest, cacert }: buildDunePackage { @@ -26,7 +26,7 @@ buildDunePackage { uri ]; - checkInputs = [ mtime alcotest git-cohttp-unix git-unix irmin-test ]; + checkInputs = [ mtime alcotest git-cohttp-unix git-unix irmin-test cacert ]; doCheck = true; diff --git a/pkgs/development/ocaml-modules/irmin/graphql.nix b/pkgs/development/ocaml-modules/irmin/graphql.nix index ca205cac4e1..03c8f1eca29 100644 --- a/pkgs/development/ocaml-modules/irmin/graphql.nix +++ b/pkgs/development/ocaml-modules/irmin/graphql.nix @@ -1,5 +1,5 @@ { lib, buildDunePackage, cohttp-lwt, graphql-cohttp, graphql-lwt, irmin -, alcotest, alcotest-lwt, logs, yojson, cohttp-lwt-unix +, alcotest, alcotest-lwt, logs, yojson, cohttp-lwt-unix, cacert }: buildDunePackage rec { @@ -19,6 +19,7 @@ buildDunePackage rec { logs cohttp-lwt-unix yojson + cacert ]; meta = irmin.meta // { diff --git a/pkgs/development/ocaml-modules/irmin/http.nix b/pkgs/development/ocaml-modules/irmin/http.nix index b50e0b87345..7bfae998202 100644 --- a/pkgs/development/ocaml-modules/irmin/http.nix +++ b/pkgs/development/ocaml-modules/irmin/http.nix @@ -1,5 +1,6 @@ { lib, buildDunePackage, cohttp-lwt, irmin, webmachine , checkseum, git-unix, irmin-git, irmin-test, digestif, git-cohttp-unix +, cacert }: buildDunePackage rec { @@ -12,7 +13,9 @@ buildDunePackage rec { propagatedBuildInputs = [ cohttp-lwt irmin webmachine ]; - checkInputs = [ digestif checkseum git-cohttp-unix git-unix irmin-git irmin-test ]; + checkInputs = [ + digestif checkseum git-cohttp-unix git-unix irmin-git irmin-test cacert + ]; doCheck = true; diff --git a/pkgs/development/ocaml-modules/irmin/mirage-git.nix b/pkgs/development/ocaml-modules/irmin/mirage-git.nix index dfa84ff2335..e33b766bd4c 100644 --- a/pkgs/development/ocaml-modules/irmin/mirage-git.nix +++ b/pkgs/development/ocaml-modules/irmin/mirage-git.nix @@ -1,6 +1,6 @@ { buildDunePackage, irmin-mirage, irmin-git , mirage-kv, cohttp, conduit-lwt, conduit-mirage -, git-cohttp-mirage, fmt, git, lwt, mirage-clock, uri +, git-paf, fmt, git, lwt, mirage-clock, uri }: buildDunePackage { @@ -15,7 +15,7 @@ buildDunePackage { cohttp conduit-lwt conduit-mirage - git-cohttp-mirage + git-paf fmt git lwt diff --git a/pkgs/development/ocaml-modules/irmin/ppx.nix b/pkgs/development/ocaml-modules/irmin/ppx.nix index 7c59e1eaef3..c7eed70d9d9 100644 --- a/pkgs/development/ocaml-modules/irmin/ppx.nix +++ b/pkgs/development/ocaml-modules/irmin/ppx.nix @@ -2,11 +2,11 @@ buildDunePackage rec { pname = "ppx_irmin"; - version = "2.5.3"; + version = "2.6.0"; src = fetchurl { url = "https://github.com/mirage/irmin/releases/download/${version}/irmin-${version}.tbz"; - sha256 = "2c8ef24cc57379c3a138f121fea350ee7b6077abc22a4fdc6a47d0c81585f3f6"; + sha256 = "1db134221e82c424260a0e206b640fcb82902be35eea4137af2bcd9c98d3ac0f"; }; minimumOCamlVersion = "4.08"; diff --git a/pkgs/development/ocaml-modules/irmin/unix.nix b/pkgs/development/ocaml-modules/irmin/unix.nix index a3dfb5d508c..89cf36979bd 100644 --- a/pkgs/development/ocaml-modules/irmin/unix.nix +++ b/pkgs/development/ocaml-modules/irmin/unix.nix @@ -1,7 +1,7 @@ { lib, buildDunePackage , checkseum, cmdliner, git-unix, git-cohttp-unix, yaml, fpath , irmin, irmin-fs, irmin-git, irmin-graphql, irmin-http -, irmin-pack, irmin-watcher, irmin-test +, irmin-pack, irmin-watcher, irmin-test, cacert }: buildDunePackage rec { @@ -18,7 +18,9 @@ buildDunePackage rec { irmin-pack irmin-watcher git-cohttp-unix ]; - checkInputs = lib.optional doCheck irmin-test; + checkInputs = [ + irmin-test cacert + ]; doCheck = true; diff --git a/pkgs/development/ocaml-modules/letsencrypt/default.nix b/pkgs/development/ocaml-modules/letsencrypt/default.nix index b3c0d4f8941..0a70bf30242 100644 --- a/pkgs/development/ocaml-modules/letsencrypt/default.nix +++ b/pkgs/development/ocaml-modules/letsencrypt/default.nix @@ -31,11 +31,11 @@ buildDunePackage rec { pname = "letsencrypt"; - version = "0.2.4"; + version = "0.2.5"; src = fetchurl { url = "https://github.com/mmaker/ocaml-letsencrypt/releases/download/v${version}/letsencrypt-v${version}.tbz"; - sha256 = "91c79828a50243804da29c17563c54d2d528a79207e5b874dce6a3e7fedf7567"; + sha256 = "6e3bbb5f593823d49e83e698c06cf9ed48818695ec8318507b311ae74731e607"; }; minimumOCamlVersion = "4.08"; diff --git a/pkgs/development/ocaml-modules/mimic/default.nix b/pkgs/development/ocaml-modules/mimic/default.nix index 3ddae57e9e8..ea163642703 100644 --- a/pkgs/development/ocaml-modules/mimic/default.nix +++ b/pkgs/development/ocaml-modules/mimic/default.nix @@ -1,27 +1,23 @@ { lib, buildDunePackage, fetchurl -, fmt, mirage-flow, result, rresult, cstruct, logs, ke +, fmt, mirage-flow, result, rresult, cstruct, logs, ke, lwt , alcotest, alcotest-lwt, bigstringaf, bigarray-compat }: buildDunePackage rec { pname = "mimic"; - version = "0.0.2"; + version = "0.0.3"; minimumOCamlVersion = "4.08"; useDune2 = true; src = fetchurl { - url = "https://github.com/mirage/ocaml-git/releases/download/${pname}-v${version}/${pname}-${pname}-v${version}.tbz"; - sha256 = "3ad5af3caa1120ecfdf022de41ba5be8edfbf50270fc99238b82d3d2d6e7c317"; + url = "https://github.com/dinosaure/mimic/releases/download/${version}/mimic-${version}.tbz"; + sha256 = "e4743cd2e4f8242eb1ce9d8086fd2affba0eb6a62131309ffa279108bd3dbbcb"; }; - # don't install changelogs for other packages - postPatch = '' - rm -f CHANGES.md CHANGES.carton.md - ''; - propagatedBuildInputs = [ fmt + lwt mirage-flow result rresult diff --git a/pkgs/development/ocaml-modules/mirage/runtime.nix b/pkgs/development/ocaml-modules/mirage/runtime.nix index 50121ad6280..aaa51aa276c 100644 --- a/pkgs/development/ocaml-modules/mirage/runtime.nix +++ b/pkgs/development/ocaml-modules/mirage/runtime.nix @@ -3,7 +3,7 @@ buildDunePackage rec { pname = "mirage-runtime"; - version = "3.10.1"; + version = "3.10.3"; useDune2 = true; @@ -11,7 +11,7 @@ buildDunePackage rec { src = fetchurl { url = "https://github.com/mirage/mirage/releases/download/v${version}/mirage-v${version}.tbz"; - sha256 = "1glmsz2znhfkk4w6d6nsr7q5jqvivhmi8zwagzw2d8pah0c8bhm4"; + sha256 = "7c8059ef9e330eaef1ed51c0d89afe17900310f8083a426cd8099602222c2281"; }; propagatedBuildInputs = [ ipaddr functoria-runtime fmt logs ocaml_lwt ]; diff --git a/pkgs/development/ocaml-modules/optint/default.nix b/pkgs/development/ocaml-modules/optint/default.nix index 7f8ded5feb6..2227f6e033c 100644 --- a/pkgs/development/ocaml-modules/optint/default.nix +++ b/pkgs/development/ocaml-modules/optint/default.nix @@ -1,12 +1,12 @@ { lib, buildDunePackage, fetchurl }: buildDunePackage rec { - minimumOCamlVersion = "4.03"; - version = "0.0.4"; + minimumOCamlVersion = "4.07"; + version = "0.1.0"; pname = "optint"; src = fetchurl { url = "https://github.com/mirage/optint/releases/download/v${version}/optint-v${version}.tbz"; - sha256 = "1a7gabxqmfvii8qnxq1clx43md2h9glskxhac8y8r0rhzblx3s1a"; + sha256 = "27847660223c16cc7eaf8fcd9d5589a0b802114330a2529578f8007d3b01185d"; }; useDune2 = true; diff --git a/pkgs/development/ocaml-modules/paf/default.nix b/pkgs/development/ocaml-modules/paf/default.nix index 0c91051e243..375ba1c125e 100644 --- a/pkgs/development/ocaml-modules/paf/default.nix +++ b/pkgs/development/ocaml-modules/paf/default.nix @@ -5,6 +5,7 @@ , mirage-stack , mirage-time , httpaf +, h2 , tls-mirage , mimic , cohttp-lwt @@ -31,11 +32,11 @@ buildDunePackage rec { pname = "paf"; - version = "0.0.1"; + version = "0.0.3"; src = fetchurl { url = "https://github.com/dinosaure/paf-le-chien/releases/download/${version}/paf-${version}.tbz"; - sha256 = "7a794c21ce458bda302553b0f5ac128c067579fbb3b7b8fba9b410446c43e790"; + sha256 = "a0bbb84b19e1f0255337fc4d7017f3ea3611b241746e391b11c1d8b1f5f30a2b"; }; useDune2 = true; @@ -45,6 +46,7 @@ buildDunePackage rec { mirage-stack mirage-time httpaf + h2 tls-mirage mimic cohttp-lwt diff --git a/pkgs/development/ocaml-modules/tls/default.nix b/pkgs/development/ocaml-modules/tls/default.nix index 2ee01ed8219..dadeb5a98ea 100644 --- a/pkgs/development/ocaml-modules/tls/default.nix +++ b/pkgs/development/ocaml-modules/tls/default.nix @@ -1,17 +1,17 @@ { lib, fetchurl, buildDunePackage, ppx_sexp_conv, ppx_cstruct, cstruct , cstruct-sexp, sexplib, mirage-crypto, mirage-crypto-pk, mirage-crypto-rng -, x509, domain-name, fmt, cstruct-unix, ounit2, ocaml_lwt, ptime -, hacl_x25519, fiat-p256, hkdf, logs, alcotest }: +, x509, domain-name, fmt, cstruct-unix, ounit2, ocaml_lwt, ptime, rresult +, mirage-crypto-ec, hkdf, logs, alcotest }: buildDunePackage rec { minimumOCamlVersion = "4.08"; - version = "0.12.8"; + version = "0.13.1"; pname = "tls"; src = fetchurl { url = "https://github.com/mirleft/ocaml-tls/releases/download/v${version}/tls-v${version}.tbz"; - sha256 = "0sgppvfnamfnsglw1cl801i1xqkxbs33g40kwmmqj2vqjcarm26a"; + sha256 = "ca95fa59a82f7d38b0b495fc0cd1ff54e7728492a292895d0067c1ba9de81b7b"; }; useDune2 = true; @@ -21,8 +21,8 @@ buildDunePackage rec { propagatedBuildInputs = [ ppx_sexp_conv ppx_cstruct cstruct cstruct-sexp sexplib mirage-crypto mirage-crypto-pk mirage-crypto-rng - x509 domain-name fmt ocaml_lwt ptime hacl_x25519 fiat-p256 - hkdf logs ]; + x509 domain-name fmt ocaml_lwt ptime mirage-crypto-ec + hkdf logs rresult ]; meta = with lib; { homepage = "https://github.com/mirleft/ocaml-tls"; diff --git a/pkgs/development/ocaml-modules/tls/mirage.nix b/pkgs/development/ocaml-modules/tls/mirage.nix index ad81c03c35d..18d0f08357d 100644 --- a/pkgs/development/ocaml-modules/tls/mirage.nix +++ b/pkgs/development/ocaml-modules/tls/mirage.nix @@ -1,6 +1,6 @@ { buildDunePackage, tls , x509, lwt, fmt, mirage-flow, mirage-kv, mirage-clock, ptime -, mirage-crypto, mirage-crypto-pk, hacl_x25519, fiat-p256 +, mirage-crypto, mirage-crypto-pk, mirage-crypto-ec }: buildDunePackage { @@ -19,8 +19,7 @@ buildDunePackage { ptime mirage-crypto mirage-crypto-pk - hacl_x25519 - fiat-p256 + mirage-crypto-ec ]; meta = tls.meta // { diff --git a/pkgs/development/ocaml-modules/x509/default.nix b/pkgs/development/ocaml-modules/x509/default.nix index 637105361fd..0ce57b07168 100644 --- a/pkgs/development/ocaml-modules/x509/default.nix +++ b/pkgs/development/ocaml-modules/x509/default.nix @@ -8,11 +8,11 @@ buildDunePackage rec { minimumOCamlVersion = "4.07"; pname = "x509"; - version = "0.12.0"; + version = "0.13.0"; src = fetchurl { url = "https://github.com/mirleft/ocaml-x509/releases/download/v${version}/x509-v${version}.tbz"; - sha256 = "04g59j8sn8am0z0a94h8cyvr6cqzd5gkn2lj6g51nb5dkwajj19h"; + sha256 = "4577c2a616bda45cc777869fc44e272397d63a029135a993df8937bcfd6f6c49"; }; useDune2 = true; diff --git a/pkgs/top-level/ocaml-packages.nix b/pkgs/top-level/ocaml-packages.nix index 71da1aa5c0a..b6c551158c0 100644 --- a/pkgs/top-level/ocaml-packages.nix +++ b/pkgs/top-level/ocaml-packages.nix @@ -82,6 +82,8 @@ let ca-certs = callPackage ../development/ocaml-modules/ca-certs { }; + ca-certs-nss = callPackage ../development/ocaml-modules/ca-certs-nss { }; + carton = callPackage ../development/ocaml-modules/carton { }; carton-git = callPackage ../development/ocaml-modules/carton/git.nix { }; @@ -457,7 +459,7 @@ let git-cohttp-unix = callPackage ../development/ocaml-modules/git/cohttp-unix.nix { }; - git-cohttp-mirage = callPackage ../development/ocaml-modules/git/cohttp-mirage.nix { }; + git-paf = callPackage ../development/ocaml-modules/git/paf.nix { }; git-unix = callPackage ../development/ocaml-modules/git/unix.nix { git-binary = pkgs.git;