diff --git a/maintainers/maintainer-list.nix b/maintainers/maintainer-list.nix index 8ec79f2b5cb2..fee2009b2a05 100644 --- a/maintainers/maintainer-list.nix +++ b/maintainers/maintainer-list.nix @@ -3777,6 +3777,12 @@ githubId = 1298344; name = "Daniel Fullmer"; }; + danielrolls = { + email = "daniel.rolls.27@googlemail.com"; + github = "danielrolls"; + githubId = 50051176; + name = "Daniel Rolls"; + }; daniyalsuri6 = { email = "daniyal.suri@gmail.com"; github = "daniyalsuri6"; @@ -16556,6 +16562,12 @@ githubId = 863327; name = "Tyler Benster"; }; + tbidne = { + email = "tbidne@protonmail.com"; + github = "tbidne"; + githubId = 2856188; + name = "Thomas Bidne"; + }; tboerger = { email = "thomas@webhippie.de"; matrix = "@tboerger:matrix.org"; diff --git a/maintainers/scripts/haskell/update-stackage.sh b/maintainers/scripts/haskell/update-stackage.sh index ba64b42ba9b7..881cf5fd4837 100755 --- a/maintainers/scripts/haskell/update-stackage.sh +++ b/maintainers/scripts/haskell/update-stackage.sh @@ -66,6 +66,7 @@ sed -r \ -e '/ hie-bios /d' \ -e '/ ShellCheck /d' \ -e '/ Agda /d' \ + -e '/ stack /d' \ < "${tmpfile_new}" >> $stackage_config # Explanations: # cabal2nix, distribution-nixpkgs, jailbreak-cabal, language-nix: These are our packages and we know what we are doing. diff --git a/pkgs/data/misc/hackage/pin.json b/pkgs/data/misc/hackage/pin.json index df31806dffb4..98212bdf25a9 100644 --- a/pkgs/data/misc/hackage/pin.json +++ b/pkgs/data/misc/hackage/pin.json @@ -1,6 +1,6 @@ { - "commit": "2951c03cb95b8892bd6d4eb89d135764c35a8d7f", - "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/2951c03cb95b8892bd6d4eb89d135764c35a8d7f.tar.gz", - "sha256": "08sh9l9df2p51q4xhrl14jga48i0ad78fp7w3cccgcw1bqq4yxml", - "msg": "Update from Hackage at 2023-06-19T20:13:38Z" + "commit": "4cdb9878496fdb36b8b9c5f2ab0ef8a44a0f859f", + "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/4cdb9878496fdb36b8b9c5f2ab0ef8a44a0f859f.tar.gz", + "sha256": "0yhymzcsls48hf44ncd79xn786rfh4k70h78w7b0ihn7lrjgsynv", + "msg": "Update from Hackage at 2023-07-24T19:28:29Z" } diff --git a/pkgs/development/compilers/ghc/8.10.2-binary.nix b/pkgs/development/compilers/ghc/8.10.2-binary.nix index 368bc76bf0e2..ccd5d50aa75d 100644 --- a/pkgs/development/compilers/ghc/8.10.2-binary.nix +++ b/pkgs/development/compilers/ghc/8.10.2-binary.nix @@ -447,7 +447,6 @@ stdenv.mkDerivation rec { # long as the evaluator runs on a platform that supports # `pkgsMusl`. platforms = builtins.attrNames ghcBinDists.${distSetName}; - hydraPlatforms = builtins.filter (p: minimal || p != "aarch64-linux") platforms; maintainers = with lib.maintainers; [ guibou ] ++ lib.teams.haskell.members; diff --git a/pkgs/development/compilers/ghc/8.10.7.nix b/pkgs/development/compilers/ghc/8.10.7.nix index a7fdf026f152..6eedcb6374be 100644 --- a/pkgs/development/compilers/ghc/8.10.7.nix +++ b/pkgs/development/compilers/ghc/8.10.7.nix @@ -28,8 +28,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. diff --git a/pkgs/development/compilers/ghc/8.8.4.nix b/pkgs/development/compilers/ghc/8.8.4.nix index d6a8d9adde34..b00b6183121d 100644 --- a/pkgs/development/compilers/ghc/8.8.4.nix +++ b/pkgs/development/compilers/ghc/8.8.4.nix @@ -27,8 +27,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. diff --git a/pkgs/development/compilers/ghc/9.0.2.nix b/pkgs/development/compilers/ghc/9.0.2.nix index 2404363b8b5b..f5f0c9317147 100644 --- a/pkgs/development/compilers/ghc/9.0.2.nix +++ b/pkgs/development/compilers/ghc/9.0.2.nix @@ -30,8 +30,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. diff --git a/pkgs/development/compilers/ghc/9.2.4-binary.nix b/pkgs/development/compilers/ghc/9.2.4-binary.nix index 93380fd14519..d3a57b6c9f0f 100644 --- a/pkgs/development/compilers/ghc/9.2.4-binary.nix +++ b/pkgs/development/compilers/ghc/9.2.4-binary.nix @@ -429,7 +429,6 @@ stdenv.mkDerivation rec { # long as the evaluator runs on a platform that supports # `pkgsMusl`. platforms = builtins.attrNames ghcBinDists.${distSetName}; - hydraPlatforms = builtins.filter (p: minimal || p != "aarch64-linux") platforms; maintainers = lib.teams.haskell.members; }; } diff --git a/pkgs/development/compilers/ghc/9.2.4.nix b/pkgs/development/compilers/ghc/9.2.4.nix index 75265f8edff0..e34f33e9ca33 100644 --- a/pkgs/development/compilers/ghc/9.2.4.nix +++ b/pkgs/development/compilers/ghc/9.2.4.nix @@ -30,8 +30,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -217,7 +216,7 @@ stdenv.mkDerivation (rec { # These cause problems as they're not eliminated by GHC's dead code # elimination on aarch64-darwin. (see # https://github.com/NixOS/nixpkgs/issues/140774 for details). - ./Cabal-3.6-paths-fix-cycle-aarch64-darwin.patch + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.2.5.nix b/pkgs/development/compilers/ghc/9.2.5.nix index a157705bde9a..abbb42b631fe 100644 --- a/pkgs/development/compilers/ghc/9.2.5.nix +++ b/pkgs/development/compilers/ghc/9.2.5.nix @@ -30,8 +30,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -217,7 +216,7 @@ stdenv.mkDerivation (rec { # These cause problems as they're not eliminated by GHC's dead code # elimination on aarch64-darwin. (see # https://github.com/NixOS/nixpkgs/issues/140774 for details). - ./Cabal-3.6-paths-fix-cycle-aarch64-darwin.patch + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.2.6.nix b/pkgs/development/compilers/ghc/9.2.6.nix index ad6352425bcc..53ee00f7b373 100644 --- a/pkgs/development/compilers/ghc/9.2.6.nix +++ b/pkgs/development/compilers/ghc/9.2.6.nix @@ -30,8 +30,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -217,7 +216,7 @@ stdenv.mkDerivation (rec { # These cause problems as they're not eliminated by GHC's dead code # elimination on aarch64-darwin. (see # https://github.com/NixOS/nixpkgs/issues/140774 for details). - ./Cabal-3.6-paths-fix-cycle-aarch64-darwin.patch + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.2.7.nix b/pkgs/development/compilers/ghc/9.2.7.nix index e7957e3fe34e..dcde1b65a568 100644 --- a/pkgs/development/compilers/ghc/9.2.7.nix +++ b/pkgs/development/compilers/ghc/9.2.7.nix @@ -30,8 +30,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -217,7 +216,7 @@ stdenv.mkDerivation (rec { # These cause problems as they're not eliminated by GHC's dead code # elimination on aarch64-darwin. (see # https://github.com/NixOS/nixpkgs/issues/140774 for details). - ./Cabal-3.6-paths-fix-cycle-aarch64-darwin.patch + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.2.8.nix b/pkgs/development/compilers/ghc/9.2.8.nix index 13e787df8e4a..443526a0b719 100644 --- a/pkgs/development/compilers/ghc/9.2.8.nix +++ b/pkgs/development/compilers/ghc/9.2.8.nix @@ -30,8 +30,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -217,7 +216,7 @@ stdenv.mkDerivation (rec { # These cause problems as they're not eliminated by GHC's dead code # elimination on aarch64-darwin. (see # https://github.com/NixOS/nixpkgs/issues/140774 for details). - ./Cabal-3.6-paths-fix-cycle-aarch64-darwin.patch + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.4.2.nix b/pkgs/development/compilers/ghc/9.4.2.nix index eef9f06a0a8d..afe78cbb87c0 100644 --- a/pkgs/development/compilers/ghc/9.4.2.nix +++ b/pkgs/development/compilers/ghc/9.4.2.nix @@ -32,8 +32,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -190,6 +189,15 @@ stdenv.mkDerivation (rec { outputs = [ "out" "doc" ]; patches = [ + # Don't generate code that doesn't compile when --enable-relocatable is passed to Setup.hs + # Can be removed if the Cabal library included with ghc backports the linked fix + (fetchpatch { + url = "https://github.com/haskell/cabal/commit/6c796218c92f93c95e94d5ec2d077f6956f68e98.patch"; + stripLen = 1; + extraPrefix = "libraries/Cabal/"; + sha256 = "sha256-yRQ6YmMiwBwiYseC5BsrEtDgFbWvst+maGgDtdD0vAY="; + }) + # Fix docs build with sphinx >= 6.0 # https://gitlab.haskell.org/ghc/ghc/-/issues/22766 (fetchpatch { @@ -197,6 +205,14 @@ stdenv.mkDerivation (rec { url = "https://gitlab.haskell.org/ghc/ghc/-/commit/10e94a556b4f90769b7fd718b9790d58ae566600.patch"; sha256 = "0kmhfamr16w8gch0lgln2912r8aryjky1hfcda3jkcwa5cdzgjdv"; }) + ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [ + # Prevent the paths module from emitting symbols that we don't use + # when building with separate outputs. + # + # These cause problems as they're not eliminated by GHC's dead code + # elimination on aarch64-darwin. (see + # https://github.com/NixOS/nixpkgs/issues/140774 for details). + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.4.3.nix b/pkgs/development/compilers/ghc/9.4.3.nix index 9d6bfed13e0c..a2ae0cf400c7 100644 --- a/pkgs/development/compilers/ghc/9.4.3.nix +++ b/pkgs/development/compilers/ghc/9.4.3.nix @@ -32,8 +32,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -190,6 +189,15 @@ stdenv.mkDerivation (rec { outputs = [ "out" "doc" ]; patches = [ + # Don't generate code that doesn't compile when --enable-relocatable is passed to Setup.hs + # Can be removed if the Cabal library included with ghc backports the linked fix + (fetchpatch { + url = "https://github.com/haskell/cabal/commit/6c796218c92f93c95e94d5ec2d077f6956f68e98.patch"; + stripLen = 1; + extraPrefix = "libraries/Cabal/"; + sha256 = "sha256-yRQ6YmMiwBwiYseC5BsrEtDgFbWvst+maGgDtdD0vAY="; + }) + # Fix docs build with sphinx >= 6.0 # https://gitlab.haskell.org/ghc/ghc/-/issues/22766 (fetchpatch { @@ -197,6 +205,14 @@ stdenv.mkDerivation (rec { url = "https://gitlab.haskell.org/ghc/ghc/-/commit/10e94a556b4f90769b7fd718b9790d58ae566600.patch"; sha256 = "0kmhfamr16w8gch0lgln2912r8aryjky1hfcda3jkcwa5cdzgjdv"; }) + ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [ + # Prevent the paths module from emitting symbols that we don't use + # when building with separate outputs. + # + # These cause problems as they're not eliminated by GHC's dead code + # elimination on aarch64-darwin. (see + # https://github.com/NixOS/nixpkgs/issues/140774 for details). + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.4.4.nix b/pkgs/development/compilers/ghc/9.4.4.nix index 1c63c1c23080..13d01a342637 100644 --- a/pkgs/development/compilers/ghc/9.4.4.nix +++ b/pkgs/development/compilers/ghc/9.4.4.nix @@ -32,8 +32,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -206,6 +205,14 @@ stdenv.mkDerivation (rec { url = "https://gitlab.haskell.org/ghc/ghc/-/commit/10e94a556b4f90769b7fd718b9790d58ae566600.patch"; sha256 = "0kmhfamr16w8gch0lgln2912r8aryjky1hfcda3jkcwa5cdzgjdv"; }) + ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [ + # Prevent the paths module from emitting symbols that we don't use + # when building with separate outputs. + # + # These cause problems as they're not eliminated by GHC's dead code + # elimination on aarch64-darwin. (see + # https://github.com/NixOS/nixpkgs/issues/140774 for details). + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.4.5.nix b/pkgs/development/compilers/ghc/9.4.5.nix index 19af148c9c88..da333a613800 100644 --- a/pkgs/development/compilers/ghc/9.4.5.nix +++ b/pkgs/development/compilers/ghc/9.4.5.nix @@ -32,8 +32,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -206,6 +205,14 @@ stdenv.mkDerivation (rec { url = "https://gitlab.haskell.org/ghc/ghc/-/commit/10e94a556b4f90769b7fd718b9790d58ae566600.patch"; sha256 = "0kmhfamr16w8gch0lgln2912r8aryjky1hfcda3jkcwa5cdzgjdv"; }) + ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [ + # Prevent the paths module from emitting symbols that we don't use + # when building with separate outputs. + # + # These cause problems as they're not eliminated by GHC's dead code + # elimination on aarch64-darwin. (see + # https://github.com/NixOS/nixpkgs/issues/140774 for details). + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch ]; postPatch = "patchShebangs ."; diff --git a/pkgs/development/compilers/ghc/9.4.6-bytestring-posix-source.patch b/pkgs/development/compilers/ghc/9.4.6-bytestring-posix-source.patch new file mode 100644 index 000000000000..644ab295191f --- /dev/null +++ b/pkgs/development/compilers/ghc/9.4.6-bytestring-posix-source.patch @@ -0,0 +1,15 @@ +Make sure that the appropriate feature flags are set when +Rts.h is included, so that clockid_t is defined. + +diff --git a/cbits/is-valid-utf8.c b/cbits/is-valid-utf8.c +index 01b3b41..c69596a 100644 +--- a/libraries/bytestring/cbits/is-valid-utf8.c ++++ b/libraries/bytestring/cbits/is-valid-utf8.c +@@ -29,6 +29,7 @@ SUCH DAMAGE. + */ + #pragma GCC push_options + #pragma GCC optimize("-O2") ++#include "rts/PosixSource.h" + #include + #include + #include diff --git a/pkgs/development/compilers/ghc/9.4.6.nix b/pkgs/development/compilers/ghc/9.4.6.nix new file mode 100644 index 000000000000..95cb31a411ff --- /dev/null +++ b/pkgs/development/compilers/ghc/9.4.6.nix @@ -0,0 +1,392 @@ +# DO NOT port this expression to hadrian. It is not possible to build a GHC +# cross compiler with 9.4.* and hadrian. +{ lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages + +# build-tools +, bootPkgs +, autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx +, xattr, autoSignDarwinBinariesHook +, bash + +, libiconv ? null, ncurses +, glibcLocales ? null + +, # GHC can be built with system libffi or a bundled one. + libffi ? null + +, useLLVM ? !(stdenv.targetPlatform.isx86 + || stdenv.targetPlatform.isPower + || stdenv.targetPlatform.isSparc + || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin)) +, # LLVM is conceptually a run-time-only dependency, but for + # non-x86, we need LLVM to bootstrap later stages, so it becomes a + # build-time dependency too. + buildTargetLlvmPackages, llvmPackages + +, # If enabled, GHC will be built with the GPL-free but slightly slower native + # bignum backend instead of the faster but GPLed gmp backend. + enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp + && lib.meta.availableOn stdenv.targetPlatform gmp) +, gmp + +, # If enabled, use -fPIC when compiling static libs. + enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform + +, enableProfiledLibs ? true + +, # Whether to build dynamic libs for the standard library (on the target + # platform). Static libs are always built. + enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic + +, # Whether to build terminfo. + enableTerminfo ? !stdenv.targetPlatform.isWindows + +, # What flavour to build. An empty string indicates no + # specific flavour and falls back to ghc default values. + ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform) + (if useLLVM then "perf-cross" else "perf-cross-ncg") + +, # Whether to build sphinx documentation. + enableDocs ? ( + # Docs disabled for musl and cross because it's a large task to keep + # all `sphinx` dependencies building in those environments. + # `sphinx` pulls in among others: + # Ruby, Python, Perl, Rust, OpenGL, Xorg, gtk, LLVM. + (stdenv.targetPlatform == stdenv.hostPlatform) + && !stdenv.hostPlatform.isMusl + ) + +, enableHaddockProgram ? + # Disabled for cross; see note [HADDOCK_DOCS]. + (stdenv.targetPlatform == stdenv.hostPlatform) + +, # Whether to disable the large address space allocator + # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/ + disableLargeAddressSpace ? stdenv.targetPlatform.isiOS +}: + +assert !enableNativeBignum -> gmp != null; + +# Cross cannot currently build the `haddock` program for silly reasons, +# see note [HADDOCK_DOCS]. +assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram; + +let + inherit (stdenv) buildPlatform hostPlatform targetPlatform; + + inherit (bootPkgs) ghc; + + # TODO(@Ericson2314) Make unconditional + targetPrefix = lib.optionalString + (targetPlatform != hostPlatform) + "${targetPlatform.config}-"; + + buildMK = '' + BuildFlavour = ${ghcFlavour} + ifneq \"\$(BuildFlavour)\" \"\" + include mk/flavours/\$(BuildFlavour).mk + endif + BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"} + BUILD_SPHINX_PDF = NO + '' + + # Note [HADDOCK_DOCS]: + # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock` + # program is built (which we generally always want to have a complete GHC install) + # and whether it is run on the GHC sources to generate hyperlinked source code + # (which is impossible for cross-compilation); see: + # https://gitlab.haskell.org/ghc/ghc/-/issues/20077 + # This implies that currently a cross-compiled GHC will never have a `haddock` + # program, so it can never generate haddocks for any packages. + # If this is solved in the future, we'd like to unconditionally + # build the haddock program (removing the `enableHaddockProgram` option). + '' + HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"} + # Build haddocks for boot packages with hyperlinking + EXTRA_HADDOCK_OPTS += --hyperlinked-source --quickjump + + DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"} + BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"} + '' + lib.optionalString (targetPlatform != hostPlatform) '' + Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"} + CrossCompilePrefix = ${targetPrefix} + '' + lib.optionalString (!enableProfiledLibs) '' + GhcLibWays = "v dyn" + '' + + # -fexternal-dynamic-refs apparently (because it's not clear from the documentation) + # makes the GHC RTS able to load static libraries, which may be needed for TemplateHaskell. + # This solution was described in https://www.tweag.io/blog/2020-09-30-bazel-static-haskell + lib.optionalString enableRelocatedStaticLibs '' + GhcLibHcOpts += -fPIC -fexternal-dynamic-refs + GhcRtsHcOpts += -fPIC -fexternal-dynamic-refs + '' + lib.optionalString targetPlatform.useAndroidPrebuilt '' + EXTRA_CC_OPTS += -std=gnu99 + ''; + + # Splicer will pull out correct variations + libDeps = platform: lib.optional enableTerminfo ncurses + ++ [libffi] + ++ lib.optional (!enableNativeBignum) gmp + ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv; + + # TODO(@sternenseemann): is buildTarget LLVM unnecessary? + # GHC doesn't seem to have {LLC,OPT}_HOST + toolsForTarget = [ + pkgsBuildTarget.targetPackages.stdenv.cc + ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm; + + targetCC = builtins.head toolsForTarget; + + # Sometimes we have to dispatch between the bintools wrapper and the unwrapped + # derivation for certain tools depending on the platform. + bintoolsFor = { + # GHC needs install_name_tool on all darwin platforms. On aarch64-darwin it is + # part of the bintools wrapper (due to codesigning requirements), but not on + # x86_64-darwin. + install_name_tool = + if stdenv.targetPlatform.isAarch64 + then targetCC.bintools + else targetCC.bintools.bintools; + # Same goes for strip. + strip = + # TODO(@sternenseemann): also use wrapper if linker == "bfd" or "gold" + if stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin + then targetCC.bintools + else targetCC.bintools.bintools; + }; + + # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues. + # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856 + # see #84670 and #49071 for more background. + useLdGold = targetPlatform.linker == "gold" || + (targetPlatform.linker == "bfd" && (targetCC.bintools.bintools.hasGold or false) && !targetPlatform.isMusl); + + # Makes debugging easier to see which variant is at play in `nix-store -q --tree`. + variantSuffix = lib.concatStrings [ + (lib.optionalString stdenv.hostPlatform.isMusl "-musl") + (lib.optionalString enableNativeBignum "-native-bignum") + ]; + +in + +# C compiler, bintools and LLVM are used at build time, but will also leak into +# the resulting GHC's settings file and used at runtime. This means that we are +# currently only able to build GHC if hostPlatform == buildPlatform. +assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc; +assert buildTargetLlvmPackages.llvm == llvmPackages.llvm; +assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang; + +stdenv.mkDerivation (rec { + version = "9.4.6"; + pname = "${targetPrefix}ghc${variantSuffix}"; + + src = fetchurl { + url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz"; + sha256 = "1b705cf52692f9d4d6707cdf8e761590f5f56ec8ea6a65e36610db392d3d24b9"; + }; + + enableParallelBuilding = true; + + outputs = [ "out" "doc" ]; + + patches = [ + # Don't generate code that doesn't compile when --enable-relocatable is passed to Setup.hs + # Can be removed if the Cabal library included with ghc backports the linked fix + (fetchpatch { + url = "https://github.com/haskell/cabal/commit/6c796218c92f93c95e94d5ec2d077f6956f68e98.patch"; + stripLen = 1; + extraPrefix = "libraries/Cabal/"; + sha256 = "sha256-yRQ6YmMiwBwiYseC5BsrEtDgFbWvst+maGgDtdD0vAY="; + }) + + # Work around a type not being defined when including Rts.h in bytestring's cbits + # due to missing feature macros. See https://gitlab.haskell.org/ghc/ghc/-/issues/23810. + ./9.4.6-bytestring-posix-source.patch + ] ++ lib.optionals (stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64) [ + # Prevent the paths module from emitting symbols that we don't use + # when building with separate outputs. + # + # These cause problems as they're not eliminated by GHC's dead code + # elimination on aarch64-darwin. (see + # https://github.com/NixOS/nixpkgs/issues/140774 for details). + ./Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch + ]; + + postPatch = "patchShebangs ."; + + # GHC needs the locale configured during the Haddock phase. + LANG = "en_US.UTF-8"; + + # GHC is a bit confused on its cross terminology. + # TODO(@sternenseemann): investigate coreutils dependencies and pass absolute paths + preConfigure = '' + for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do + export "''${env#TARGET_}=''${!env}" + done + # GHC is a bit confused on its cross terminology, as these would normally be + # the *host* tools. + export CC="${targetCC}/bin/${targetCC.targetPrefix}cc" + export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++" + # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177 + export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}" + export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as" + export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar" + export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm" + export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib" + export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf" + export STRIP="${bintoolsFor.strip}/bin/${bintoolsFor.strip.targetPrefix}strip" + '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") '' + export OTOOL="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}otool" + export INSTALL_NAME_TOOL="${bintoolsFor.install_name_tool}/bin/${bintoolsFor.install_name_tool.targetPrefix}install_name_tool" + '' + lib.optionalString useLLVM '' + export LLC="${lib.getBin buildTargetLlvmPackages.llvm}/bin/llc" + export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt" + '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) '' + # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm + export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang" + '' + '' + + echo -n "${buildMK}" > mk/build.mk + + sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure + '' + lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") '' + export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive" + '' + lib.optionalString (!stdenv.isDarwin) '' + export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}" + '' + lib.optionalString stdenv.isDarwin '' + export NIX_LDFLAGS+=" -no_dtrace_dof" + + # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7 + export XATTR=${lib.getBin xattr}/bin/xattr + '' + lib.optionalString targetPlatform.useAndroidPrebuilt '' + sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets + '' + lib.optionalString targetPlatform.isMusl '' + echo "patching llvm-targets for musl targets..." + echo "Cloning these existing '*-linux-gnu*' targets:" + grep linux-gnu llvm-targets | sed 's/^/ /' + echo "(go go gadget sed)" + sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets + echo "llvm-targets now contains these '*-linux-musl*' targets:" + grep linux-musl llvm-targets | sed 's/^/ /' + + echo "And now patching to preserve '-musleabi' as done with '-gnueabi'" + # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen) + for x in configure aclocal.m4; do + substituteInPlace $x \ + --replace '*-android*|*-gnueabi*)' \ + '*-android*|*-gnueabi*|*-musleabi*)' + done + '' + # HACK: allow bootstrapping with GHC 8.10 which works fine, as we don't have + # binary 9.0 packaged. Bootstrapping with 9.2 is broken without hadrian. + + '' + substituteInPlace configure --replace \ + 'MinBootGhcVersion="9.0"' \ + 'MinBootGhcVersion="8.10"' + ''; + + # TODO(@Ericson2314): Always pass "--target" and always prefix. + configurePlatforms = [ "build" "host" ] + ++ lib.optional (targetPlatform != hostPlatform) "target"; + + # `--with` flags for libraries needed for RTS linker + configureFlags = [ + "--datadir=$doc/share/doc/ghc" + "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib" + ] ++ lib.optionals (libffi != null) [ + "--with-system-libffi" + "--with-ffi-includes=${targetPackages.libffi.dev}/include" + "--with-ffi-libraries=${targetPackages.libffi.out}/lib" + ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [ + "--with-gmp-includes=${targetPackages.gmp.dev}/include" + "--with-gmp-libraries=${targetPackages.gmp.out}/lib" + ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [ + "--with-iconv-includes=${libiconv}/include" + "--with-iconv-libraries=${libiconv}/lib" + ] ++ lib.optionals (targetPlatform != hostPlatform) [ + "--enable-bootstrap-with-devel-snapshot" + ] ++ lib.optionals useLdGold [ + "CFLAGS=-fuse-ld=gold" + "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold" + "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold" + ] ++ lib.optionals (disableLargeAddressSpace) [ + "--disable-large-address-space" + ]; + + # Make sure we never relax`$PATH` and hooks support for compatibility. + strictDeps = true; + + # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself. + dontAddExtraLibs = true; + + nativeBuildInputs = [ + perl autoconf automake m4 python3 + ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour + ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [ + autoSignDarwinBinariesHook + ] ++ lib.optionals enableDocs [ + sphinx + ]; + + # For building runtime libs + depsBuildTarget = toolsForTarget; + + buildInputs = [ perl bash ] ++ (libDeps hostPlatform); + + depsTargetTarget = map lib.getDev (libDeps targetPlatform); + depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform); + + # required, because otherwise all symbols from HSffi.o are stripped, and + # that in turn causes GHCi to abort + stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols"; + + checkTarget = "test"; + + hardeningDisable = + [ "format" ] + # In nixpkgs, musl based builds currently enable `pie` hardening by default + # (see `defaultHardeningFlags` in `make-derivation.nix`). + # But GHC cannot currently produce outputs that are ready for `-pie` linking. + # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear. + # See: + # * https://github.com/NixOS/nixpkgs/issues/129247 + # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580 + ++ lib.optional stdenv.targetPlatform.isMusl "pie"; + + # big-parallel allows us to build with more than 2 cores on + # Hydra which already warrants a significant speedup + requiredSystemFeatures = [ "big-parallel" ]; + + postInstall = '' + # Install the bash completion file. + install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc + ''; + + passthru = { + inherit bootPkgs targetPrefix; + + inherit llvmPackages; + inherit enableShared; + + # This is used by the haskell builder to query + # the presence of the haddock program. + hasHaddock = enableHaddockProgram; + + # Our Cabal compiler name + haskellCompilerName = "ghc-${version}"; + }; + + meta = { + homepage = "http://haskell.org/ghc"; + description = "The Glasgow Haskell Compiler"; + maintainers = with lib.maintainers; [ + guibou + ] ++ lib.teams.haskell.members; + timeout = 24 * 3600; + inherit (ghc.meta) license platforms; + }; + +} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt { + dontStrip = true; + dontPatchELF = true; + noAuditTmpdir = true; +}) diff --git a/pkgs/development/compilers/ghc/Cabal-3.6-paths-fix-cycle-aarch64-darwin.patch b/pkgs/development/compilers/ghc/Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch similarity index 100% rename from pkgs/development/compilers/ghc/Cabal-3.6-paths-fix-cycle-aarch64-darwin.patch rename to pkgs/development/compilers/ghc/Cabal-3.6-3.8-paths-fix-cycle-aarch64-darwin.patch diff --git a/pkgs/development/compilers/ghc/common-hadrian.nix b/pkgs/development/compilers/ghc/common-hadrian.nix index 099a7fd2568f..94755f1beec8 100644 --- a/pkgs/development/compilers/ghc/common-hadrian.nix +++ b/pkgs/development/compilers/ghc/common-hadrian.nix @@ -57,8 +57,7 @@ , # If enabled, use -fPIC when compiling static libs. enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform - # aarch64 outputs otherwise exceed 2GB limit -, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 +, enableProfiledLibs ? true , # Whether to build dynamic libs for the standard library (on the target # platform). Static libs are always built. @@ -155,6 +154,8 @@ ghcSrc = ghcSrc; ghcVersion = version; userSettings = hadrianUserSettings; + # Disable haddock generating pretty source listings to stay under 3GB on aarch64-linux + enableHyperlinkedSource = !(stdenv.hostPlatform.isAarch64 && stdenv.hostPlatform.isLinux); } , # Whether to build sphinx documentation. diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable.nix b/pkgs/development/haskell-modules/cabal2nix-unstable.nix index d55a1341cf4b..3fa9c44e7cd7 100644 --- a/pkgs/development/haskell-modules/cabal2nix-unstable.nix +++ b/pkgs/development/haskell-modules/cabal2nix-unstable.nix @@ -8,10 +8,10 @@ }: mkDerivation { pname = "cabal2nix"; - version = "unstable-2023-05-05"; + version = "unstable-2023-08-15"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/078350047d358bb450d634d775493aba89b21212.tar.gz"; - sha256 = "0rsdn2zyw0zr6pi3dg6cm3i310alppigdsv20iqpx0dzykkicywj"; + url = "https://github.com/NixOS/cabal2nix/archive/0365d9b77086d26ca5197fb48019cedbb0dce5d2.tar.gz"; + sha256 = "15aia2v05cmblabhb287cf1yqy4dlzw0g905h79fcvkgygnn2ib8"; }; postUnpack = "sourceRoot+=/cabal2nix; echo source root reset to $sourceRoot"; isLibrary = true; diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 2328d3214593..9951c38a54bb 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -19,15 +19,6 @@ in with haskellLib; self: super: { - - # Make sure that Cabal 3.8.* can be built as-is - Cabal_3_8_1_0 = doDistribute (super.Cabal_3_8_1_0.override ({ - Cabal-syntax = self.Cabal-syntax_3_8_1_0; - } // lib.optionalAttrs (lib.versionOlder self.ghc.version "9.2.5") { - # Use process core package when possible - process = self.process_1_6_17_0; - })); - # Make sure that Cabal 3.10.* can be built as-is Cabal_3_10_1_0 = doDistribute (super.Cabal_3_10_1_0.override ({ Cabal-syntax = self.Cabal-syntax_3_10_1_0; @@ -42,7 +33,12 @@ self: super: { let # !!! Use cself/csuper inside for the actual overrides cabalInstallOverlay = cself: csuper: - lib.optionalAttrs (lib.versionOlder self.ghc.version "9.6") { + { + # Needs to be upgraded compared to Stackage LTS 21 + cabal-install-solver = cself.cabal-install-solver_3_10_1_0; + # Needs to be downgraded compared to Stackage LTS 21 + resolv = cself.resolv_0_1_2_0; + } // lib.optionalAttrs (lib.versionOlder self.ghc.version "9.6") { Cabal = cself.Cabal_3_10_1_0; Cabal-syntax = cself.Cabal-syntax_3_10_1_0; } // lib.optionalAttrs (lib.versionOlder self.ghc.version "9.4") { @@ -61,15 +57,15 @@ self: super: { # not solvable short of recompiling GHC. Instead of adding # allowInconsistentDependencies for all reverse dependencies of hspec-core, # just upgrade to an hspec version without the offending dependency. - hspec-core = cself.hspec-core_2_11_1; - hspec-discover = cself.hspec-discover_2_11_1; - hspec = cself.hspec_2_11_1; + hspec-core = cself.hspec-core_2_11_4; + hspec-discover = cself.hspec-discover_2_11_4; + hspec = cself.hspec_2_11_4; # hspec-discover and hspec-core depend on hspec-meta for testing which # we need to avoid since it depends on ghc as well. Since hspec*_2_11* # are overridden to take the versioned attributes as inputs, we need # to make sure to override the versioned attribute with this fix. - hspec-discover_2_11_1 = dontCheck csuper.hspec-discover_2_11_1; + hspec-discover_2_11_4 = dontCheck csuper.hspec-discover_2_11_4; # Prevent dependency on doctest which causes an inconsistent dependency # due to depending on ghc which depends on directory etc. @@ -80,20 +76,16 @@ self: super: { cabal-install = super.cabal-install.overrideScope cabalInstallOverlay; cabal-install-solver = super.cabal-install-solver.overrideScope cabalInstallOverlay; - guardian = lib.pipe - # Needs cabal-install >= 3.8 /as well as/ matching Cabal - (super.guardian.overrideScope (self: super: - cabalInstallOverlay self super // { - # Needs at least path-io 1.8.0 due to canonicalizePath changes - path-io = self.path-io_1_8_1; - } - )) - [ - # Tests need internet access (run stack) - dontCheck - # May as well… - (self.generateOptparseApplicativeCompletions [ "guardian" ]) - ]; + # Needs cabal-install >= 3.8 /as well as/ matching Cabal + guardian = + lib.pipe + (super.guardian.overrideScope cabalInstallOverlay) + [ + # Tests need internet access (run stack) + dontCheck + # May as well… + (self.generateOptparseApplicativeCompletions [ "guardian" ]) + ]; } ) cabal-install cabal-install-solver @@ -125,8 +117,6 @@ self: super: { hls-brittany-plugin = assert super.hls-brittany-plugin.version == "1.1.0.0"; doJailbreak super.hls-brittany-plugin; hls-hlint-plugin = super.hls-hlint-plugin.override { - # For "ghc-lib" flag see https://github.com/haskell/haskell-language-server/issues/3185#issuecomment-1250264515 - hlint = enableCabalFlag "ghc-lib" super.hlint; apply-refact = self.apply-refact_0_11_0_0; }; @@ -137,13 +127,31 @@ self: super: { # https://github.com/supki/ldap-client/issues/18 ldap-client-og = dontCheck super.ldap-client-og; - # For -fghc-lib see cabal.project in haskell-language-server. - stylish-haskell = if lib.versionAtLeast super.ghc.version "9.2" - then enableCabalFlag "ghc-lib" - (if lib.versionAtLeast super.ghc.version "9.4" - then super.stylish-haskell_0_14_4_0 - else super.stylish-haskell) - else super.stylish-haskell; + stylish-haskell = + # Too-strict upper bounds, no Hackage revisions + doJailbreak + # For -fghc-lib see cabal.project in haskell-language-server. + (if lib.versionAtLeast super.ghc.version "9.2" + then enableCabalFlag "ghc-lib" super.stylish-haskell + else super.stylish-haskell + ); + + hiedb = + lib.pipe + super.hiedb + [ + # hiedb-0.4.3.0 does not yet support algebraic-graphs-0.7. This patch works + # around the issue. + # https://github.com/wz1000/HieDb/pull/44 + (appendPatch + (pkgs.fetchpatch { + name = "hiedb-algebraic-graphs-0.7.patch"; + url = "https://github.com/wz1000/HieDB/commit/4ac8e6735321872b9d5d15a9cac492add5555234.patch"; + hash = "sha256-Iu+M8r+DrpoxUCG6yekgbW+GffoNjjRksnwUJ6jojhE="; + })) + # Patch does not actually bump the bound in the .cabal file. + doJailbreak + ]; ########################################### ### END HASKELL-LANGUAGE-SERVER SECTION ### @@ -175,30 +183,39 @@ self: super: { testFlags = drv.testFlags or [] ++ [ "-p" "! /Kahan.t_sum_shifted/" ]; }) super.math-functions; + # Too strict bounds on base + # https://github.com/lspitzner/butcher/issues/7#issuecomment-1681394943 + butcher = doJailbreak super.butcher; + # https://github.com/lspitzner/data-tree-print/issues/4 + data-tree-print = doJailbreak super.data-tree-print; + # … and template-haskell. + # https://github.com/lspitzner/czipwith/issues/5 + czipwith = doJailbreak super.czipwith; + # Deal with infinite and NaN values generated by QuickCheck-2.14.3 - inherit ( - let - aesonQuickCheckPatch = appendPatches [ - (pkgs.fetchpatch { - name = "aeson-quickcheck-2.14.3-double-workaround.patch"; - url = "https://github.com/haskell/aeson/commit/58766a1916b4980792763bab74f0c86e2a7ebf20.patch"; - sha256 = "1jk2xyi9g6dfjsi6hvpvkpmag3ivimipwy1izpbidf3wvc9cixs3"; - }) - ]; - in - { - aeson = aesonQuickCheckPatch super.aeson; - aeson_2_1_2_1 = aesonQuickCheckPatch super.aeson_2_1_2_1; - } - ) aeson - aeson_2_1_2_1 - ; + aeson = overrideCabal { + # aeson's test suite includes some tests with big numbers that fail on 32bit + # https://github.com/haskell/aeson/issues/1060 + doCheck = !pkgs.stdenv.hostPlatform.is32bit; + } (appendPatches [ + (pkgs.fetchpatch { + name = "aeson-quickcheck-2.14.3-double-workaround.patch"; + url = "https://github.com/haskell/aeson/commit/58766a1916b4980792763bab74f0c86e2a7ebf20.patch"; + sha256 = "1jk2xyi9g6dfjsi6hvpvkpmag3ivimipwy1izpbidf3wvc9cixs3"; + }) + ] super.aeson); # 2023-06-28: Test error: https://hydra.nixos.org/build/225565149 orbits = dontCheck super.orbits; - # 2023-06-28: Test error: https://hydra.nixos.org/build/225559546 - monad-bayes = dontCheck super.monad-bayes; + # Allow aeson == 2.1.* + # https://github.com/hdgarrood/aeson-better-errors/issues/23 + aeson-better-errors = doJailbreak super.aeson-better-errors; + + # 2023-08-09: Jailbreak because of vector < 0.13 + monad-bayes = doJailbreak (super.monad-bayes.override { + hspec = self.hspec_2_11_4; + }); # Disable tests failing on odd floating point numbers generated by QuickCheck 2.14.3 # https://github.com/haskell/statistics/issues/205 @@ -220,7 +237,11 @@ self: super: { # Arion's test suite needs a Nixpkgs, which is cumbersome to do from Nixpkgs # itself. For instance, pkgs.path has dirty sources and puts a huge .git in the # store. Testing is done upstream. - arion-compose = dontCheck super.arion-compose; + # 2023-07-27: Allow base-4.17 + arion-compose = dontCheck (assert super.arion-compose.version == "0.2.0.0"; doJailbreak super.arion-compose); + + # 2023-07-17: Outdated base bound https://github.com/srid/lvar/issues/5 + lvar = doJailbreak super.lvar; # This used to be a core package provided by GHC, but then the compiler # dropped it. We define the name here to make sure that old packages which @@ -255,17 +276,43 @@ self: super: { ghc-datasize = disableLibraryProfiling super.ghc-datasize; ghc-vis = disableLibraryProfiling super.ghc-vis; + # Fixes compilation for basement on i686 for GHC >= 9.4 + # https://github.com/haskell-foundation/foundation/pull/573 + # Patch would not work for GHC >= 9.2 where it breaks compilation on x86_64 + # https://github.com/haskell-foundation/foundation/pull/573#issuecomment-1669468867 + # TODO(@sternenseemann): make unconditional + basement = appendPatches (lib.optionals pkgs.stdenv.hostPlatform.is32bit [ + (fetchpatch { + name = "basement-i686-ghc-9.4.patch"; + url = "https://github.com/haskell-foundation/foundation/pull/573/commits/38be2c93acb6f459d24ed6c626981c35ccf44095.patch"; + sha256 = "17kz8glfim29vyhj8idw8bdh3id5sl9zaq18zzih3schfvyjppj7"; + stripLen = 1; + }) + ]) super.basement; + + # Fixes compilation of memory with GHC >= 9.4 on 32bit platforms + # https://github.com/vincenthz/hs-memory/pull/99 + memory = appendPatches (lib.optionals pkgs.stdenv.hostPlatform.is32bit [ + (fetchpatch { + name = "memory-i686-ghc-9.4.patch"; + url = "https://github.com/vincenthz/hs-memory/pull/99/commits/2738929ce15b4c8704bbbac24a08539b5d4bf30e.patch"; + sha256 = "196rj83iq2k249132xsyhbbl81qi1j23h9pa6mmk6zvxpcf63yfw"; + }) + ]) super.memory; + + # Waiting for the commit being fetched as a patch to get a release. + espial = appendPatch (fetchpatch { + url = "https://github.com/jonschoning/espial/commit/70375db7e245207b3572779288eade3252c4d9e3.patch"; + sha256 = "sha256-fto8fdFbZkzn7dwCCsGw+j+5HSvEvyvU5VzYDn4F2G8="; + excludes = ["*.yaml" "*.lock" "*.json"]; + }) super.espial; + # 2023-06-10: Too strict version bound on https://github.com/haskell/ThreadScope/issues/118 threadscope = doJailbreak super.threadscope; - # patat main branch has an unreleased commit that fixes the build by - # relaxing restrictive upper boundaries. This can be removed once there's a - # new release following version 0.8.8.0. - patat = appendPatch (fetchpatch { - url = "https://github.com/jaspervdj/patat/commit/be9e0fe5642ba6aa7b25705ba17950923e9951fa.patch"; - sha256 = "sha256-Vxxi46qrkIyzYQZ+fe1vNTPldcQEI2rX2H40GvFJR2M="; - excludes = ["stack.yaml" "stack.yaml.lock"]; - }) super.patat; + # Overriding the version pandoc dependency uses as the latest release has version bounds + # defined as >= 3.1 && < 3.2, can be removed once pandoc gets bumped by Stackage. + patat = super.patat.override { pandoc = self.pandoc_3_1_6; }; # The latest release on hackage has an upper bound on containers which # breaks the build, though it works with the version of containers present @@ -280,6 +327,10 @@ self: super: { mysql-simple = dontCheck super.mysql-simple; mysql-haskell = dontCheck super.mysql-haskell; + # Test data missing + # https://github.com/FPtje/GLuaFixer/issues/165 + glualint = dontCheck super.glualint; + # The Hackage tarball is purposefully broken, because it's not intended to be, like, useful. # https://git-annex.branchable.com/bugs/bash_completion_file_is_missing_in_the_6.20160527_tarball_on_hackage/ git-annex = overrideCabal (drv: { @@ -287,7 +338,7 @@ self: super: { name = "git-annex-${super.git-annex.version}-src"; url = "git://git-annex.branchable.com/"; rev = "refs/tags/" + super.git-annex.version; - sha256 = "0mz1b3vnschsndv42787mm6kybpb2yskkdss3rcm7xc6jjh815ik"; + sha256 = "1i14mv8z9sr5sckckwiba4cypgs3iwk19pyrl9xzcrzz426dxrba"; # delete android and Android directories which cause issues on # darwin (case insensitive directory). Since we don't need them # during the build process, we can delete it to prevent a hash @@ -302,25 +353,55 @@ self: super: { # `git-annex-shell` by making `shell = haskellPackages.git-annex`. # https://git-annex.branchable.com/git-annex-shell/ passthru.shellPath = "/bin/git-annex-shell"; - }) super.git-annex; + }) (super.git-annex.overrideScope (self: _: { + # https://github.com/haskell-pkg-janitors/unix-compat/issues/3 + unix-compat = self.unix-compat_0_6; + })); # Too strict bounds on servant # Pending a hackage revision: https://github.com/berberman/arch-web/commit/5d08afee5b25e644f9e2e2b95380a5d4f4aa81ea#commitcomment-89230555 arch-web = doJailbreak super.arch-web; + # Too strict upper bound on hedgehog + # https://github.com/circuithub/rel8/issues/248 + rel8 = doJailbreak super.rel8; + # Fix test trying to access /home directory shell-conduit = overrideCabal (drv: { postPatch = "sed -i s/home/tmp/ test/Spec.hs"; }) super.shell-conduit; - cachix = self.generateOptparseApplicativeCompletions [ "cachix" ] super.cachix; + # https://github.com/serokell/nixfmt/issues/130 + nixfmt = doJailbreak super.nixfmt; + + # Too strict upper bounds on turtle and text + # https://github.com/awakesecurity/nix-deploy/issues/35 + nix-deploy = doJailbreak super.nix-deploy; + + # Too strict upper bound on algebraic-graphs + # https://github.com/awakesecurity/nix-graph/issues/5 + nix-graph = doJailbreak super.nix-graph; + + cachix = self.generateOptparseApplicativeCompletions [ "cachix" ] + # Adds a workaround to the API changes in the versions library + # Should be dropped by the next release + # https://github.com/cachix/cachix/pull/556 + (appendPatch (fetchpatch { + url = "https://github.com/cachix/cachix/commit/078d2d2212d7533a6a4db000958bfc4373c4deeb.patch"; + hash = "sha256-xfJaO2CuZWFHivq4gqbkNnTOWPiyFVjlwOPV6yibKH4="; + stripLen = 1; + }) super.cachix); # https://github.com/froozen/kademlia/issues/2 kademlia = dontCheck super.kademlia; # Tests require older versions of tasty. hzk = dontCheck super.hzk; - resolv = doJailbreak super.resolv; + resolv_0_1_2_0 = doJailbreak super.resolv_0_1_2_0; + + # Too strict bounds on base{,-orphans}, template-haskell + # https://github.com/sebastiaanvisser/fclabels/issues/44 + fclabels = doJailbreak super.fclabels; # Tests require a Kafka broker running locally haskakafka = dontCheck super.haskakafka; @@ -345,18 +426,7 @@ self: super: { # https://github.com/techtangents/ablist/issues/1 ABList = dontCheck super.ABList; - pandoc-cli = throwIfNot (versionOlder super.pandoc.version "3.0.0") "pandoc-cli contains the pandoc executable starting with 3.0, this needs to be considered now." (markBroken (dontDistribute super.pandoc-cli)); - inline-c-cpp = overrideCabal (drv: { - patches = drv.patches or [] ++ [ - (fetchpatch { - # awaiting release >0.5.0.0 - url = "https://github.com/fpco/inline-c/commit/e176b8e8c3c94e7d8289a8b7cc4ce8e737741730.patch"; - name = "inline-c-cpp-pr-132-1.patch"; - sha256 = "sha256-CdZXAT3Ar4KKDGyAUu8A7hzddKe5/AuMKoZSjt3o0UE="; - stripLen = 1; - }) - ]; postPatch = (drv.postPatch or "") + '' substituteInPlace inline-c-cpp.cabal --replace "-optc-std=c++11" "" ''; @@ -409,22 +479,6 @@ self: super: { # 2022-02-14: Strict upper bound: https://github.com/psibi/streamly-bytestring/issues/30 streamly-bytestring = dontCheck (doJailbreak super.streamly-bytestring); - # The package requires streamly == 0.9.*. - # (We can remove this once the assert starts failing.) - streamly-archive = super.streamly-archive.override { - streamly = - assert (builtins.compareVersions pkgs.haskellPackages.streamly.version "0.9.0" < 0); - pkgs.haskellPackages.streamly_0_9_0; - }; - - # The package requires streamly == 0.9.*. - # (We can remove this once the assert starts failing.) - streamly-lmdb = super.streamly-lmdb.override { - streamly = - assert (builtins.compareVersions pkgs.haskellPackages.streamly.version "0.9.0" < 0); - self.streamly_0_9_0; - }; - # base bound digit = doJailbreak super.digit; @@ -442,10 +496,15 @@ self: super: { # 2020-06-05: HACK: does not pass own build suite - `dontCheck` # 2022-11-24: jailbreak as it has too strict bounds on a bunch of things - hnix = self.generateOptparseApplicativeCompletions [ "hnix" ] (dontCheck (doJailbreak super.hnix)); + # 2023-07-26: Cherry-pick GHC 9.4 changes from hnix master branch + hnix = appendPatches [ + ./patches/hnix-compat-for-ghc-9.4.patch + ] (dontCheck (doJailbreak super.hnix)); + # Too strict bounds on algebraic-graphs and bytestring # https://github.com/haskell-nix/hnix-store/issues/180 hnix-store-core = doJailbreak super.hnix-store-core; + hnix-store-core_0_6_1_0 = doDistribute (doJailbreak super.hnix-store-core_0_6_1_0); # Fails for non-obvious reasons while attempting to use doctest. focuslist = dontCheck super.focuslist; @@ -455,14 +514,17 @@ self: super: { opencv = dontCheck (appendPatch ./patches/opencv-fix-116.patch super.opencv); opencv-extra = dontCheck (appendPatch ./patches/opencv-fix-116.patch super.opencv-extra); - # Too strict lower bound on hspec - graphql = - assert lib.versionOlder self.hspec.version "2.10"; - doJailbreak super.graphql; - # https://github.com/ekmett/structures/issues/3 structures = dontCheck super.structures; + jacinda = appendPatches [ + (pkgs.fetchpatch { + name = "jacinda-alex-3.3.patch"; + url = "https://github.com/vmchale/jacinda/commit/b8e18871900402e6ab0addae2e41a0f360682ae3.patch"; + sha256 = "0c1b9hp9j44zafzjidp301dz0m54vplgfisqvb1zrh1plk6vsxsa"; + }) + ] (overrideCabal { revision = null; editedCabalFile = null; } super.jacinda); + # Disable test suites to fix the build. acme-year = dontCheck super.acme-year; # http://hydra.cryp.to/build/497858/log/raw aeson-lens = dontCheck super.aeson-lens; # http://hydra.cryp.to/build/496769/log/raw @@ -726,11 +788,6 @@ self: super: { # else dontCheck super.doctest-discover); doctest-discover = dontCheck super.doctest-discover; - # Test suite is missing an import from hspec - # https://github.com/haskell-works/tasty-discover/issues/9 - # https://github.com/commercialhaskell/stackage/issues/6584#issuecomment-1326522815 - tasty-discover = assert super.tasty-discover.version == "4.2.2"; dontCheck super.tasty-discover; - # Too strict lower bound on tasty-hedgehog # https://github.com/qfpl/tasty-hedgehog/issues/70 tasty-sugar = doJailbreak super.tasty-sugar; @@ -799,6 +856,9 @@ self: super: { elm-server = markBroken super.elm-server; elm-yesod = markBroken super.elm-yesod; + # Tests failure with GHC >= 9.0.1, fixed in 1.6.24.4 + yesod-core = assert super.yesod-core.version == "1.6.24.3"; dontCheck super.yesod-core; + # https://github.com/Euterpea/Euterpea2/issues/40 Euterpea = doJailbreak super.Euterpea; @@ -1023,20 +1083,12 @@ self: super: { restless-git = dontCheck super.restless-git; # requires git at test-time *and* runtime, but we'll just rely on users to - # bring their own git at runtime + # bring their own git at runtime. Additionally, sensei passes `-package + # hspec-meta` to GHC in the tests, but doesn't depend on it itself. sensei = overrideCabal (drv: { - testHaskellDepends = drv.testHaskellDepends or [] ++ [ self.hspec-meta_2_10_5 ]; + testHaskellDepends = drv.testHaskellDepends or [] ++ [ self.hspec-meta ]; testToolDepends = drv.testToolDepends or [] ++ [ pkgs.git ]; - }) (super.sensei.override { - hspec = self.hspec_2_11_1; - hspec-wai = self.hspec-wai.override { - hspec = self.hspec_2_11_1; - }; - hspec-contrib = self.hspec-contrib.override { - hspec-core = self.hspec-core_2_11_1; - }; - fsnotify = self.fsnotify_0_4_1_0; - }); + }) super.sensei; # Depends on broken fluid. fluid-idl-http-client = markBroken super.fluid-idl-http-client; @@ -1084,15 +1136,16 @@ self: super: { # jailbreak tasty < 1.2 until servant-docs > 0.11.3 is on hackage. snap-templates = doJailbreak super.snap-templates; # https://github.com/snapframework/snap-templates/issues/22 - # https://github.com/haskell-hvr/resolv/pull/6 - resolv_0_1_1_2 = dontCheck super.resolv_0_1_1_2; - # The test suite does not know how to find the 'alex' binary. alex = overrideCabal (drv: { testSystemDepends = (drv.testSystemDepends or []) ++ [pkgs.which]; preCheck = ''export PATH="$PWD/dist/build/alex:$PATH"''; }) super.alex; + # 2023-07-14: Restrictive upper bounds: https://github.com/luke-clifton/shh/issues/76 + shh = doJailbreak super.shh; + shh-extras = doJailbreak super.shh-extras; + # This package refers to the wrong library (itself in fact!) vulkan = super.vulkan.override { vulkan = pkgs.vulkan-loader; }; @@ -1144,17 +1197,33 @@ self: super: { }) super.dhall-nixpkgs); stack = - self.generateOptparseApplicativeCompletions - [ "stack" ] - (super.stack.override { - # stack needs to use an exact hpack version. When changing or removing - # this override, double-check the upstream stack release to confirm - # that we are using the correct hpack version. See - # https://github.com/NixOS/nixpkgs/issues/223390 for more information. - # - # hpack tests fail because of https://github.com/sol/hpack/issues/528 - hpack = dontCheck self.hpack_0_35_0; - }); + lib.pipe + super.stack + [ + (self.generateOptparseApplicativeCompletions [ "stack" ]) + + # Seems to be an unnecessarily strict dep on ansi-terminal + doJailbreak + + # The below patch has unix line endings, but the actual file + # has CRLF line endings. The following override changes the + # file to unix line endings before applying the patch. + (overrideCabal (oldAttrs: { + prePatch = oldAttrs.prePatch or "" + '' + "${lib.getBin pkgs.buildPackages.dos2unix}/bin/dos2unix" src/main/BuildInfo.hs + ''; + })) + # stack-2.11.1 has a bug when building without git. + # https://github.com/commercialhaskell/stack/pull/6127 + (appendPatch + (fetchpatch { + name = "stack-fix-building-without-git.patch"; + url = "https://github.com/commercialhaskell/stack/pull/6127/commits/086f93933d547736a7007fc4110f7816ef21f691.patch"; + hash = "sha256-1nwzMoumWceVu8RNnH2mmSxYT24G1FAnFRJvUMeD3po="; + includes = [ "src/main/BuildInfo.hs" ]; + }) + ) + ]; # Too strict version bound on hashable-time. # Tests require newer package version. @@ -1288,6 +1357,10 @@ self: super: { # https://github.com/erikd/hjsmin/issues/32 hjsmin = dontCheck super.hjsmin; + # too strict bounds on text in the test suite + # https://github.com/audreyt/string-qq/pull/3 + string-qq = doJailbreak super.string-qq; + # Remove for hail > 0.2.0.0 hail = overrideCabal (drv: { patches = [ @@ -1348,17 +1421,6 @@ self: super: { Cabal-syntax = self.Cabal-syntax_3_10_1_0; })); - # 2022-03-12: Pick patches from master for compat with Stackage Nightly - # 2022-12-07: Lift bounds to allow dependencies shipped with LTS-20 - # https://github.com/jgm/gitit/pull/683 - gitit = appendPatches [ - (fetchpatch { - name = "gitit-fix-build-with-hoauth2-2.3.0.patch"; - url = "https://github.com/jgm/gitit/commit/fd534c0155eef1790500c834e612ab22cf9b67b6.patch"; - sha256 = "0hmlqkavn8hr0b4y4hxs1yyg0r79ylkzhzwy1dzbb3a2q86ydd2f"; - }) - ] (doJailbreak super.gitit); - # Test suite requires database persistent-mysql = dontCheck super.persistent-mysql; persistent-postgresql = @@ -1409,7 +1471,6 @@ self: super: { }); }; - # 2023-06-24: too strict upper bound on bytestring jsaddle-webkit2gtk = appendPatches [ (pkgs.fetchpatch { @@ -1426,7 +1487,14 @@ self: super: { stripLen = 1; includes = [ "jsaddle-webkit2gtk.cabal" ]; }) - ] super.jsaddle-webkit2gtk; + ] + (overrideCabal (old: { + postPatch = old.postPatch or "" + '' + sed -i 's/aeson.*,/aeson,/' jsaddle-webkit2gtk.cabal + sed -i 's/text.*,/text,/' jsaddle-webkit2gtk.cabal + ''; + }) + super.jsaddle-webkit2gtk); # 2022-03-16: lens bound can be loosened https://github.com/ghcjs/jsaddle-dom/issues/19 jsaddle-dom = overrideCabal (old: { @@ -1440,6 +1508,8 @@ self: super: { reflex-dom-core = overrideCabal (old: { postPatch = old.postPatch or "" + '' sed -i 's/template-haskell.*2.17/template-haskell/' reflex-dom-core.cabal + sed -i 's/semialign.*1.3/semialign/' reflex-dom-core.cabal + sed -i 's/these.*0.9/these/' reflex-dom-core.cabal ''; }) ((appendPatches [ @@ -1592,7 +1662,6 @@ self: super: { # Also, we need QuickCheck-2.14.x to build the test suite, which isn't easy in LTS-16.x. # So let's not go there and just disable the tests altogether. hspec-core = dontCheck super.hspec-core; - hspec-core_2_7_10 = doDistribute (dontCheck super.hspec-core_2_7_10); # tests seem to require a different version of hspec-core hspec-contrib = dontCheck super.hspec-contrib; @@ -1665,18 +1734,20 @@ self: super: { servant-openapi3 = dontCheck super.servant-openapi3; # Give latest hspec correct dependency versions without overrideScope - hspec_2_11_1 = doDistribute (super.hspec_2_11_1.override { - hspec-discover = self.hspec-discover_2_11_1; - hspec-core = self.hspec-core_2_11_1; + hspec_2_11_4 = doDistribute (super.hspec_2_11_4.override { + hspec-discover = self.hspec-discover_2_11_4; + hspec-core = self.hspec-core_2_11_4; }); - hspec-discover_2_11_1 = doDistribute (super.hspec-discover_2_11_1.override { - hspec-meta = self.hspec-meta_2_10_5; + hspec-meta_2_11_4 = doDistribute (super.hspec-meta_2_11_4.override { + hspec-expectations = self.hspec-expectations_0_8_4; }); - # Need to disable tests to prevent an infinite recursion if hspec-core_2_11_1 + hspec-discover_2_11_4 = doDistribute (super.hspec-discover_2_11_4.override { + hspec-meta = self.hspec-meta_2_11_4; + }); + # Need to disable tests to prevent an infinite recursion if hspec-core_2_11_4 # is overlayed to hspec-core. - hspec-core_2_11_1 = doDistribute (dontCheck (super.hspec-core_2_11_1.override { - hspec-meta = self.hspec-meta_2_10_5; - hspec-expectations = self.hspec-expectations_0_8_3; + hspec-core_2_11_4 = doDistribute (dontCheck (super.hspec-core_2_11_4.override { + hspec-expectations = self.hspec-expectations_0_8_4; })); # Point hspec 2.7.10 to correct dependencies @@ -1684,23 +1755,15 @@ self: super: { hspec-discover = self.hspec-discover_2_7_10; hspec-core = self.hspec-core_2_7_10; }; + hspec-discover_2_7_10 = super.hspec-discover_2_7_10.override { + hspec-meta = self.hspec-meta_2_7_8; + }; + hspec-core_2_7_10 = doJailbreak (dontCheck super.hspec-core_2_7_10); # waiting for aeson bump servant-swagger-ui-core = doJailbreak super.servant-swagger-ui-core; - hercules-ci-agent = lib.pipe super.hercules-ci-agent [ - (appendPatches [ - # https://github.com/hercules-ci/hercules-ci-agent/pull/507 - (fetchpatch { - url = "https://github.com/hercules-ci/hercules-ci-agent/commit/f5c39d0cbde36a056419cab8d69a67302eb8b0e4.patch"; - sha256 = "sha256-J8N4+HUQ6vlJBCwCyxv8Fv5HSbtiim64Qh1n9CaRe1o="; - stripLen = 1; - }) - # https://github.com/hercules-ci/hercules-ci-agent/pull/526 - ./patches/hercules-ci-agent-cachix-1.6.patch - ]) - (self.generateOptparseApplicativeCompletions [ "hercules-ci-agent" ]) - ]; + hercules-ci-agent = self.generateOptparseApplicativeCompletions [ "hercules-ci-agent" ] super.hercules-ci-agent; # Test suite doesn't compile with aeson 2.0 # https://github.com/hercules-ci/hercules-ci-agent/pull/387 @@ -1767,6 +1830,10 @@ self: super: { # 2020-12-06: Restrictive upper bounds w.r.t. pandoc-types (https://github.com/owickstrom/pandoc-include-code/issues/27) pandoc-include-code = doJailbreak super.pandoc-include-code; + # 2023-07-08: Restrictive upper bounds on text: https://github.com/owickstrom/pandoc-emphasize-code/pull/14 + # 2023-07-08: Missing test dependency: https://github.com/owickstrom/pandoc-emphasize-code/pull/13 + pandoc-emphasize-code = dontCheck (doJailbreak super.pandoc-emphasize-code); + # DerivingVia is not allowed in safe Haskell # https://github.com/strake/util.hs/issues/1 util = appendConfigureFlags [ @@ -1839,6 +1906,64 @@ self: super: { # https://github.com/jgm/pandoc/issues/7163 pandoc = dontCheck super.pandoc; + # Since pandoc-3, the actual `pandoc` executable is in the pandoc-cli + # package. It is no longer distributed in the pandoc package itself. So for + # people that want to use the `pandoc` cli tool, they must use pandoc-cli. + # + # The unfortunate thing is that LTS-21 includes no possible build plan for + # pandoc-cli, because pandoc-cli pandoc-lua-engine are not in LTS 21. + # To get pandoc-lua-engine building we need either to downgrade a ton + # of hslua-module-* packages from stackage or use pandoc 3.1 although + # LTS contains pandoc 3.0. + inherit (let + pandoc-cli-overlay = self: super: { + # pandoc-cli requires pandoc >= 3.1 + pandoc = self.pandoc_3_1_6; + + # pandoc depends on crypton-connection, which requires tls >= 1.7 + tls = self.tls_1_7_0; + crypton-connection = unmarkBroken super.crypton-connection; + + # pandoc depends on http-client-tls, which only starts depending + # on crypton-connection in http-client-tls-0.3.6.2. + http-client-tls = self.http-client-tls_0_3_6_2; + + # pandoc and skylighting are developed in tandem + skylighting-core = self.skylighting-core_0_13_4_1; + skylighting = self.skylighting_0_13_4_1; + }; + in { + pandoc-cli = super.pandoc-cli.overrideScope pandoc-cli-overlay; + pandoc_3_1_6 = doDistribute (super.pandoc_3_1_6.overrideScope pandoc-cli-overlay); + pandoc-lua-engine = super.pandoc-lua-engine.overrideScope pandoc-cli-overlay; + }) + pandoc-cli + pandoc_3_1_6 + pandoc-lua-engine + ; + + crypton-x509 = + lib.pipe + super.crypton-x509 + [ + # Mistype in a dependency in a test. + # https://github.com/kazu-yamamoto/crypton-certificate/pull/3 + (appendPatch + (fetchpatch { + name = "crypton-x509-rename-dep.patch"; + url = "https://github.com/kazu-yamamoto/crypton-certificate/commit/5281ff115a18621407b41f9560fd6cd65c602fcc.patch"; + hash = "sha256-pLzuq+baSDn+MWhtYIIBOrE1Js+tp3UsaEZy5MhWAjY="; + relative = "x509"; + }) + ) + # There is a revision in crypton-x509, so the above patch won't + # apply because of line endings in revised .cabal files. + (overrideCabal { + editedCabalFile = null; + revision = null; + }) + ]; + # * doctests don't work without cabal # https://github.com/noinia/hgeometry/issues/132 # * Too strict version bound on vector-builder @@ -1964,6 +2089,10 @@ self: super: { # https://github.com/obsidiansystems/database-id/issues/1 database-id-class = doJailbreak super.database-id-class; + # https://github.com/softwarefactory-project/matrix-client-haskell/issues/36 + # Restrictive bounds on aeson + matrix-client = doJailbreak super.matrix-client; + cabal2nix-unstable = overrideCabal { passthru = { updateScript = ../../../maintainers/scripts/haskell/update-cabal2nix-unstable.sh; @@ -2015,15 +2144,25 @@ self: super: { }) (dontCheck super.yi-language); # 2022-03-16: Upstream is not bumping bounds https://github.com/ghcjs/jsaddle/issues/123 - jsaddle = overrideCabal (drv: { + # 2023-07-14: Upstream is also not releasing fixes. + jsaddle = appendPatch + (fetchpatch { + name = "jsaddle-casemapping.patch"; + url = "https://github.com/ghcjs/jsaddle/commit/f90df85fec84fcc4927bfb67452e31342f5aec1f.patch"; + sha256 = "sha256-xCtDxpjZbus8VSeBUEV0OnJlcQKjeL1PbYSHnhpFuyI="; + relative = "jsaddle"; + }) + (overrideCabal (drv: { # lift conditional version constraint on ref-tf postPatch = '' sed -i 's/ref-tf.*,/ref-tf,/' jsaddle.cabal sed -i 's/attoparsec.*,/attoparsec,/' jsaddle.cabal sed -i 's/time.*,/time,/' jsaddle.cabal + sed -i 's/vector.*,/vector,/' jsaddle.cabal sed -i 's/(!name)/(! name)/' src/Language/Javascript/JSaddle/Object.hs '' + (drv.postPatch or ""); - }) (doJailbreak super.jsaddle); + }) + (doJailbreak super.jsaddle)); # 2022-03-22: Jailbreak for base bound: https://github.com/reflex-frp/reflex-dom/pull/433 reflex-dom = assert super.reflex-dom.version == "0.6.1.1"; doJailbreak super.reflex-dom; @@ -2076,9 +2215,10 @@ self: super: { gi-gtk-declarative-app-simple = doJailbreak super.gi-gtk-declarative-app-simple; # 2023-04-09: haskell-ci needs Cabal-syntax 3.10 - haskell-ci = super.haskell-ci.overrideScope (self: super: { + # 2023-07-03: allow lattices-2.2, waiting on https://github.com/haskell-CI/haskell-ci/pull/664 + haskell-ci = doJailbreak (super.haskell-ci.overrideScope (self: super: { Cabal-syntax = self.Cabal-syntax_3_10_1_0; - }); + })); large-hashable = lib.pipe (super.large-hashable.override { # https://github.com/factisresearch/large-hashable/commit/5ec9d2c7233fc4445303564047c992b693e1155c @@ -2110,6 +2250,12 @@ self: super: { "-n" "^Data.LargeHashable.Tests.Inspection:genericSumGetsOptimized$" ]; })) + # https://github.com/factisresearch/large-hashable/issues/25 + # Currently broken with text >= 2.0 + (overrideCabal (lib.optionalAttrs (lib.versionAtLeast self.ghc.version "9.4") { + broken = true; + hydraPlatforms = []; + })) ]; # BSON defaults to requiring network instead of network-bsd which is @@ -2153,11 +2299,6 @@ self: super: { sha256 = "0l15ccfdys100jf50s9rr4p0d0ikn53bkh7a9qlk9i0y0z5jc6x1"; }) super.basic-cpuid; - # Needs Cabal >= 3.4 - chs-cabal = super.chs-cabal.override { - Cabal = self.Cabal_3_6_3_0; - }; - # 2021-08-18: streamly-posix was released with hspec 2.8.2, but it works with older versions too. streamly-posix = doJailbreak super.streamly-posix; @@ -2318,19 +2459,26 @@ self: super: { # The shipped Setup.hs file is broken. csv = overrideCabal (drv: { preCompileBuildDriver = "rm Setup.hs"; }) super.csv; + # Build-type is simple, but ships a broken Setup.hs + digits = overrideCabal (drv: { preCompileBuildDriver = "rm Setup.lhs"; }) super.digits; cabal-fmt = doJailbreak (super.cabal-fmt.override { # Needs newer Cabal-syntax version. - Cabal-syntax = self.Cabal-syntax_3_8_1_0; + Cabal-syntax = self.Cabal-syntax_3_10_1_0; }); - # Tests require ghc-9.2. - ema = dontCheck super.ema; + # 2023-07-18: https://github.com/srid/ema/issues/156 + ema = doJailbreak super.ema; glirc = doJailbreak (super.glirc.override { vty = self.vty_5_35_1; }); + # Too strict bounds on text and tls + # https://github.com/barrucadu/irc-conduit/issues/54 + irc-conduit = doJailbreak super.irc-conduit; + irc-client = doJailbreak super.irc-client; + # 2022-02-25: Unmaintained and to strict upper bounds paths = doJailbreak super.paths; @@ -2349,7 +2497,8 @@ self: super: { sed -i 's/import "jsaddle-dom" GHCJS.DOM.Document/import "ghcjs-dom-jsaddle" GHCJS.DOM.Document/' src/GHCJS/DOM/Document.hs '' + (old.postPatch or ""); }) - super.ghcjs-dom; + # 2023-07-15: Restrictive upper bounds on text + (doJailbreak super.ghcjs-dom); # Too strict bounds on chell: https://github.com/fpco/haskell-filesystem/issues/24 system-fileio = doJailbreak super.system-fileio; @@ -2413,8 +2562,11 @@ self: super: { # has been resolved. lucid-htmx = doJailbreak super.lucid-htmx; - # 2022-09-20: Restrictive upper bound on lsp - futhark = doJailbreak super.futhark; + # Needs lsp >= 2.1 + futhark = super.futhark.overrideScope (fself: _: { + lsp = fself.lsp_2_1_0_0; + lsp-types = fself.lsp-types_2_0_1_0; + }); # Too strict bounds on hspec # https://github.com/klapaucius/vector-hashtables/issues/11 @@ -2425,10 +2577,6 @@ self: super: { doctest-parallel = dontCheck super.doctest-parallel; clash-prelude = dontCheck super.clash-prelude; - # Too strict upper bound on th-desugar, fixed in 3.1.1 - singletons-th = assert super.singletons-th.version == "3.1"; doJailbreak super.singletons-th; - singletons-base = doJailbreak super.singletons-base; - # Ships a broken Setup.hs # https://github.com/lehins/conduit-aeson/issues/1 conduit-aeson = overrideCabal (drv: { @@ -2440,6 +2588,10 @@ self: super: { testTarget = "tests"; }) super.conduit-aeson; + # Upper bounds are too strict: + # https://github.com/velveteer/hermes/pull/22 + hermes-json = doJailbreak super.hermes-json; + # Disabling doctests. regex-tdfa = overrideCabal { testTarget = "regex-tdfa-unittest"; @@ -2459,7 +2611,7 @@ self: super: { (let # We need to build purescript with these dependencies and thus also its reverse # dependencies to avoid version mismatches in their dependency closure. - # TODO(@cdepillabout): maybe unify with the spago overlay in configuration-nix.nix? + # TODO: maybe unify with the spago overlay in configuration-nix.nix? purescriptOverlay = self: super: { # As of 2021-11-08, the latest release of `language-javascript` is 0.7.1.0, # but it has a problem with parsing the `async` keyword. It doesn't allow @@ -2493,11 +2645,8 @@ self: super: { # 2022-11-05: https://github.com/ysangkok/haskell-tzdata/issues/3 tzdata = dontCheck super.tzdata; - # 2022-11-15: Needs newer witch package and brick 1.3 which in turn works with text-zipper 0.12 - # Other dependencies are resolved with doJailbreak for both swarm and brick_1_3 - swarm = doJailbreak (super.swarm.override { - brick = doJailbreak (dontCheck super.brick_1_9); - }); + # We provide newer dependencies than upstream expects. + swarm = doJailbreak super.swarm; # Too strict upper bound on bytestring # https://github.com/TravisWhitaker/rdf/issues/8 @@ -2565,11 +2714,6 @@ self: super: { # https://github.com/tweag/webauthn/issues/166 webauthn = dontCheck super.webauthn; - # Too strict lower bound on hspec - wai-token-bucket-ratelimiter = - assert lib.versionOlder self.hspec.version "2.10"; - doJailbreak super.wai-token-bucket-ratelimiter; - # doctest <0.19 polysemy = doJailbreak super.polysemy; @@ -2624,11 +2768,6 @@ self: super: { # Get rid of this in the next release: https://github.com/kowainik/tomland/commit/37f16460a6dfe4606d48b8b86c13635d409442cd tomland = doJailbreak super.tomland; - # 2023-04-05: The last version to support libsoup-2.4, required for - # compatibility with other gi- packages. - # Take another look when gi-webkit2 updates as it may have become compatible with libsoup-3 - gi-soup = assert versions.major self.gi-webkit2.version == "4"; self.gi-soup_2_4_28; - llvm-ffi = super.llvm-ffi.override { LLVM = pkgs.llvmPackages_13.libllvm; }; @@ -2638,7 +2777,7 @@ self: super: { # Tests fail due to the newly-build fourmolu not being in PATH # https://github.com/fourmolu/fourmolu/issues/231 - fourmolu_0_13_0_0 = dontCheck (super.fourmolu_0_13_0_0.overrideScope (lself: lsuper: { + fourmolu_0_13_1_0 = dontCheck (super.fourmolu_0_13_1_0.overrideScope (lself: lsuper: { Cabal-syntax = lself.Cabal-syntax_3_10_1_0; ghc-lib-parser = lself.ghc-lib-parser_9_6_2_20230523; parsec = lself.parsec_3_1_16_1; @@ -2656,4 +2795,7 @@ self: super: { # Flaky QuickCheck tests # https://github.com/Haskell-Things/ImplicitCAD/issues/441 implicit = dontCheck super.implicit; + + # The hackage source is somehow missing a file present in the repo (tests/ListStat.hs). + sym = dontCheck super.sym; } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super diff --git a/pkgs/development/haskell-modules/configuration-darwin.nix b/pkgs/development/haskell-modules/configuration-darwin.nix index b800debe15ee..227e90e10588 100644 --- a/pkgs/development/haskell-modules/configuration-darwin.nix +++ b/pkgs/development/haskell-modules/configuration-darwin.nix @@ -301,6 +301,15 @@ self: super: ({ '' + drv.postPatch or ""; }) super.foldl; + # https://hydra.nixos.org/build/230964714/nixlog/1 + inline-c-cpp = appendPatch (pkgs.fetchpatch { + url = "https://github.com/fpco/inline-c/commit/e8dc553b13bb847409fdced649a6a863323cff8a.patch"; + name = "revert-use-system-cxx-std-lib.patch"; + sha256 = "sha256-ql1/+8bvmWexyCdFR0VS4M4cY2lD0Px/9dHYLqlKyNA="; + revert = true; + stripLen = 1; + }) super.inline-c-cpp; + } // lib.optionalAttrs pkgs.stdenv.isAarch64 { # aarch64-darwin # https://github.com/fpco/unliftio/issues/87 diff --git a/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix b/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix index fac983969de3..4bf89ec4ea31 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-8.10.x.nix @@ -46,18 +46,27 @@ self: super: { unix = null; # GHC only bundles the xhtml library if haddock is enabled, check if this is # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463 - xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1; + xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_3_0_0; + + # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work + Cabal-syntax = self.Cabal-syntax_3_6_0_0; + # These core package only exist for GHC >= 9.4. The best we can do is feign + # their existence to callPackages, but their is no shim for lower GHC versions. + system-cxx-std-lib = null; # Additionally depends on OneTuple for GHC < 9.0 base-compat-batteries = addBuildDepend self.OneTuple super.base-compat-batteries; + # For GHC < 9.4, some packages need data-array-byte as an extra dependency + primitive = addBuildDepends [ self.data-array-byte ] super.primitive; + hashable = addBuildDepends [ + self.data-array-byte + self.base-orphans + ] super.hashable; + # Pick right versions for GHC-specific packages ghc-api-compat = doDistribute (unmarkBroken self.ghc-api-compat_8_10_7); - # ghc versions which don’t match the ghc-lib-parser-ex version need the - # additional dependency to compile successfully. - ghc-lib-parser-ex = addBuildDepend self.ghc-lib-parser super.ghc-lib-parser-ex; - # Needs to use ghc-lib due to incompatible GHC ghc-tags = doDistribute (addBuildDepend self.ghc-lib self.ghc-tags_1_5); @@ -102,10 +111,23 @@ self: super: { in addBuildDepends additionalDeps (super.haskell-language-server.overrideScope (lself: lsuper: { Cabal = lself.Cabal_3_6_3_0; aeson = lself.aeson_1_5_6_0; - lens-aeson = lself.lens-aeson_1_1_3; + lens-aeson = doJailbreak lself.lens-aeson_1_1_3; lsp-types = doJailbreak lsuper.lsp-types; # Checks require aeson >= 2.0 + hls-overloaded-record-dot-plugin = null; })); + ghc-lib-parser = doDistribute self.ghc-lib-parser_9_2_7_20230228; + ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_2_1_1; + ghc-lib = doDistribute self.ghc-lib_9_2_7_20230228; + + mod = super.mod_0_1_2_2; + path-io = doJailbreak super.path-io; + + ormolu = self.ormolu_0_5_0_1; + fourmolu = dontCheck self.fourmolu_0_9_0_0; + hlint = self.hlint_3_4_1; + stylish-haskell = doJailbreak self.stylish-haskell_0_14_3_0; + hls-tactics-plugin = unmarkBroken (addBuildDepends (with self.hls-tactics-plugin.scope; [ aeson extra fingertree generic-lens ghc-exactprint ghc-source-gen ghcide hls-graph hls-plugin-api hls-refactor-plugin hyphenation lens lsp megaparsec @@ -129,15 +151,21 @@ self: super: { mime-string = disableOptimization super.mime-string; - # weeder 2.3.0 no longer supports GHC 8.10 + # weeder 2.3.* no longer supports GHC 8.10 weeder = doDistribute (doJailbreak self.weeder_2_2_0); + # Unnecessarily strict upper bound on lens + weeder_2_2_0 = doJailbreak (super.weeder_2_2_0.override { + # weeder < 2.6 only supports algebraic-graphs < 0.7 + # We no longer have matching test deps for algebraic-graphs 0.6.1 in the set + algebraic-graphs = dontCheck self.algebraic-graphs_0_6_1; + }); - # OneTuple needs hashable instead of ghc-prim for GHC < 9 - OneTuple = super.OneTuple.override { + # OneTuple needs hashable (instead of ghc-prim) and foldable1-classes-compat for GHC < 9 + OneTuple = addBuildDepends [ + self.foldable1-classes-compat + ] (super.OneTuple.override { ghc-prim = self.hashable; - }; - - hashable = addBuildDepend self.base-orphans super.hashable; + }); # Doesn't build with 9.0, see https://github.com/yi-editor/yi/issues/1125 yi-core = doDistribute (markUnbroken super.yi-core); @@ -180,4 +208,7 @@ self: super: { # Needs OneTuple for ghc < 9.2 binary-orphans = addBuildDepends [ self.OneTuple ] super.binary-orphans; + + # Requires GHC < 9.4 + ghc-source-gen = doDistribute (unmarkBroken super.ghc-source-gen); } diff --git a/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix b/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix index 9b4abe34908f..7cd010e22d9c 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-8.6.x.nix @@ -45,10 +45,13 @@ self: super: { unix = null; # GHC only bundles the xhtml library if haddock is enabled, check if this is # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463 - xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1; + xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_3_0_0; + + # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work + Cabal-syntax = self.Cabal-syntax_3_6_0_0; # Needs Cabal 3.0.x. - jailbreak-cabal = super.jailbreak-cabal.override { Cabal = self.Cabal_3_2_1_0; }; + jailbreak-cabal = super.jailbreak-cabal.overrideScope (cself: _: { Cabal = cself.Cabal_3_2_1_0; }); # https://github.com/tibbe/unordered-containers/issues/214 unordered-containers = dontCheck super.unordered-containers; @@ -66,7 +69,6 @@ self: super: { unicode-transforms = dontCheck super.unicode-transforms; wl-pprint-extras = doJailbreak super.wl-pprint-extras; # containers >=0.4 && <0.6 is too tight; https://github.com/ekmett/wl-pprint-extras/issues/17 RSA = dontCheck super.RSA; # https://github.com/GaloisInc/RSA/issues/14 - monad-par = dontCheck super.monad-par; # https://github.com/simonmar/monad-par/issues/66 github = dontCheck super.github; # hspec upper bound exceeded; https://github.com/phadej/github/pull/341 binary-orphans = dontCheck super.binary-orphans; # tasty upper bound exceeded; https://github.com/phadej/binary-orphans/commit/8ce857226595dd520236ff4c51fa1a45d8387b33 rebase = doJailbreak super.rebase; # time ==1.9.* is too low @@ -74,12 +76,6 @@ self: super: { # https://github.com/jgm/skylighting/issues/55 skylighting-core = dontCheck super.skylighting-core; - # Break out of "yaml >=0.10.4.0 && <0.11": https://github.com/commercialhaskell/stack/issues/4485 - stack = doJailbreak super.stack; - - # Newer versions don't compile. - resolv = self.resolv_0_1_1_2; - # cabal2nix needs the latest version of Cabal, and the one # hackage-db uses must match, so take the latest cabal2nix = super.cabal2nix.overrideScope (self: super: { Cabal = self.Cabal_3_2_1_0; }); diff --git a/pkgs/development/haskell-modules/configuration-ghc-8.8.x.nix b/pkgs/development/haskell-modules/configuration-ghc-8.8.x.nix index 01cb34881516..207697356f97 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-8.8.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-8.8.x.nix @@ -45,7 +45,13 @@ self: super: { unix = null; # GHC only bundles the xhtml library if haddock is enabled, check if this is # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463 - xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1; + xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_3_0_0; + # These core package only exist for GHC >= 9.4. The best we can do is feign + # their existence to callPackages, but their is no shim for lower GHC versions. + system-cxx-std-lib = null; + + # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work + Cabal-syntax = self.Cabal-syntax_3_6_0_0; # GHC 8.8.x can build haddock version 2.23.* haddock = self.haddock_2_23_1; @@ -57,6 +63,13 @@ self: super: { # Additionally depends on OneTuple for GHC < 9.0 base-compat-batteries = addBuildDepend self.OneTuple super.base-compat-batteries; + # For GHC < 9.4, some packages need data-array-byte as an extra dependency + primitive = addBuildDepends [ self.data-array-byte ] super.primitive; + hashable = addBuildDepends [ + self.data-array-byte + self.base-orphans + ] super.hashable; + # Ignore overly restrictive upper version bounds. aeson-diff = doJailbreak super.aeson-diff; async = doJailbreak super.async; @@ -64,7 +77,6 @@ self: super: { chell = doJailbreak super.chell; Diff = dontCheck super.Diff; doctest = doJailbreak super.doctest; - hashable = addBuildDepend self.base-orphans super.hashable; hashable-time = doJailbreak super.hashable-time; hledger-lib = doJailbreak super.hledger-lib; # base >=4.8 && <4.13, easytest >=0.2.1 && <0.3 integer-logarithms = doJailbreak super.integer-logarithms; @@ -136,10 +148,12 @@ self: super: { # has a restrictive lower bound on Cabal fourmolu = doJailbreak super.fourmolu; - # OneTuple needs hashable instead of ghc-prim for GHC < 9 - OneTuple = super.OneTuple.override { + # OneTuple needs hashable (instead of ghc-prim) and foldable1-classes-compat for GHC < 9 + OneTuple = addBuildDepends [ + self.foldable1-classes-compat + ] (super.OneTuple.override { ghc-prim = self.hashable; - }; + }); # Temporarily disabled blaze-textual for GHC >= 9.0 causing hackage2nix ignoring it # https://github.com/paul-rouse/mysql-simple/blob/872604f87044ff6d1a240d9819a16c2bdf4ed8f5/Database/MySQL/Internal/Blaze.hs#L4-L10 @@ -166,4 +180,7 @@ self: super: { # Later versions only support GHC >= 9.2 ghc-exactprint = self.ghc-exactprint_0_6_4; apply-refact = self.apply-refact_0_9_3_0; + + # Requires GHC < 9.4 + ghc-source-gen = doDistribute (unmarkBroken super.ghc-source-gen); } diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix index 3c59f6b80d66..0e53c1935966 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.0.x.nix @@ -47,45 +47,34 @@ self: super: { unix = null; # GHC only bundles the xhtml library if haddock is enabled, check if this is # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463 - xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1; + xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_3_0_0; + + # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work + Cabal-syntax = self.Cabal-syntax_3_6_0_0; + # These core package only exist for GHC >= 9.4. The best we can do is feign + # their existence to callPackages, but their is no shim for lower GHC versions. + system-cxx-std-lib = null; # Jailbreaks & Version Updates - # This `doJailbreak` can be removed once the following PR is released to Hackage: - # https://github.com/thsutton/aeson-diff/pull/58 - aeson-diff = doJailbreak super.aeson-diff; + # For GHC < 9.4, some packages need data-array-byte as an extra dependency + primitive = addBuildDepends [ self.data-array-byte ] super.primitive; + hashable = addBuildDepends [ + self.data-array-byte + self.base-orphans + ] super.hashable; - async = doJailbreak super.async; - data-fix = doJailbreak super.data-fix; - dec = doJailbreak super.dec; - ed25519 = doJailbreak super.ed25519; - hackage-security = doJailbreak super.hackage-security; - hashable = - pkgs.lib.pipe - super.hashable - [ (overrideCabal (drv: { postPatch = "sed -i -e 's,integer-gmp .*<1.1,integer-gmp < 2,' hashable.cabal"; })) - doJailbreak - dontCheck - (addBuildDepend self.base-orphans) - ]; hashable-time = doJailbreak super.hashable-time; - HTTP = overrideCabal (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; }) (doJailbreak super.HTTP); - integer-logarithms = overrideCabal (drv: { postPatch = "sed -i -e 's,integer-gmp <1.1,integer-gmp < 2,' integer-logarithms.cabal"; }) (doJailbreak super.integer-logarithms); - lukko = doJailbreak super.lukko; - parallel = doJailbreak super.parallel; - primitive = doJailbreak (dontCheck super.primitive); - regex-posix = doJailbreak super.regex-posix; - resolv = doJailbreak super.resolv; - singleton-bool = doJailbreak super.singleton-bool; - split = doJailbreak super.split; - tar = doJailbreak super.tar; - time-compat = doJailbreak super.time-compat; tuple = addBuildDepend self.base-orphans super.tuple; - vector-binary-instances = doJailbreak super.vector-binary-instances; vector-th-unbox = doJailbreak super.vector-th-unbox; - zlib = doJailbreak super.zlib; - # 2021-11-08: Fixed in autoapply-0.4.2 - autoapply = doJailbreak super.autoapply; + + ormolu = self.ormolu_0_5_2_0.override { + Cabal-syntax = self.Cabal-syntax_3_8_1_0; + }; + + fourmolu = self.fourmolu_0_10_1_0.override { + Cabal-syntax = self.Cabal-syntax_3_8_1_0; + }; doctest = dontCheck super.doctest; # Apply patches from head.hackage. @@ -106,6 +95,7 @@ self: super: { # Needed for modern ormolu and fourmolu. # Apply this here and not in common, because other ghc versions offer different Cabal versions. Cabal = lself.Cabal_3_6_3_0; + hls-overloaded-record-dot-plugin = null; })); # Needs to use ghc-lib due to incompatible GHC @@ -123,16 +113,6 @@ self: super: { parser-combinators prettyprinter refinery retrie syb unagi-chan unordered-containers ]) super.hls-tactics-plugin); - # The test suite depends on ChasingBottoms, which is broken with ghc-9.0.x. - unordered-containers = dontCheck super.unordered-containers; - - # The test suite seems pretty broken. - base64-bytestring = dontCheck super.base64-bytestring; - - # GHC 9.0.x doesn't like `import Spec (main)` in Main.hs - # https://github.com/snoyberg/mono-traversable/issues/192 - mono-traversable = dontCheck super.mono-traversable; - # Test suite sometimes segfaults with GHC 9.0.1 and 9.0.2 # https://github.com/ekmett/reflection/issues/51 # https://gitlab.haskell.org/ghc/ghc/-/issues/21141 @@ -162,8 +142,14 @@ self: super: { (if isDarwin then appendConfigureFlags ["--ghc-option=-fcompact-unwind"] else x: x) super.inline-c-cpp; - # 2022-05-31: weeder 2.3.0 requires GHC 9.2 + # 2022-05-31: weeder 2.4.* requires GHC 9.2 weeder = doDistribute self.weeder_2_3_1; + # Unnecessarily strict upper bound on lens + weeder_2_3_1 = doJailbreak (super.weeder_2_3_1.override { + # weeder < 2.6 only supports algebraic-graphs < 0.7 + # We no longer have matching test deps for algebraic-graphs 0.6.1 in the set + algebraic-graphs = dontCheck self.algebraic-graphs_0_6_1; + }); # Restrictive upper bound on base and containers sv2v = doJailbreak super.sv2v; @@ -181,4 +167,7 @@ self: super: { # Needs OneTuple for ghc < 9.2 binary-orphans = addBuildDepends [ self.OneTuple ] super.binary-orphans; + + # Requires GHC < 9.4 + ghc-source-gen = doDistribute (unmarkBroken super.ghc-source-gen); } diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix index 206add606da7..2214a2055f5d 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix @@ -47,10 +47,33 @@ self: super: { unix = null; # GHC only bundles the xhtml library if haddock is enabled, check if this is # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463 - xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1; + xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_3_0_0; - # weeder == 2.5.* requires GHC 9.4 + # Need the Cabal-syntax-3.6.0.0 fake package for Cabal < 3.8 to allow callPackage and the constraint solver to work + Cabal-syntax = self.Cabal-syntax_3_6_0_0; + # These core package only exist for GHC >= 9.4. The best we can do is feign + # their existence to callPackages, but their is no shim for lower GHC versions. + system-cxx-std-lib = null; + + # weeder >= 2.5 requires GHC 9.4 weeder = doDistribute self.weeder_2_4_1; + weeder_2_4_1 = super.weeder_2_4_1.override { + # weeder < 2.6 only supports algebraic-graphs < 0.7 + # We no longer have matching test deps for algebraic-graphs 0.6.1 in the set + algebraic-graphs = dontCheck self.algebraic-graphs_0_6_1; + }; + + ormolu = self.ormolu_0_5_2_0.override { + Cabal-syntax = self.Cabal-syntax_3_8_1_0; + }; + + fourmolu = self.fourmolu_0_10_1_0.override { + Cabal-syntax = self.Cabal-syntax_3_8_1_0; + }; + + # For GHC < 9.4, some packages need data-array-byte as an extra dependency + hashable = addBuildDepends [ self.data-array-byte ] super.hashable; + primitive = addBuildDepends [ self.data-array-byte ] super.primitive; # Jailbreaks & Version Updates hashable-time = doJailbreak super.hashable-time; @@ -75,6 +98,9 @@ self: super: { # For "ghc-lib" flag see https://github.com/haskell/haskell-language-server/issues/3185#issuecomment-1250264515 hlint = enableCabalFlag "ghc-lib" super.hlint; + # 0.2.2.3 requires Cabal >= 3.8 + shake-cabal = doDistribute self.shake-cabal_0_2_2_2; + # https://github.com/sjakobi/bsb-http-chunked/issues/38 bsb-http-chunked = dontCheck super.bsb-http-chunked; @@ -93,4 +119,10 @@ self: super: { inline-c-cpp = (if isDarwin then appendConfigureFlags ["--ghc-option=-fcompact-unwind"] else x: x) super.inline-c-cpp; + + # A given major version of ghc-exactprint only supports one version of GHC. + ghc-exactprint = super.ghc-exactprint_1_5_0; + + # Requires GHC < 9.4 + ghc-source-gen = doDistribute (unmarkBroken super.ghc-source-gen); } diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.4.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.4.x.nix index 4873fff3b3e1..7b9feb98dcba 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.4.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.4.x.nix @@ -53,81 +53,20 @@ in { unix = null; # GHC only bundles the xhtml library if haddock is enabled, check if this is # still the case when updating: https://gitlab.haskell.org/ghc/ghc/-/blob/0198841877f6f04269d6050892b98b5c3807ce4c/ghc.mk#L463 - xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_2_2_1; - - # Tests fail because of typechecking changes - conduit = dontCheck super.conduit; - - # consequences of doctest breakage follow: - - ghc-source-gen = checkAgainAfter super.ghc-source-gen "0.4.3.0" "fails to build" (markBroken super.ghc-source-gen); - - haskell-src-meta = doJailbreak super.haskell-src-meta; - - # Tests fail in GHC 9.2 - extra = dontCheck super.extra; + xhtml = if self.ghc.hasHaddock or true then null else self.xhtml_3000_3_0_0; # Jailbreaks & Version Updates - aeson = doDistribute self.aeson_2_1_2_1; - assoc = doJailbreak super.assoc; - async = doJailbreak super.async; - base64-bytestring = doJailbreak super.base64-bytestring; - binary-instances = doJailbreak super.binary-instances; - ChasingBottoms = doJailbreak super.ChasingBottoms; - constraints = doJailbreak super.constraints; - cpphs = overrideCabal (drv: { postPatch = "sed -i -e 's,time >=1.5 && <1.11,time >=1.5 \\&\\& <1.12,' cpphs.cabal";}) super.cpphs; - data-fix = doJailbreak super.data-fix; - dec = doJailbreak super.dec; - ed25519 = doJailbreak super.ed25519; - ghc-byteorder = doJailbreak super.ghc-byteorder; - ghc-lib = doDistribute self.ghc-lib_9_4_5_20230430; - ghc-lib-parser = doDistribute self.ghc-lib-parser_9_4_5_20230430; - ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_4_0_0; - hackage-security = doJailbreak super.hackage-security; hashable-time = doJailbreak super.hashable-time; - HTTP = overrideCabal (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; }) (doJailbreak super.HTTP); - integer-logarithms = overrideCabal (drv: { postPatch = "sed -i -e 's, <1.1, <1.3,' integer-logarithms.cabal"; }) (doJailbreak super.integer-logarithms); - lifted-async = doJailbreak super.lifted-async; - lukko = doJailbreak super.lukko; - lzma-conduit = doJailbreak super.lzma-conduit; - parallel = doJailbreak super.parallel; - path = doJailbreak super.path; - polyparse = overrideCabal (drv: { postPatch = "sed -i -e 's, <0.11, <0.12,' polyparse.cabal"; }) (doJailbreak super.polyparse); - primitive = dontCheck (doJailbreak self.primitive_0_7_4_0); - regex-posix = doJailbreak super.regex-posix; - resolv = doJailbreak super.resolv; - singleton-bool = doJailbreak super.singleton-bool; - rope-utf16-splay = doDistribute self.rope-utf16-splay_0_4_0_0; - shake-cabal = doDistribute self.shake-cabal_0_2_2_3; libmpd = doJailbreak super.libmpd; - generics-sop = doJailbreak super.generics-sop; - microlens-th = doJailbreak super.microlens-th; + lens-family-th = doJailbreak super.lens-family-th; # template-haskell <2.19 + # generically needs base-orphans for 9.4 only base-orphans = dontCheck (doDistribute super.base-orphans); - generically = addBuildDepend self.base-orphans super.generically; # the dontHaddock is due to a GHC panic. might be this bug, not sure. # https://gitlab.haskell.org/ghc/ghc/-/issues/21619 - # - # We need >= 1.1.2 for ghc-9.4 support, but we don't have 1.1.x in - # hackage-packages.nix - hedgehog = doDistribute (dontHaddock super.hedgehog_1_2); - # tasty-hedgehog > 1.3 necessary to work with hedgehog 1.2: - # https://github.com/qfpl/tasty-hedgehog/pull/63 - tasty-hedgehog = self.tasty-hedgehog_1_4_0_1; - - # https://github.com/dreixel/syb/issues/38 - syb = dontCheck super.syb; - - splitmix = doJailbreak super.splitmix; - th-desugar = doDistribute self.th-desugar_1_15; - th-abstraction = doDistribute self.th-abstraction_0_5_0_0; - time-compat = doJailbreak super.time-compat; - tomland = doJailbreak super.tomland; - type-equality = doJailbreak super.type-equality; - unordered-containers = doJailbreak super.unordered-containers; - vector-binary-instances = doJailbreak super.vector-binary-instances; + hedgehog = dontHaddock super.hedgehog; hpack = overrideCabal (drv: { # Cabal 3.6 seems to preserve comments when reading, which makes this test fail @@ -137,8 +76,6 @@ in { ] ++ drv.testFlags or []; }) (doJailbreak super.hpack); - lens = doDistribute self.lens_5_2_2; - # Apply patches from head.hackage. language-haskell-extract = appendPatch (pkgs.fetchpatch { url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/language-haskell-extract-0.2.4.patch"; @@ -148,38 +85,22 @@ in { # Tests depend on `parseTime` which is no longer available hourglass = dontCheck super.hourglass; - memory = super.memory_0_18_0; - # https://github.com/sjakobi/bsb-http-chunked/issues/38 bsb-http-chunked = dontCheck super.bsb-http-chunked; - # need bytestring >= 0.11 which is only bundled with GHC >= 9.2 - regex-rure = doDistribute (markUnbroken super.regex-rure); - jacinda = doDistribute super.jacinda; - some = doJailbreak super.some; - # 2022-08-01: Tests are broken on ghc 9.2.4: https://github.com/wz1000/HieDb/issues/46 hiedb = dontCheck super.hiedb; - hlint = self.hlint_3_5; - hls-hlint-plugin = super.hls-hlint-plugin.override { - inherit (self) hlint; - }; - # 2022-10-06: https://gitlab.haskell.org/ghc/ghc/-/issues/22260 ghc-check = dontHaddock super.ghc-check; - ghc-exactprint = overrideCabal (drv: { - libraryHaskellDepends = with self; [ HUnit data-default fail filemanip free ghc-paths ordered-containers silently syb Diff ]; - }) - self.ghc-exactprint_1_6_1_3; + ghc-tags = self.ghc-tags_1_6; - # needed to build servant - http-api-data = super.http-api-data_0_5_1; - attoparsec-iso8601 = super.attoparsec-iso8601_1_1_0_0; + # Too strict upper bound on template-haskell + # https://github.com/mokus0/th-extras/issues/18 + th-extras = doJailbreak super.th-extras; # requires newer versions to work with GHC 9.4 - swagger2 = dontCheck super.swagger2; servant = doJailbreak super.servant; servant-server = doJailbreak super.servant-server; servant-auth = doJailbreak super.servant-auth; @@ -188,23 +109,9 @@ in { servant-client-core = doJailbreak super.servant-client-core; servant-client = doJailbreak super.servant-client; # https://github.com/kowainik/relude/issues/436 - relude = dontCheck (doJailbreak super.relude); + relude = dontCheck super.relude; - ormolu = doDistribute self.ormolu_0_5_3_0; - # https://github.com/tweag/ormolu/issues/941 fourmolu = overrideCabal (drv: { libraryHaskellDepends = drv.libraryHaskellDepends ++ [ self.file-embed ]; - }) (disableCabalFlag "fixity-th" super.fourmolu_0_10_1_0); - - # Apply workaround for Cabal 3.8 bug https://github.com/haskell/cabal/issues/8455 - # by making `pkg-config --static` happy. Note: Cabal 3.9 is also affected, so - # the GHC 9.6 configuration may need similar overrides eventually. - X11-xft = __CabalEagerPkgConfigWorkaround super.X11-xft; - # Jailbreaks for https://github.com/gtk2hs/gtk2hs/issues/323#issuecomment-1416723309 - glib = __CabalEagerPkgConfigWorkaround (doJailbreak super.glib); - cairo = __CabalEagerPkgConfigWorkaround (doJailbreak super.cairo); - pango = __CabalEagerPkgConfigWorkaround (doJailbreak super.pango); - - # Pending text-2.0 support https://github.com/gtk2hs/gtk2hs/issues/327 - gtk = doJailbreak super.gtk; + }) (disableCabalFlag "fixity-th" super.fourmolu); } diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix index 522d9a484ded..d2fcb916020c 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.6.x.nix @@ -14,6 +14,9 @@ let else builtins.throw "Check if '${msg}' was resolved in ${pkg.pname} ${pkg.version} and update or remove this"; jailbreakForCurrentVersion = p: v: checkAgainAfter p v "bad bounds" (doJailbreak p); + + # Workaround for a ghc-9.6 issue: https://gitlab.haskell.org/ghc/ghc/-/issues/23392 + disableParallelBuilding = overrideCabal (drv: { enableParallelBuilding = false; }); in self: super: { @@ -62,38 +65,24 @@ self: super: { # Version deviations from Stackage LTS # - doctest = doDistribute super.doctest_0_21_1; - inspection-testing = doDistribute self.inspection-testing_0_5_0_1; # allows base >= 4.18 - OneTuple = doDistribute (dontCheck super.OneTuple_0_4_1_1); # allows base >= 4.18 - primitive = doDistribute (dontCheck self.primitive_0_7_4_0); # allows base >= 4.18 - http-api-data = doDistribute self.http-api-data_0_5_1; # allows base >= 4.18 - attoparsec-iso8601 = doDistribute self.attoparsec-iso8601_1_1_0_0; # for http-api-data-0.5.1 - tagged = doDistribute self.tagged_0_8_7; # allows template-haskell-2.20 + doctest = doDistribute super.doctest_0_22_0; + http-api-data = doDistribute self.http-api-data_0_6; # allows base >= 4.18 some = doDistribute self.some_1_0_5; - tasty-inspection-testing = doDistribute self.tasty-inspection-testing_0_2; th-abstraction = doDistribute self.th-abstraction_0_5_0_0; th-desugar = doDistribute self.th-desugar_1_15; - turtle = doDistribute self.turtle_1_6_1; - aeson = doDistribute self.aeson_2_1_2_1; - memory = doDistribute self.memory_0_18_0; semigroupoids = doDistribute self.semigroupoids_6_0_0_1; bifunctors = doDistribute self.bifunctors_5_6_1; - cabal-plan = doDistribute self.cabal-plan_0_7_3_0; base-compat = doDistribute self.base-compat_0_13_0; base-compat-batteries = doDistribute self.base-compat-batteries_0_13_0; - semialign = doDistribute self.semialign_1_3; - assoc = doDistribute self.assoc_1_1; - strict = doDistribute self.strict_0_5; + + # Too strict upper bound on template-haskell + # https://github.com/mokus0/th-extras/pull/21 + th-extras = doJailbreak super.th-extras; ghc-lib = doDistribute self.ghc-lib_9_6_2_20230523; ghc-lib-parser = doDistribute self.ghc-lib-parser_9_6_2_20230523; ghc-lib-parser-ex = doDistribute self.ghc-lib-parser-ex_9_6_0_0; - # allows mtl, template-haskell, text and transformers - hedgehog = doDistribute self.hedgehog_1_2; - # allows base >= 4.18 - tasty-hedgehog = doDistribute self.tasty-hedgehog_1_4_0_1; - # v0.1.6 forbids base >= 4.18 singleton-bool = doDistribute super.singleton-bool_0_1_7; @@ -123,18 +112,6 @@ self: super: { # Compilation failure workarounds # - # Add missing Functor instance for Tuple2 - # https://github.com/haskell-foundation/foundation/pull/572 - foundation = appendPatches [ - (pkgs.fetchpatch { - name = "foundation-pr-572.patch"; - url = - "https://github.com/haskell-foundation/foundation/commit/d3136f4bb8b69e273535352620e53f2196941b35.patch"; - sha256 = "sha256-oPadhQdCPJHICdCPxn+GsSQUARIYODG8Ed6g2sK+eC4="; - stripLen = 1; - }) - ] (super.foundation); - # Add support for time 1.10 # https://github.com/vincenthz/hs-hourglass/pull/56 hourglass = appendPatches [ @@ -151,6 +128,40 @@ self: super: { # https://github.com/dreixel/syb/issues/40 syb = dontCheck super.syb; + # Support for template-haskell >= 2.16 + language-haskell-extract = appendPatch (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/dfd024c9a336c752288ec35879017a43bd7e85a0/patches/language-haskell-extract-0.2.4.patch"; + sha256 = "0w4y3v69nd3yafpml4gr23l94bdhbmx8xky48a59lckmz5x9fgxv"; + }) (doJailbreak super.language-haskell-extract); + + # Patch for support of mtl-2.3 + monad-par = appendPatch + (pkgs.fetchpatch { + name = "monad-par-mtl-2.3.patch"; + url = "https://github.com/simonmar/monad-par/pull/75/commits/ce53f6c1f8246224bfe0223f4aa3d077b7b6cc6c.patch"; + sha256 = "1jxkl3b3lkjhk83f5q220nmjxbkmni0jswivdw4wfbzp571djrlx"; + stripLen = 1; + }) + (doJailbreak super.monad-par); + + # Patch 0.17.1 for support of mtl-2.3 + xmonad-contrib = appendPatch + (pkgs.fetchpatch { + name = "xmonad-contrib-mtl-2.3.patch"; + url = "https://github.com/xmonad/xmonad-contrib/commit/8cb789af39e93edb07f1eee39c87908e0d7c5ee5.patch"; + sha256 = "sha256-ehCvVy0N2Udii/0K79dsRSBP7/i84yMoeyupvO8WQz4="; + }) + (doJailbreak super.xmonad-contrib); + + # Patch 0.12.0.1 for support of unix-2.8.0.0 + arbtt = appendPatch + (pkgs.fetchpatch { + name = "arbtt-unix-2.8.0.0.patch"; + url = "https://github.com/nomeata/arbtt/pull/168/commits/ddaac94395ac50e3d3cd34c133dda4a8e5a3fd6c.patch"; + sha256 = "sha256-5Gmz23f4M+NfgduA5O+9RaPmnneAB/lAlge8MrFpJYs="; + }) + super.arbtt; + # 2023-04-03: plugins disabled for hls 1.10.0.0 based on # haskell-language-server = @@ -170,8 +181,25 @@ self: super: { hls-stylish-haskell-plugin = null; }; - MonadRandom = super.MonadRandom_0_6; - unix-compat = super.unix-compat_0_7; + # Newer version of servant required for GHC 9.6 + servant = self.servant_0_20; + servant-server = self.servant-server_0_20; + servant-client = self.servant-client_0_20; + servant-client-core = self.servant-client-core_0_20; + # Select versions compatible with servant_0_20 + servant-docs = self.servant-docs_0_13; + servant-swagger = self.servant-swagger_1_2; + # Jailbreaks for servant <0.20 + servant-lucid = doJailbreak super.servant-lucid; + + # Jailbreak strict upper bounds: http-api-data <0.6 + servant_0_20 = doJailbreak super.servant_0_20; + servant-server_0_20 = doJailbreak super.servant-server_0_20; + servant-client_0_20 = doJailbreak super.servant-client_0_20; + servant-client-core_0_20 = doJailbreak super.servant-client-core_0_20; + # Jailbreak strict upper bounds: doctest <0.22 + servant-swagger_1_2 = doJailbreak super.servant-swagger_1_2; + lifted-base = dontCheck super.lifted-base; hw-fingertree = dontCheck super.hw-fingertree; hw-prim = dontCheck (doJailbreak super.hw-prim); @@ -180,10 +208,9 @@ self: super: { rebase = doJailbreak super.rebase_1_20; rerebase = doJailbreak super.rerebase_1_20; hiedb = dontCheck super.hiedb; - retrie = dontCheck (super.retrie); - - # break infinite recursion with foldable1-classes-compat's test suite, which depends on 'these'. - these = doDistribute (super.these_1_2.override { foldable1-classes-compat = dontCheck super.foldable1-classes-compat; }); + retrie = dontCheck super.retrie; + # https://github.com/kowainik/relude/issues/436 + relude = dontCheck (doJailbreak super.relude); ghc-exactprint = unmarkBroken (addBuildDepends (with self.ghc-exactprint.scope; [ HUnit Diff data-default extra fail free ghc-paths ordered-containers silently syb @@ -203,18 +230,21 @@ self: super: { implicit-hie-cradle focus hie-compat - xmonad-contrib # mtl >=1 && <2.3 dbus # template-haskell >=2.18 && <2.20, transformers <0.6, unix <2.8 + gi-cairo-connector # mtl <2.3 + haskintex # text <2 + lens-family-th # template-haskell <2.19 + ghc-prof # base <4.18 + profiteur # vector <0.13 + mfsolve # mtl <2.3 + cubicbezier # mtl <2.3 + dhall # template-haskell <2.20 + env-guard # doctest <0.21 + package-version # doctest <0.21, tasty-hedgehog <1.4 ; - # Apply workaround for Cabal 3.8 bug https://github.com/haskell/cabal/issues/8455 - # by making `pkg-config --static` happy. Note: Cabal 3.9 is also affected, so - # the GHC 9.6 configuration may need similar overrides eventually. - X11-xft = __CabalEagerPkgConfigWorkaround super.X11-xft; - # Jailbreaks for https://github.com/gtk2hs/gtk2hs/issues/323#issuecomment-1416723309 - glib = __CabalEagerPkgConfigWorkaround (doJailbreak super.glib); - cairo = __CabalEagerPkgConfigWorkaround (doJailbreak super.cairo); - pango = __CabalEagerPkgConfigWorkaround (doJailbreak super.pango); + # Avoid triggering an issue in ghc-9.6.2 + gi-gtk = disableParallelBuilding super.gi-gtk; # Pending text-2.0 support https://github.com/gtk2hs/gtk2hs/issues/327 gtk = doJailbreak super.gtk; @@ -229,4 +259,17 @@ self: super: { }) super.libmpd; + # Apply patch from PR with mtl-2.3 fix. + ConfigFile = overrideCabal (drv: { + editedCabalFile = null; + buildDepends = drv.buildDepends or [] ++ [ self.HUnit ]; + patches = [(pkgs.fetchpatch { + name = "ConfigFile-pr-12.patch"; + url = "https://github.com/jgoerzen/configfile/pull/12.patch"; + sha256 = "sha256-b7u9GiIAd2xpOrM0MfILHNb6Nt7070lNRIadn2l3DfQ="; + })]; + }) super.ConfigFile; + + # The curl executable is required for withApplication tests. + warp_3_3_28 = addTestToolDepend pkgs.curl super.warp_3_3_28; } diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix index 2ad093ab9652..d8e1e9d7320b 100644 --- a/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix +++ b/pkgs/development/haskell-modules/configuration-ghc-9.8.x.nix @@ -70,7 +70,6 @@ self: super: { unicode-transforms = dontCheck super.unicode-transforms; wl-pprint-extras = doJailbreak super.wl-pprint-extras; # containers >=0.4 && <0.6 is too tight; https://github.com/ekmett/wl-pprint-extras/issues/17 RSA = dontCheck super.RSA; # https://github.com/GaloisInc/RSA/issues/14 - monad-par = dontCheck super.monad-par; # https://github.com/simonmar/monad-par/issues/66 github = dontCheck super.github; # hspec upper bound exceeded; https://github.com/phadej/github/pull/341 binary-orphans = dontCheck super.binary-orphans; # tasty upper bound exceeded; https://github.com/phadej/binary-orphans/commit/8ce857226595dd520236ff4c51fa1a45d8387b33 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 09eb1512f4cd..c4783feb5362 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -18,6 +18,7 @@ broken-packages: - access-time - accuerr - AC-EasyRaster-GTK + - ace # test failure in job https://hydra.nixos.org/build/230967016 at 2023-08-16 - AC-HalfInteger - achille - acid-state-dist @@ -68,8 +69,11 @@ broken-packages: - AERN-Basics - aeson-applicative - aeson-bson + - aeson-commit # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970158 at 2023-08-16 + - aeson-compat # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955731 at 2023-08-16 - aeson-decode - aeson-default + - aeson-dependent-sum # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951615 at 2023-08-16 - aeson-deriving - aeson-diff-generic - aeson-filthy @@ -86,11 +90,13 @@ broken-packages: - aeson-parsec-picky - aeson-prefix - aeson-schema + - aeson-single-field # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952090 at 2023-08-16 - aeson-smart - aeson-streams - aeson-t - aeson-toolkit - aeson-utils + - aeson-via # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971255 at 2023-08-16 - aeson-with - affection - affine-invariant-ensemble-mcmc @@ -112,6 +118,7 @@ broken-packages: - ajhc - AlanDeniseEricLauren - alerta + - alerts # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970661 at 2023-08-16 - alex-prelude - alfred - alfred-margaret @@ -123,6 +130,7 @@ broken-packages: - algorithmic-composition-complex - AlgorithmW - algo-s + - align-affine # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969907 at 2023-08-16 - align-text - ally-invest - alpaca-netcode @@ -170,10 +178,12 @@ broken-packages: - aosd - apache-md5 - apart + - apecs-physics # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/230961455 at 2023-08-16 - api-builder - api-rpc-factom - apns-http2 - appc + - appendful-persistent # failure building library in job https://hydra.nixos.org/build/230949704 at 2023-08-16 - app-lens - AppleScript - applicative-fail @@ -196,6 +206,7 @@ broken-packages: - archlinux - archnews - arena + - argo # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957050 at 2023-08-16 - argon2 - argparser - arguedit @@ -219,6 +230,7 @@ broken-packages: - asap - ascii85-conduit - ascii-caseless + - asciidiagram # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955130 at 2023-08-16 - ascii-flatten - ascii-string - ascii-vector-avc @@ -233,6 +245,8 @@ broken-packages: - assert4hs-core - assertions - asset-map + - assoc-list # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968246 at 2023-08-16 + - assoc-listlike # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957051 at 2023-08-16 - assumpta - ast-monad - astrds @@ -246,9 +260,11 @@ broken-packages: - atlassian-connect-descriptor - atndapi - atom + - atomic-modify # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969549 at 2023-08-16 - atomic-primops-vector - atomo - atp-haskell + - ats-format # failure building executable 'atsfmt' in job https://hydra.nixos.org/build/230948414 at 2023-08-16 - ats-pkg - ats-setup - ats-storable @@ -257,6 +273,7 @@ broken-packages: - AttoBencode - atto-lisp - attomail + - attoparsec-aeson # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964825 at 2023-08-16 - attoparsec-csv - attoparsec-text - attoparsec-trans @@ -308,6 +325,7 @@ broken-packages: - bake - Bang - banwords + - barbies-th # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949387 at 2023-08-16 - barchart - barcodes-code128 - barecheck @@ -318,13 +336,16 @@ broken-packages: - base32-lens - base58address - base62 + - base64-bytes # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952298 at 2023-08-16 - base64-conduit - base64-lens - base-compat-migrate + - based # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967441 at 2023-08-16 - base-encoding - base-feature-macros - base-generics - base-io-access + - basement-cd # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963879 at 2023-08-16 - basen - basex-client - basic-sop @@ -343,7 +364,9 @@ broken-packages: - bech32 - bed-and-breakfast - Befunge93 + - bench-graph # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958515 at 2023-08-16 - BenchmarkHistory + - bench-show # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951256 at 2023-08-16 - bencodex - bencoding-lens - berkeleydb @@ -353,6 +376,7 @@ broken-packages: - besout - bet - betacode + - betris # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971705 at 2023-08-16 - bgmax - bgzf - bibdb @@ -403,6 +427,7 @@ broken-packages: - bindings-wlc - bind-marshal - binembed + - binrep # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/231689637 at 2023-08-16 - binsm - bio - BiobaseNewick @@ -418,6 +443,7 @@ broken-packages: - bitcoin-keys - bitcoin-rpc - bitcoin-script + - bitfield # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967290 at 2023-08-16 - bits-atomic - bits-conduit - bitset @@ -428,6 +454,7 @@ broken-packages: - BitStringRandomMonad - BitSyntax - bitx-bitcoin + - bizzlelude # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953184 at 2023-08-16 - bizzlelude-js - bkr - blagda @@ -456,6 +483,7 @@ broken-packages: - bolt - boltzmann-brain - bookhound + - bookkeeping # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958716 at 2023-08-16 - boolean-like - boolean-normal-forms - boolexpr @@ -465,7 +493,10 @@ broken-packages: - bot - botpp - bottom + - bounded-array # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957201 at 2023-08-16 + - bound-simple # failure building library in job https://hydra.nixos.org/build/230950474 at 2023-08-16 - box + - box-tuples # failure building library in job https://hydra.nixos.org/build/230956723 at 2023-08-16 - bpath - BPS - braid @@ -477,6 +508,7 @@ broken-packages: - brick-filetree - brick-list-search # failure in job https://hydra.nixos.org/build/211236614 at 2023-03-13 - brick-list-skip # failure in job https://hydra.nixos.org/build/215850872 at 2023-04-17 + - brick-panes # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961711 at 2023-08-16 - bricks-internal - brick-tabular-list - brillig @@ -522,6 +554,7 @@ broken-packages: - bytestring-aeson-orphans - bytestring-arbitrary - bytestring-class + - bytestring-conversion # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970130 at 2023-08-16 - bytestring-csv - bytestring-delta - bytestring-handle @@ -548,6 +581,7 @@ broken-packages: - cabal-bundle-clib - cabal-constraints - cabal-db + - cabal-debian # failure building library in job https://hydra.nixos.org/build/230959173 at 2023-08-16 - cabal-dependency-licenses - cabal-dev - cabal-dir @@ -558,6 +592,7 @@ broken-packages: - cabalgraph - cabal-graphdeps - cabal-helper + - cabal-hoogle # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965454 at 2023-08-16 - Cabal-ide-backend - cabal-info - cabal-install-bundle @@ -569,6 +604,7 @@ broken-packages: - cabal-mon - cabal-nirvana - cabal-plan-bounds + - cabal-plan # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949515 at 2023-08-16 - cabal-progdeps - cabalQuery - CabalSearch @@ -602,6 +638,7 @@ broken-packages: - canteven-parsedate - cantor - capataz + - ca-patterns # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959692 at 2023-08-16 - capped-list - capri - caps @@ -615,6 +652,7 @@ broken-packages: - casadi-bindings-internal - Cascade - cascading + - case-insensitive-match # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953665 at 2023-08-16 - caseof - cas-hashable - casr-logbook @@ -623,6 +661,7 @@ broken-packages: - Cassava - cassava-conduit - cassava-records + - cassava-streams # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968263 at 2023-08-16 - cassette - castagnoli # failure in job https://hydra.nixos.org/build/219826672 at 2023-05-19 - castle @@ -637,6 +676,7 @@ broken-packages: - cayene-lpp - cayley-client - cblrepo + - cbor-tool # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947427 at 2023-08-16 - CCA - ccast - CC-delcont-cxe @@ -664,6 +704,7 @@ broken-packages: - chakra - chalkboard - chalmers-lava2000 + - changelogged # failure building library in job https://hydra.nixos.org/build/230967974 at 2023-08-16 - ChannelT - character-cases - charter @@ -672,6 +713,7 @@ broken-packages: - chaselev-deque - chatty-text - chatwork + - cheapskate # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951147 at 2023-08-16 - check-cfg-ambiguity # failure in job https://hydra.nixos.org/build/225575902 at 2023-06-28 - checked - Checked @@ -688,8 +730,11 @@ broken-packages: - chunky - church - church-maybe + - churros # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230954366 at 2023-08-16 + - cicero-api # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967916 at 2023-08-16 - cielo - cil + - cimple # failure building library in job https://hydra.nixos.org/build/230963662 at 2023-08-16 - cinvoke - c-io - cio @@ -709,6 +754,7 @@ broken-packages: - clanki - clarifai - CLASE + - clash-prelude # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967667 at 2023-08-16 - Clash-Royale-Hack-Cheats - ClassLaws - classy-influxdb-simple @@ -722,11 +768,13 @@ broken-packages: - cld2 - Clean - clean-unions + - cleff # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963671 at 2023-08-16 - clerk # failure building library in job https://hydra.nixos.org/build/214864491 at 2023-04-07 - clevercss - clexer - CLI - cli-builder + - cli-extras # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949753 at 2023-08-16 - clif - clifm - cli-git @@ -736,13 +784,17 @@ broken-packages: - clipper - clisparkline - clit + - cloben # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955543 at 2023-08-16 - clocked - clock-extras - clogparse - clone-all + - closed-classes # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969665 at 2023-08-16 + - closed-intervals # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959515 at 2023-08-16 - closure - cloudfront-signer - clplug # failure in job https://hydra.nixos.org/build/211239834 at 2023-03-13 + - clr-host # failure building library in job https://hydra.nixos.org/build/230958504 at 2023-08-16 - clr-inline - clr-typed - cluss @@ -788,6 +840,7 @@ broken-packages: - comark-syntax - combinat-compat - combinat-diagrams + - combinat # failure building library in job https://hydra.nixos.org/build/230947031 at 2023-08-16 - combinatorial-problems - combinator-interactive - combobuffer @@ -815,12 +868,14 @@ broken-packages: - compose-trans - composite-aeson-path - composite-aeson-refined + - composite-base # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966274 at 2023-08-16 - composite-cassava - composition-tree - compressed - compression - computational-geometry - computations + - ConClusion # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952663 at 2023-08-16 - concrete-relaxng-parser - concrete-typerep - concurrency-benchmarks @@ -845,6 +900,7 @@ broken-packages: - conduit-vfs - conf - conferer-dhall + - conferer # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230960587 at 2023-08-16 - conferer-hspec - conferer-provider-json - conferer-snap @@ -854,18 +910,21 @@ broken-packages: - config-parser - Configurable - configuration + - configurator-pg # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962366 at 2023-08-16 - config-value-getopt - confsolve - congruence-relation - conjure - conkin - conlogger + - connection-pool # failure building library in job https://hydra.nixos.org/build/230958887 at 2023-08-16 - connections - connection-string - Conscript - consistent - console-program - constable + - const # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972319 at 2023-08-16 - const-math-ghc-plugin - constrained - constrained-categories @@ -875,6 +934,7 @@ broken-packages: - constraints-deriving - constraints-emerge - constr-eq + - construct # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959867 at 2023-08-16 - constructive-algebra - consul-haskell - Consumer @@ -899,6 +959,7 @@ broken-packages: - contstuff-monads-tf - contstuff-transformers - convert-annotation + - copilot-c99 # test failure in job https://hydra.nixos.org/build/230951365 at 2023-08-16 - copr - coquina - COrdering @@ -916,6 +977,7 @@ broken-packages: - couchdb-conduit - couch-hs - counter + - country-codes # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969077 at 2023-08-16 - courier - court - coverage @@ -936,6 +998,7 @@ broken-packages: - crc32c - crdt - crdt-event-fold + - creatur # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950704 at 2023-08-16 - credential-store - crem # test failure in job https://hydra.nixos.org/build/214604824 at 2023-04-07 - critbit @@ -945,6 +1008,7 @@ broken-packages: - criterion-to-html - criu-rpc-types - crjdt-haskell + - crockford # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/230965833 at 2023-08-16 - crocodile - cronus - cruncher-types @@ -955,8 +1019,8 @@ broken-packages: - cryptoids-types - crypto-keys-ssh - crypto-multihash + - crypton-connection # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956968 at 2023-08-16 - crypto-numbers - - crypton-x509 # failure building test suite 'test-x509' in job https://hydra.nixos.org/build/225569131 at 2023-06-28 - crypto-pubkey-openssh - crypto-random-effect - crypto-simple @@ -970,7 +1034,7 @@ broken-packages: - css - css-easings - css-selectors - - css-syntax + - css-simple # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951038 at 2023-08-16 - C-structs - csv-nptools - csv-sip @@ -982,12 +1046,14 @@ broken-packages: - curl-aeson - curl-runnings - curly-expander + - currencies # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946919 at 2023-08-16 - currency-convert - curry-base - CurryDB - curryer-rpc # dependency missing in job https://hydra.nixos.org/build/214772339 at 2023-04-07 - curry-frontend - curryrs + - cursedcsv # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967021 at 2023-08-16 - curves - custom-prelude - cut-the-crap @@ -1022,6 +1088,7 @@ broken-packages: - data-construction - data-constructors - data-default-instances-new-base + - data-default-instances-text # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949390 at 2023-08-16 - data-dispersal - data-diverse - datadog @@ -1029,9 +1096,11 @@ broken-packages: - data-embed - data-emoticons - data-filepath + - data-filter # failure building library in job https://hydra.nixos.org/build/230970830 at 2023-08-16 - data-fin - data-fin-simple - data-flagset + - data-forced # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946495 at 2023-08-16 - data-index - DataIndex - data-ivar @@ -1046,6 +1115,7 @@ broken-packages: - data-object - datapacker - data-pdf-fieldreader + - data-pprint # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972007 at 2023-08-16 - data-quotientref - data-reify-cse - data-repr @@ -1064,11 +1134,13 @@ broken-packages: - data-util - data-validation - data-variant + - data-vector-growable # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964148 at 2023-08-16 - dates - datetime - datetime-sb - dawdle - dawg + - dawg-ord # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969059 at 2023-08-16 - daytripper # failure in job https://hydra.nixos.org/build/225578117 at 2023-06-28 - dbcleaner - dbf @@ -1088,7 +1160,10 @@ broken-packages: - dead-code-detection - Deadpan-DDP - dead-simple-json + - dear-imgui # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968725 at 2023-08-16 + - debugger-hs # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968226 at 2023-08-16 - debug-me + - debug-trace-file # test failure in job https://hydra.nixos.org/build/230951658 at 2023-08-16 - debug-tracy - decepticons - decision-diagrams @@ -1102,6 +1177,7 @@ broken-packages: - deepseq-magic - deepseq-th - definitive-base + - deiko-config # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964942 at 2023-08-16 - deka - Delta-Lambda - delude @@ -1110,7 +1186,9 @@ broken-packages: - dense - dense-int-set - dependent-hashmap + - dependent-monoidal-map # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972604 at 2023-08-16 - dep-t-dynamic + - dep-t # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956455 at 2023-08-16 - deptrack-core - dep-t-value - derangement @@ -1140,11 +1218,13 @@ broken-packages: - dhall-check - dhall-csv - dhall-fly + - dhall-lsp-server # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971652 at 2023-08-16 - dhall-text - dhall-to-cabal - dhcp-lease-parser - dhrun - dia-base + - diagnose # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962878 at 2023-08-16 - diagrams-boolean - diagrams-builder - diagrams-pdf @@ -1169,11 +1249,12 @@ broken-packages: - digestive-foundation-lucid - digestive-functors-aeson - digestive-functors-happstack + - digestive-functors-heist # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948900 at 2023-08-16 + - digestive-functors-lucid # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969836 at 2023-08-16 - digestive-functors-snap - digest-pure - DigitalOcean - digitalocean-kzs - - digits - digraph - dijkstra-simple - DimensionalHash @@ -1187,6 +1268,7 @@ broken-packages: - direct-plugins - direm - disco # failure building library in job https://hydra.nixos.org/build/219207076 at 2023-05-10 + - discord-haskell # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971973 at 2023-08-16 - discordian-calendar - discord-register - discord-types @@ -1202,12 +1284,14 @@ broken-packages: - distributed-closure - distribution - dist-upload + - ditto-lucid # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947345 at 2023-08-16 - djembe - djinn-ghc - djinn-th - dmcc - dmenu - dnscache + - dns-patterns # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959482 at 2023-08-16 - dnsrbl - dnssd - dobutok @@ -1216,6 +1300,7 @@ broken-packages: - docidx - docker-build-cacher - dockercook + - docker # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961470 at 2023-08-16 - dockerfile-creator - docopt - docrecords @@ -1225,7 +1310,9 @@ broken-packages: - docvim - DOH - doi + - domaindriven-core # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948092 at 2023-08-16 - domain-optics + - dom-events # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958378 at 2023-08-16 - dom-parser - domplate - dom-selector @@ -1261,9 +1348,11 @@ broken-packages: - dson - dson-parsec - dstring + - dsv # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953340 at 2023-08-16 - DTC - dtd-text - dtw + - dual-game # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959616 at 2023-08-16 - dualizer - duckling - duet @@ -1312,6 +1401,7 @@ broken-packages: - eddie - ede - edenmodules + - edf # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965074 at 2023-08-16 - edis - edit - edit-lenses @@ -1348,6 +1438,7 @@ broken-packages: - elm-street - elm-websocket - elocrypt + - ema-generics # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957258 at 2023-08-16 - emailaddress - email-header - email-postmark @@ -1375,8 +1466,10 @@ broken-packages: - enum-text - enum-utf8 - envelope + - env-extra # test failure in job https://hydra.nixos.org/build/230961939 at 2023-08-16 - env-parser - envstatus + - envy-extensible # failure building library in job https://hydra.nixos.org/build/230971634 at 2023-08-16 - epanet-haskell - epass - epic @@ -1418,6 +1511,7 @@ broken-packages: - eventsource-api - eventsourced - eventstore + - evoke # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955694 at 2023-08-16 - ewe # failure building executable 'ewe' in job https://hydra.nixos.org/build/225555839 at 2023-06-28 - exact-cover - exact-real-positional @@ -1444,6 +1538,7 @@ broken-packages: - explicit-constraint-lens - explicit-determinant - explicit-iomodes + - exploring-interpreters # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967612 at 2023-08-16 - exposed-containers - expression-parser - expressions @@ -1454,15 +1549,18 @@ broken-packages: - extensible-data - extensible-effects-concurrent - extensible-skeleton + - extensioneer # failure building executable 'extensioneer' in job https://hydra.nixos.org/build/230953750 at 2023-08-16 - external-sort - extism - extractelf + - extralife # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950860 at 2023-08-16 - ez3 - ez-couch - Facebook-Password-Hacker-Online-Latest-Version - faceted - factory # test failure in job https://hydra.nixos.org/build/214600338 at 2023-04-07 - facts + - Facts # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949709 at 2023-08-16 - fadno-braids - fadno-xml - failable-list @@ -1510,6 +1608,7 @@ broken-packages: - Feval - fez-conf - ffeed + - ffmpeg-light # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963762 at 2023-08-16 - ffunctor - fgl-extras-decompositions - fib @@ -1517,6 +1616,7 @@ broken-packages: - fields - fieldwise - fig + - filecache # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961614 at 2023-08-16 - file-collection - file-command-qq - filediff @@ -1544,6 +1644,7 @@ broken-packages: - firefly-example - first-and-last - first-class-instances + - FirstPrelude # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952406 at 2023-08-16 - fit - fitsio - fits-parse @@ -1552,6 +1653,7 @@ broken-packages: - fixed-precision - fixed-storable-array - fixed-timestep + - fixed-vector-hetero # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959989 at 2023-08-16 - fixed-width - fixer - fixfile @@ -1564,6 +1666,7 @@ broken-packages: - flamethrower - flamingra - flat-maybe + - flat-mcmc # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951840 at 2023-08-16 - flay - flexible-time - flickr @@ -1585,10 +1688,13 @@ broken-packages: - fmark - FModExRaw - fn-extra + - fold-debounce-conduit # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972387 at 2023-08-16 - foldl-incremental - foldl-statistics + - foldl-transduce # test failure in job https://hydra.nixos.org/build/230962135 at 2023-08-16 - folds-common - follow + - fontconfig-pure # test failure in job https://hydra.nixos.org/build/230970811 at 2023-08-16 - font-opengl-basic4x6 - forbidden-fruit - fordo @@ -1601,12 +1707,14 @@ broken-packages: - for-free - forger - ForkableT + - forma # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967499 at 2023-08-16 - formal - formattable - forml - formura - Fortnite-Hack-Cheats-Free-V-Bucks-Generator - fortran-src-extras + - fortytwo # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950284 at 2023-08-16 - foscam-filename - fpe - fp-ieee # test failure in job https://hydra.nixos.org/build/225561952 at 2023-06-28 @@ -1623,9 +1731,11 @@ broken-packages: - free-concurrent - f-ree-hack-cheats-free-v-bucks-generator - free-http + - freenect # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969157 at 2023-08-16 - free-operational - freer-effects - freer-simple-catching + - freer-simple # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959714 at 2023-08-16 - freer-simple-http - freer-simple-profiling - freer-simple-random @@ -1643,16 +1753,20 @@ broken-packages: - friday-devil - friday-scale-dct - friday # test failure in job https://hydra.nixos.org/build/225561573 at 2023-06-28 + - friendly # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966475 at 2023-08-16 - frown - frp-arduino - frpnow - fs-events - fsh-csv - fsmActions + - FSM # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963381 at 2023-08-16 + - fsnotify-conduit # failure building library in job https://hydra.nixos.org/build/230972081 at 2023-08-16 - fst - fsutils - fswait - fswatch + - fswatcher # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959599 at 2023-08-16 - ft-generator - FTGL-bytestring - ftp-client @@ -1661,6 +1775,7 @@ broken-packages: - full-sessions - funbot-client - funcons-lambda-cbv-mp # failure building executable 'lambda-cbv' in job https://hydra.nixos.org/build/217559083 at 2023-04-29 + - funcons-values # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971643 at 2023-08-16 - functional-arrow - function-instances-algebra - functor-combinators @@ -1675,11 +1790,14 @@ broken-packages: - fused-effects-exceptions - fused-effects-mwc-random - fused-effects-resumable + - fused-effects-th # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961770 at 2023-08-16 - fusion - futhask - futun - future + - futures # failure building library in job https://hydra.nixos.org/build/230952892 at 2023-08-16 - fuzzyfind + - fuzzyset # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967540 at 2023-08-16 - fuzzy-timings - fwgl - fxpak @@ -1692,6 +1810,7 @@ broken-packages: - gamma - Ganymede - garepinoh + - gargoyle # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955806 at 2023-08-16 - gargoyle-postgresql-nix - gas - gather @@ -1711,6 +1830,7 @@ broken-packages: - GeneralTicTacToe - generator - generators + - generic-aeson # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955043 at 2023-08-16 - generic-binary - generic-church - generic-enum @@ -1749,19 +1869,26 @@ broken-packages: - GeomPredicates-SSE - geo-resolver - geos + - gerrit # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950005 at 2023-08-16 - Get - getflag + - gev-lib # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946300 at 2023-08-16 - GGg - ggtsTC - ghc-api-compat + - ghc-bignum-orphans # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952175 at 2023-08-16 - ghc-clippy-plugin - ghc-core-smallstep + - ghc-corroborate # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966063 at 2023-08-16 - ghc-datasize + - ghc-definitions-th # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968119 at 2023-08-16 + - ghc-dump-core # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962483 at 2023-08-16 - ghc-dump-tree - ghc-dup - ghc-events-analyze - ghc-events-parallel - ghcflags + - ghc-gc-hook # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962629 at 2023-08-16 - ghc-generic-instances - ghc-hotswap - ghci-diagrams @@ -1784,6 +1911,7 @@ broken-packages: - ghc-plugs-out - ghc-proofs - ghc-simple + - ghc-source-gen - ghc-srcspan-plugin - ghc-syb - ghc-syb-utils @@ -1801,7 +1929,9 @@ broken-packages: - gi-gtk-declarative - gi-gtk-layer-shell - gi-gtksheet + - gi-gtksource # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968384 at 2023-08-16 - gi-handy + - gi-ibus # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971732 at 2023-08-16 - gingersnap - ginsu - gipeda @@ -1810,6 +1940,7 @@ broken-packages: - GiST - git - git-all + - git-brunch # failure building executable 'git-brunch' in job https://hydra.nixos.org/build/230966224 at 2023-08-16 - git-checklist - git-cuk - git-date @@ -1820,6 +1951,7 @@ broken-packages: - github-utils - github-webhook-handler - githud + - gitHUD # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965338 at 2023-08-16 - gitignore - git-jump - gitlab-api @@ -1846,6 +1978,7 @@ broken-packages: - gloss-banana - gloss-export - gloss-game + - glsl # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230960137 at 2023-08-16 - gltf-codec - glue - g-npm @@ -1854,6 +1987,7 @@ broken-packages: - goatee - gochan - godot-haskell + - godot-megaparsec # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948877 at 2023-08-16 - gofer-prelude - gogol-core - gooey @@ -1874,6 +2008,7 @@ broken-packages: - gothic - GotoT-transformers - gotta-go-fast + - gotyno-hs # failure building library in job https://hydra.nixos.org/build/230953887 at 2023-08-16 - gpah - GPipe - GPipe-Core @@ -1910,12 +2045,14 @@ broken-packages: - gremlin-haskell - Grempa - greplicate + - greskell-core # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230954493 at 2023-08-16 - gridfs - grid-proto # failure building library in job https://hydra.nixos.org/build/219248049 at 2023-05-10 - grids - grm - GroteTrap - groundhog + - grouped-list # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962501 at 2023-08-16 - groups-generic - group-theory - group-with @@ -1969,6 +2106,7 @@ broken-packages: - hadoop-rpc - hadoop-streaming - hafar + - haggle # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967144 at 2023-08-16 - Haggressive - HaGL # test failure in job https://hydra.nixos.org/build/225563740 at 2023-06-28 - hahp @@ -1987,6 +2125,7 @@ broken-packages: - hakyll-contrib-elm - hakyll-contrib-i18n - hakyll-contrib-links + - hakyll-convert # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951676 at 2023-08-16 - hakyll-dhall - hakyll-dir-list - hakyll-R @@ -1994,8 +2133,10 @@ broken-packages: - hakyll-shortcode - hakyll-typescript - HaLeX + - hal # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966637 at 2023-08-16 - halfs - half-space + - halide-haskell # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951821 at 2023-08-16 - halipeto - halive - halma @@ -2022,9 +2163,11 @@ broken-packages: - happlets - happraise - happstack + - happstack-clientsession # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955472 at 2023-08-16 - happstack-hamlet - happstack-heist - happstack-hstringtemplate + - happstack-lite # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969664 at 2023-08-16 - happstack-monad-peel - happstack-server-tls-cryptonite - happstack-util @@ -2129,8 +2272,10 @@ broken-packages: - haskelzinc - haskeme - haskey + - haskey-btree # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947127 at 2023-08-16 - haskheap - haskhol-core + - haskintex # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947126 at 2023-08-16 - haskmon - haskoin - haskoin-util @@ -2156,10 +2301,12 @@ broken-packages: - hasql-resource-pool - hasql-simple - hasql-streams-core + - hasql-transaction-io # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949199 at 2023-08-16 - hasql-url - hastache - haste - haste-prim + - hasura-ekg-core # failure building library in job https://hydra.nixos.org/build/230950264 at 2023-08-16 - hat - hatex-guide - hats @@ -2212,7 +2359,9 @@ broken-packages: - headroom - heap-console - heapsort + - heartbeat-streams # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948671 at 2023-08-16 - heart-core + - heatitup-complete # failure building executable 'heatitup-complete' in job https://hydra.nixos.org/build/230969611 at 2023-08-16 - hebrew-time - heckle - heddit @@ -2220,6 +2369,7 @@ broken-packages: - hedgehog-gen - hedgehog-generic - hedgehog-golden + - hedgehog-lens # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947380 at 2023-08-16 - hedgehog-servant - hedis-config - hedis-namespace @@ -2231,6 +2381,7 @@ broken-packages: - heist-aeson - heist-async - heist-emanote + - heist-extra # failure building library in job https://hydra.nixos.org/build/230953957 at 2023-08-16 - helisp - helix - helm @@ -2243,6 +2394,7 @@ broken-packages: - her-lexer-parsec - Hermes - herms + - heroku-persistent # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959576 at 2023-08-16 - hetero-dict - heterogeneous-list-literals - hetris @@ -2285,6 +2437,7 @@ broken-packages: - hgopher - h-gpgme - HGraphStorage + - hgreet # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970023 at 2023-08-16 - hgrep - hgrev - hgrib @@ -2299,9 +2452,11 @@ broken-packages: - hidden-char - hid-examples - hieraclus + - hierarchical-clustering # failure building library in job https://hydra.nixos.org/build/230953344 at 2023-08-16 - hierarchical-exceptions - hierarchy - hiernotify + - hifi # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961852 at 2023-08-16 - higgledy - higher-leveldb - higherorder @@ -2342,12 +2497,15 @@ broken-packages: - hleap - hledger-chart - hledger-diff + - hledger-flow # failure building library in job https://hydra.nixos.org/build/230963320 at 2023-08-16 - hledger-iadd - hledger-irr + - hledger-makeitso # failure building library in job https://hydra.nixos.org/build/230946385 at 2023-08-16 - hledger-vty - hlibBladeRF - hlibev - hlibfam + - HList # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950021 at 2023-08-16 - hlivy - hlogger - HLogger @@ -2373,12 +2531,14 @@ broken-packages: - hmm - HMM - hmm-hmatrix + - HMock # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971948 at 2023-08-16 - hMollom - hmp3 - Hmpf - hmumps - hnetcdf - hnn + - hnock # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230960174 at 2023-08-16 - hnop - hoauth - hoauth2-providers @@ -2513,8 +2673,6 @@ broken-packages: - hslogger-template - hs-logo - hslua-examples - - hslua-repl # dependency missing in job https://hydra.nixos.org/build/214605872 at 2023-04-07 - - hslua-typing # dependency missing in job https://hydra.nixos.org/build/214600262 at 2023-04-07 - hsluv-haskell - hsmagick - hsmodetweaks @@ -2533,11 +2691,13 @@ broken-packages: - hsp-cgi - hspear - hspec2 + - hspec-api # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957655 at 2023-08-16 - hspec-expectations-match - hspec-experimental - hspec-jenkins - hspec-junit-formatter - hspec-monad-control + - hspec-need-env # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962402 at 2023-08-16 - hspec-slow - hspec-snap - hspec-structured-formatter @@ -2557,6 +2717,7 @@ broken-packages: - hs-rs-notify - hs-scrape - hsseccomp + - hsshellscript # failure building library in job https://hydra.nixos.org/build/230964557 at 2023-08-16 - hs-snowtify - hsSqlite3 - hssqlppp @@ -2586,6 +2747,7 @@ broken-packages: - HTicTacToe - htiled - htlset + - html-parse # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962751 at 2023-08-16 - html-rules - html-tokenizer - htoml @@ -2594,6 +2756,7 @@ broken-packages: - htsn - htssets - http2-client-exe + - http2-client # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949635 at 2023-08-16 - http2-grpc-types - http3 # dependency missing in job https://hydra.nixos.org/build/214603147 at 2023-04-07 - http-attoparsec @@ -2647,6 +2810,7 @@ broken-packages: - hVOIDP - hwall-auth-iitk - hw-ci-assist + - hw-dsv # failure building library in job https://hydra.nixos.org/build/230955653 at 2023-08-16 - hw-dump - hweblib - hwhile @@ -2658,12 +2822,15 @@ broken-packages: - hw-prim-bits - hw-simd-cli - hwsl2 + - hw-streams # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953855 at 2023-08-16 - hw-tar + - hw-xml # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966951 at 2023-08-16 - hx - hxmppc - HXQ - hxt-pickle-utils - hyakko + - hydra # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947287 at 2023-08-16 - hydra-hs - hydrogen - hydrogen-multimap @@ -2710,9 +2877,12 @@ broken-packages: - ihaskell-charts - ihaskell-diagrams - ihaskell-gnuplot + - ihaskell-graphviz # failure building library in job https://hydra.nixos.org/build/230959018 at 2023-08-16 - ihaskell-parsec - ihaskell-plot - ihaskell-widgets + - ihp-hsx # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971837 at 2023-08-16 + - ilist # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948898 at 2023-08-16 - illuminate - imagemagick - imagepaste @@ -2741,9 +2911,11 @@ broken-packages: - indices - infernal - inferno-types + - infernu # failure building library in job https://hydra.nixos.org/build/230972899 at 2023-08-16 - infer-upstream - inf-interval - infix + - inflections # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230960295 at 2023-08-16 - inflist - informative - inilist @@ -2753,6 +2925,7 @@ broken-packages: - inject-function - injections - inline-c-objc # failure building test suite 'tests' in job https://hydra.nixos.org/build/221844966 at 2023-05-30 + - inline-r # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/231676486 at 2023-08-16 - in-other-words-plugin - inserts - instana-haskell-trace-sdk @@ -2760,7 +2933,7 @@ broken-packages: - instant-generics - instapaper-sender - instinct - - integer-conversion # dependency missing in job https://hydra.nixos.org/build/225563519 at 2023-06-28 + - intcode # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963480 at 2023-08-16 - integer-pure - integer-simple - intensional-datatys @@ -2782,6 +2955,7 @@ broken-packages: - interval-tree-clock - IntFormats - int-interval-map + - int-like # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957175 at 2023-08-16 - int-multimap - intrinsic-superclasses - intro @@ -2808,6 +2982,7 @@ broken-packages: - IPv6DB - Irc - ircbot + - irc-core # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962123 at 2023-08-16 - irc-dcc - irc-fun-types - ireal @@ -2831,6 +3006,7 @@ broken-packages: - ivory - ixdopp - ixmonad + - ixset-typed # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967299 at 2023-08-16 - ixshader - j - jack-bindings @@ -2843,6 +3019,7 @@ broken-packages: - jammittools - jarfind - jarify + - jaskell # test failure in job https://hydra.nixos.org/build/230959845 at 2023-08-16 - jason - java-adt - javascript-bridge @@ -2864,6 +3041,7 @@ broken-packages: - join-api - joinlist - jonathanscard + - jordan # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965587 at 2023-08-16 - jort - joy-rewrite - jpeg @@ -2912,6 +3090,7 @@ broken-packages: - JuicyPixels-blurhash - JuicyPixels-canvas - JuicyPixels-util + - jukebox # failure building library in job https://hydra.nixos.org/build/230961139 at 2023-08-16 - JunkDB - jupyter - justified-containers @@ -2926,6 +3105,7 @@ broken-packages: - kalman - Kalman - kangaroo + - kanji # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967903 at 2023-08-16 - karabiner-config - karps - katip-datadog @@ -2981,9 +3161,11 @@ broken-packages: - ktx - kubernetes-client-core - kubernetes-webhook-haskell + - kudzu # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947047 at 2023-08-16 - kuifje - kure - KyotoCabinet + - l10n # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958884 at 2023-08-16 - labeled-graph - lagrangian - lambda2js @@ -3032,6 +3214,7 @@ broken-packages: - language-openscad - language-pig - language-rust + - language-sally # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953286 at 2023-08-16 - language-sh - language-sqlite - language-sygus @@ -3039,6 +3222,7 @@ broken-packages: - language-webidl - laop - LargeCardinalHierarchy + - large-generics # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948096 at 2023-08-16 - Lastik - latest-npm-version - latex-formulae-image @@ -3082,6 +3266,7 @@ broken-packages: - lens-text-encoding - lens-th-rewrite - lens-time + - lens-toml-parser # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971016 at 2023-08-16 - lens-tutorial - lens-typelevel - lens-xml @@ -3094,13 +3279,16 @@ broken-packages: - lhc - lhs2TeX-hl - lhslatex + - libarchive # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230954627 at 2023-08-16 - LibClang - libexpect - libGenI - libhbb - libinfluxdb - libjenkins + - libjwt-typed # failure building library in job https://hydra.nixos.org/build/230959244 at 2023-08-16 - libltdl + - libmdbx # failure in job https://hydra.nixos.org/build/230971264 at 2023-08-16 - liboath-hs - liboleg - libpafe @@ -3111,9 +3299,11 @@ broken-packages: - libssh2 # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/223222399 at 2023-06-07 - libsystemd-daemon - libtagc + - libtelnet # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948008 at 2023-08-16 - libxls - libxlsxwriter-hs - libxslt + - libyaml-streamly # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965706 at 2023-08-16 - libzfs - licensor - lie @@ -3136,8 +3326,11 @@ broken-packages: - linear-vect - line-bot-sdk - line-drawing + - line-indexed-cursor # test failure in job https://hydra.nixos.org/build/230971466 at 2023-08-16 + - linenoise # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230954880 at 2023-08-16 - lines-of-action - lingo + - linguistic-ordinals # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962191 at 2023-08-16 - linkedhashmap - linked-list-with-iterator - linklater @@ -3153,6 +3346,7 @@ broken-packages: - linx-gateway - lipsum-gen - liquid + - liquid-fixpoint # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948295 at 2023-08-16 - liquidhaskell-cabal - Liquorice - list-fusion-probe @@ -3169,6 +3363,7 @@ broken-packages: - lit - literals - LiterateMarkdown + - little-earley # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949904 at 2023-08-16 - ll-picosat - llsd - llvm-base @@ -3176,7 +3371,10 @@ broken-packages: - llvm-general-pure - llvm-hs - llvm-ht + - llvm-party # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967625 at 2023-08-16 - llvm-pretty + - llvm-tf # failure building library in job https://hydra.nixos.org/build/230970343 at 2023-08-16 + - lmdb-high-level # failure building library in job https://hydra.nixos.org/build/230954528 at 2023-08-16 - lmdb-simple - lmonad - lnurl @@ -3186,6 +3384,7 @@ broken-packages: - located - located-monad-logger - loch + - loc-test # failure in haddockPhase in job https://hydra.nixos.org/build/230967699 at 2023-08-16 - log2json - log-base - log-effect @@ -3202,6 +3401,8 @@ broken-packages: - lojbanXiragan - lol-calculus - longboi + - long-double # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964106 at 2023-08-16 + - looksee # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959202 at 2023-08-16 - lookup-tables - loopbreaker - loop-dsl @@ -3227,8 +3428,10 @@ broken-packages: - lua-bc - luautils - lucid2-htmx + - lucid-alpine # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948075 at 2023-08-16 - lucid-aria - lucid-hyperscript + - luhn # failure in compileBuildDriverPhase in job https://hydra.nixos.org/build/230960533 at 2023-08-16 - luis-client - luka - luminance @@ -3237,7 +3440,9 @@ broken-packages: - lvmlib - lvmrun - lxd-client + - lxd-client-config # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967232 at 2023-08-16 - lye + - lz4-bytes # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958626 at 2023-08-16 - lz4-frame-conduit - lzip - lzlib @@ -3280,16 +3485,19 @@ broken-packages: - marked-pretty - markov-realization - mars + - marshal-contt # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964051 at 2023-08-16 - marvin-interpolate - MASMGen - massiv-persist - massiv-scheduler - massiv-serialise - master-plan + - matcher # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947893 at 2023-08-16 - mathflow - math-grads - math-interpolate - math-metric + - math-programming # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964799 at 2023-08-16 - matrix-as-xyz - matrix-lens - matrix-market @@ -3304,16 +3512,19 @@ broken-packages: - MazesOfMonad - MBot - mbox-tools + - mbtiles # failure building library in job https://hydra.nixos.org/build/230947737 at 2023-08-16 - mbug - mcl - mcm - mcmaster-gloss-examples - mcmc-synthesis - mcpi + - md5 # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966189 at 2023-08-16 - mdapi - mdcat - mdp - mealstrom + - mealy # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952277 at 2023-08-16 - MeanShift - Measure - mecab @@ -3365,6 +3576,7 @@ broken-packages: - microformats2-parser - microgroove - microlens-each + - microlens-process # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957561 at 2023-08-16 - micrologger - micro-recursion-schemes - microsoft-translator @@ -3392,6 +3604,7 @@ broken-packages: - mios - MIP - mirror-tweet + - mismi-p # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949261 at 2023-08-16 - mismi-s3-core - miso-action-logger - miso-examples @@ -3409,6 +3622,7 @@ broken-packages: - mmsyn7ukr-common - mmtf - mmtl + - mmzk-typeid # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951832 at 2023-08-16 - Mobile-Legends-Hack-Cheats - mockazo - mock-httpd @@ -3446,9 +3660,11 @@ broken-packages: - monadloc-pp - monad-log - monadlog + - monad-logger-prefix # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955752 at 2023-08-16 - monad-logger-syslog - monad-lrs - monad-mersenne-random + - monad-metrics # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947569 at 2023-08-16 - monad-mock - monad-open - monad-parallel-progressbar @@ -3458,6 +3674,7 @@ broken-packages: - monad-ran - MonadRandomLazy - monad-recorder + - monad-skeleton # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956155 at 2023-08-16 - MonadStack - monad-statevar - monad-ste @@ -3479,6 +3696,7 @@ broken-packages: - mono-foldable - monoid - monoid-absorbing + - monoidal-functors # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956652 at 2023-08-16 - monoid-owns - monoidplus - monoids @@ -3507,8 +3725,11 @@ broken-packages: - mrifk - mrm - ms + - ms-auth # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947549 at 2023-08-16 + - ms-azure-api # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969734 at 2023-08-16 - msgpack - msgpack-types + - ms-graph-api # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953084 at 2023-08-16 - msh - mssql-simple - MTGBuilder @@ -3528,12 +3749,14 @@ broken-packages: - multiaddr - multiarg - multihash + - multi-instance # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230954844 at 2023-08-16 - multilinear - multipass - multipath - multiplate-simplified - multipool - multirec + - Munkres # failure building library in job https://hydra.nixos.org/build/230964280 at 2023-08-16 - Munkres-simple - muon - murmur @@ -3571,6 +3794,7 @@ broken-packages: - nano-cryptr - nanocurses - nano-hmac + - NanoID # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948998 at 2023-08-16 - nano-md5 - nanomsg - nanomsg-haskell @@ -3668,6 +3892,7 @@ broken-packages: - nix-freeze-tree - nixfromnpm - nixpkgs-update + - nix-serve-ng # failure building executable 'nix-serve' in job https://hydra.nixos.org/build/231635876 at 2023-08-16 - nix-tools - nlp-scores - nm @@ -3684,10 +3909,13 @@ broken-packages: - non-empty-containers - nonempty-lift - non-empty-zipper + - nonlinear-optimization # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950369 at 2023-08-16 - noodle + - normalization-insensitive # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969473 at 2023-08-16 - no-role-annots - notcpp - notmuch-haskell + - not-prelude # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947663 at 2023-08-16 - NoTrace - notzero - np-linear @@ -3696,19 +3924,23 @@ broken-packages: - ntp-control - ntrip-client - n-tuple + - nuha # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959017 at 2023-08-16 - nullary - null-canvas - nullpipe - NumberSieves - NumberTheory + - number-wall # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947084 at 2023-08-16 - numeric-qq - numeric-ranges - numhask-free - numhask-histogram - numhask-prelude + - numhask-space # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958208 at 2023-08-16 - numtype - numtype-tf - Nutri + - nvfetcher # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/231635785 at 2023-08-16 - nvim-hs-ghcid - NXT - NXTDSL @@ -3751,6 +3983,7 @@ broken-packages: - om-time - on-a-horse - onama + - ONC-RPC # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952342 at 2023-08-16 - on-demand-ssh-tunnel - oneormore - onpartitions @@ -3788,6 +4021,7 @@ broken-packages: - opentelemetry-extra - opentelemetry-http-client - opentheory-char + - opentracing # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951073 at 2023-08-16 - opentype - open-typerep - OpenVGRaw @@ -3814,10 +4048,13 @@ broken-packages: - organize-imports - orgmode - orgmode-parse + - org-parser # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971946 at 2023-08-16 - origami - orion-hs - orizentic - OrPatterns + - ory-hydra-client # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971097 at 2023-08-16 + - ory-kratos # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968815 at 2023-08-16 - osc - oscpacking - oset @@ -3837,6 +4074,7 @@ broken-packages: - owoify-hs - pack - package-description-remote + - package-version # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230960762 at 2023-08-16 - package-vt - packdeps - packed @@ -3856,17 +4094,21 @@ broken-packages: - pagure-hook-receiver - PandocAgda - pandoc-citeproc - - pandoc-emphasize-code + - pandoc-columns # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956006 at 2023-08-16 + - pandoc-csv2table # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968874 at 2023-08-16 - pandoc-filter-graphviz - pandoc-filter-indent - pandoc-include + - pandoc-include-plus # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962699 at 2023-08-16 - pandoc-lens - - pandoc-lua-engine + - pandoc-linear-table # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968966 at 2023-08-16 + - pandoc-link-context # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972013 at 2023-08-16 + - pandoc-logic-proof # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961625 at 2023-08-16 - pandoc-markdown-ghci-filter - pandoc-placetable - pandoc-plantuml-diagrams - pandoc-pyplot - - pandoc-server + - pandoc-select-code # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956087 at 2023-08-16 - pandoc-unlit - pandoc-utils - pandora @@ -3920,6 +4162,7 @@ broken-packages: - parsers-megaparsec - parser-unbiased-choice-monad-embedding - parsimony + - parsix # failure building library in job https://hydra.nixos.org/build/230966036 at 2023-08-16 - parsnip - partage - partial-lens @@ -3937,6 +4180,7 @@ broken-packages: - patches-vector - Pathfinder - pathfindingcore + - path-formatting # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969881 at 2023-08-16 - PathTree - patrol - patronscraper @@ -3987,10 +4231,12 @@ broken-packages: - persistent-generic - persistent-mongoDB - persistent-odbc + - persistent-postgresql-streaming # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967419 at 2023-08-16 - persistent-ratelimit - persistent-stm - persistent-template-classy - persistent-zookeeper + - persist # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970536 at 2023-08-16 - persist-state - persona - pesca @@ -4009,6 +4255,7 @@ broken-packages: - phasechange - phaser - phoityne + - phoityne-vscode # failure building executable 'phoityne-vscode' in job https://hydra.nixos.org/build/230958609 at 2023-08-16 - phone-metadata - phone-numbers - phone-push @@ -4044,6 +4291,7 @@ broken-packages: - Pipe - pipes-async - pipes-bgzf + - pipes-break # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950050 at 2023-08-16 - pipes-brotli - pipes-category - pipes-cereal @@ -4051,6 +4299,8 @@ broken-packages: - pipes-errors - pipes-interleave - pipes-io + - pipes-lines # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965615 at 2023-08-16 + - pipes-lzma # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230954108 at 2023-08-16 - pipes-network-ws # failure building library in job https://hydra.nixos.org/build/214504366 at 2023-04-07 - pipes-protolude - pipes-rt @@ -4121,41 +4371,52 @@ broken-packages: - polynomial - polysemy-check - polysemy-keyed-state + - polysemy-kvstore # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971431 at 2023-08-16 - polysemy-kvstore-jsonfile + - polysemy-managed # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972262 at 2023-08-16 - polysemy-methodology-co-log - polysemy-mocks - polysemy-path - polysemy-readline - polysemy-req - polysemy-resume + - polysemy-several # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969795 at 2023-08-16 - polysemy-socket - polysemy-video - polysemy-vinyl + - polysemy-zoo # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962140 at 2023-08-16 - poly # test failure in job https://hydra.nixos.org/build/225574715 at 2023-06-28 - polytypeable + - polyvariadic # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956502 at 2023-08-16 - pomaps - pomohoro - ponder - pong-server + - pontarius-xmpp-extras # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/231689607 at 2023-08-16 - pontarius-xpmn - pool - poolboy # test failure in job https://hydra.nixos.org/build/212819440 at 2023-03-26 - pool-conduit - pop3-client + - popkey # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964862 at 2023-08-16 - poppler - porpoise - portager - porte - PortFusion + - posable # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948222 at 2023-08-16 - posit - positron - posix-acl + - posix-api # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230954850 at 2023-08-16 - posix-realtime - posix-waitpid + - posplyu # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957556 at 2023-08-16 - postcodes - postgres-embedded - PostgreSQL - postgresql-common + - postgresql-config # failure building library in job https://hydra.nixos.org/build/230957015 at 2023-08-16 - postgresql-cube - postgresql-lo-stream - postgresql-ltree @@ -4207,6 +4468,7 @@ broken-packages: - press - pretty-compact - pretty-ghci + - pretty-loc # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953975 at 2023-08-16 - pretty-ncols - prettyprinter-vty - prim @@ -4218,11 +4480,14 @@ broken-packages: - PrimitiveArray - PrimitiveArray-Pretty - primitive-atomic + - primitive-checked # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957933 at 2023-08-16 - primitive-convenience - primitive-foreign - primitive-indexed - primitive-maybe + - primitive-primvar # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951857 at 2023-08-16 - primitive-simd + - primitive-slice # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949991 at 2023-08-16 - primitive-sort - primitive-stablename - prim-ref @@ -4233,6 +4498,7 @@ broken-packages: - prints - PriorityChansConverger - priority-queue + - pro-abstract # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968325 at 2023-08-16 - probable - prob-fx - Probnet @@ -4247,6 +4513,7 @@ broken-packages: - product-isomorphic - prof2pretty - prof-flamegraph + - profiteur # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962019 at 2023-08-16 - profunctor-monad - progression - progressive @@ -4259,6 +4526,7 @@ broken-packages: - prolens - prolog - prometheus-effect + - prometheus # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959996 at 2023-08-16 - prometheus-proc - promise - pronounce @@ -4267,14 +4535,16 @@ broken-packages: - Proper - properties - property-list + - prop-unit # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950936 at 2023-08-16 - proquint # failure in job https://hydra.nixos.org/build/215308028 at 2023-04-11 - prosidy + - pro-source # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963769 at 2023-08-16 - prosper - - proteaaudio - - proteaaudio-sdl + - proteaaudio # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950003 at 2023-08-16 - protocol - protocol-buffers - protocol-buffers-fork + - proto-lens-arbitrary # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230953387 at 2023-08-16 - proto-lens-combinators - protolude-lifted - proton-haskell @@ -4287,6 +4557,7 @@ broken-packages: - psc-ide - pseudo-trie - psi + - pstemmer # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230955354 at 2023-08-16 - psx - PTQ - pub @@ -4305,6 +4576,7 @@ broken-packages: - purescript-cst - purescript-tsd-gen - pure-zlib + - purview # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961366 at 2023-08-16 - pushbullet - pushbullet-types - pusher-haskell @@ -4313,6 +4585,7 @@ broken-packages: - push-notifications - putlenses - puzzle-draw + - pvector # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952685 at 2023-08-16 - pyffi - pyfi - python-pickle @@ -4341,9 +4614,12 @@ broken-packages: - querystring-pickle - questioner - quibble-core + - quic # failure building library in job https://hydra.nixos.org/build/230948542 at 2023-08-16 - QuickAnnotate - quickbooks - quickcheck-arbitrary-template + - quickcheck-combinators # failure building library in job https://hydra.nixos.org/build/230952645 at 2023-08-16 + - quickcheck-dynamic # failure building library in job https://hydra.nixos.org/build/230963873 at 2023-08-16 - quickcheck-groups - quickcheck-lockstep # dependency missing in job https://hydra.nixos.org/build/210845914 at 2023-02-28 - quickcheck-monoid-subclasses @@ -4381,6 +4657,7 @@ broken-packages: - raml - rando - random-access-list + - random-cycle # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957192 at 2023-08-16 - random-derive - RandomDotOrg - random-eff @@ -4394,6 +4671,7 @@ broken-packages: - rangeset - rank1dynamic - rank-product + - rapid # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958426 at 2023-08-16 - rapid-term - Rasenschach - rating-chgk-info @@ -4405,6 +4683,7 @@ broken-packages: - raz - rbst - rclient + - rdf4h # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965619 at 2023-08-16 - react-flux - react-haskell - reaction-logic @@ -4434,6 +4713,7 @@ broken-packages: - records-sop - record-wrangler - recover-rtti + - rec-smallarray # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971840 at 2023-08-16 - recursors - red-black-record - redis-glob @@ -4457,6 +4737,7 @@ broken-packages: - reflex-dom-contrib - reflex-dom-fragment-shader-canvas - reflex-dom-helpers + - reflex-dom-pandoc # failure building library in job https://hydra.nixos.org/build/230953122 at 2023-08-16 - reflex-dom-retractable - reflex-dom-svg - reflex-external-ref @@ -4472,6 +4753,9 @@ broken-packages: - reflex-vty - ref-mtl - reformat + - reform-hamlet # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965992 at 2023-08-16 + - reform-hsp # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230957580 at 2023-08-16 + - reform-lucid # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968858 at 2023-08-16 - refresht - refty - refurb @@ -4502,6 +4786,7 @@ broken-packages: - reify - relacion - relation + - releaser # failure building library in job https://hydra.nixos.org/build/230963399 at 2023-08-16 - relevant-time - reload - remark @@ -4510,10 +4795,12 @@ broken-packages: - remote-debugger - remote-monad - reorderable + - reorder-expression # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952702 at 2023-08-16 - repa-bytestring - repa-devil - repa-eval - repa-examples + - repa # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959980 at 2023-08-16 - repa-linear-algebra - repa-scalar - repa-series @@ -4524,6 +4811,7 @@ broken-packages: - repl-toolkit - repo-based-blog - representable-functors + - reprinter # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970043 at 2023-08-16 - reproject - req-conduit - request @@ -4536,9 +4824,10 @@ broken-packages: - resolve-trivial-conflicts - resource-effect - resource-embed + - resource-pool-monad # failure building library in job https://hydra.nixos.org/build/230949096 at 2023-08-16 + - resourcet-pool # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950524 at 2023-08-16 - respond - restartable - - rest-rewrite - restyle - resumable-exceptions - rethinkdb @@ -4573,6 +4862,7 @@ broken-packages: - rivet-simple-deploy - RJson - Rlang-QQ + - rle # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950686 at 2023-08-16 - rlglue - RLP - rl-satton @@ -4591,6 +4881,7 @@ broken-packages: - rosebud - rose-trees - rosmsg + - rospkg # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/231689673 at 2023-08-16 - rosso - rotating-log - rounded @@ -4601,6 +4892,7 @@ broken-packages: - rpc-framework - rpm - rpmbuild-order + - rpmostree-update # failure building executable 'rpmostree-update' in job https://hydra.nixos.org/build/230963857 at 2023-08-16 - rrule - rspp - rss2irc @@ -4610,6 +4902,7 @@ broken-packages: - rtorrent-rpc - rtorrent-state - rts-loader + - rubberband # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972230 at 2023-08-16 - ruby-marshal - ruby-qq - ruff @@ -4653,6 +4946,7 @@ broken-packages: - sat - satchmo-backends - satchmo-minisat + - saturn # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961398 at 2023-08-16 - Saturnin - satyros - savage @@ -4663,6 +4957,7 @@ broken-packages: - scaleimage - scalendar - s-cargot-letbind + - scat # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970581 at 2023-08-16 - scc - schedevr - schedule-planner @@ -4695,6 +4990,10 @@ broken-packages: - sdl2-cairo-image - sdl2-compositor - sdl2-fps + - sdl2-gfx # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947327 at 2023-08-16 + - sdl2-image # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965350 at 2023-08-16 + - sdl2-mixer # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969457 at 2023-08-16 + - sdl2-ttf # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963820 at 2023-08-16 - sdp - sdr - seacat @@ -4711,6 +5010,7 @@ broken-packages: - secure-sockets - secureUDP - SegmentTree + - selda # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970840 at 2023-08-16 - selda-postgresql - selectors - selenium @@ -4719,6 +5019,8 @@ broken-packages: - semaphore-compat # dependency missing in job https://hydra.nixos.org/build/214509429 at 2023-04-07 - semdoc - semialign-extras + - semialign-indexed # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950953 at 2023-08-16 + - semialign-optics # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950916 at 2023-08-16 - semibounded-lattices - Semigroup - semigroupoids-syntax @@ -4733,20 +5035,25 @@ broken-packages: - SeqAlign - sequent-core - sequential-index + - serf # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970238 at 2023-08-16 - serialize-instances + - serialport # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962754 at 2023-08-16 - serokell-util - servant-aeson-specs - servant-auth-cookie - servant-auth-hmac + - servant-auth-server # failure building test suite 'spec' in job https://hydra.nixos.org/build/230968407 at 2023-08-16 - servant-avro - servant-benchmark - servant-client-js + - servant-combinators # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950496 at 2023-08-16 - servant-db - servant-dhall - servant-docs-simple - servant-elm - servant-errors - servant-event-stream + - servant-foreign # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967834 at 2023-08-16 - servant-gdp - servant-generate - servant-generic @@ -4755,8 +5062,10 @@ broken-packages: - servant-hmac-auth - servant-htmx - servant-http2-client + - servant-http-streams # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956465 at 2023-08-16 - servant-iCalendar - servant-jquery + - servant-JuicyPixels # failure building library in job https://hydra.nixos.org/build/230963492 at 2023-08-16 - servant-kotlin - servant-mock - servant-namedargs @@ -4798,6 +5107,7 @@ broken-packages: - setters - set-with - sexp + - sexpr-parser # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967001 at 2023-08-16 - sext - SFML - sfml-audio @@ -4821,9 +5131,12 @@ broken-packages: - sha-streams - she - Shellac + - shellify # failure building test suite 'haskelltest-test' in job https://hydra.nixos.org/build/230963414 at 2023-08-16 - shellish - shellmate + - shellmet # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972264 at 2023-08-16 - shell-pipe + - shikensu # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951632 at 2023-08-16 - shimmer - shine-examples - shivers-cfg @@ -4834,12 +5147,14 @@ broken-packages: - shorten-strings - short-vec - show-prettyprint + - show-type # failure building library in job https://hydra.nixos.org/build/230946625 at 2023-08-16 - Shpadoinkle-console - Shpadoinkle-debug - Shpadoinkle-isreal - shwifty - sifflet - sifflet-lib + - sigmacord # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948674 at 2023-08-16 - signable - signable-haskell-protoc - signed-multiset @@ -4855,6 +5170,7 @@ broken-packages: - simpleconfig - simple-css - simple-download + - simple-effects # failure building library in job https://hydra.nixos.org/build/230951952 at 2023-08-16 - simple-eval - simple-form - simple-genetic-algorithm @@ -4863,9 +5179,11 @@ broken-packages: - simpleirc - simple-log - simple-logging + - simple-media-timestamp-formatting # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946985 at 2023-08-16 - simple-money - simple-neural-networks - simplenote + - simple-parser # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951616 at 2023-08-16 - simple-pipe - simpleprelude - simple-rope @@ -4889,6 +5207,7 @@ broken-packages: - singnal - singular-factory - sink + - sint # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966755 at 2023-08-16 - siphash - sitepipe - sixfiguregroup @@ -4931,9 +5250,12 @@ broken-packages: - smartconstructor - smartGroup - smash + - smawk # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963766 at 2023-08-16 - sme - smerdyakov - smiles + - smith # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230967626 at 2023-08-16 + - SmithNormalForm # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970411 at 2023-08-16 - smoothie - smsaero - smt-lib @@ -4966,6 +5288,7 @@ broken-packages: - snaplet-mongodb-minimalistic - snaplet-mysql-simple - snaplet-postgresql-simple + - snaplet-purescript # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971794 at 2023-08-16 - snaplet-recaptcha - snaplet-redis - snaplet-sass @@ -5008,6 +5331,7 @@ broken-packages: - source-constraints - sousit - soyuz + - SpaceInvaders # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963310 at 2023-08-16 - spacepart - spade # dependency missing in job https://hydra.nixos.org/build/225563353 at 2023-06-28 - spake2 @@ -5016,13 +5340,17 @@ broken-packages: - sparse - sparsecheck - sparse-lin-alg + - sparse-linear-algebra # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966041 at 2023-08-16 + - sparse-merkle-trees # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948641 at 2023-08-16 - sparse-tensor + - spdx # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970358 at 2023-08-16 - special-functors - special-keys - spectacle - speculation - sphinx - sphinxesc + - Spintax # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964258 at 2023-08-16 - spiros - spir-v - splay @@ -5033,11 +5361,13 @@ broken-packages: - Spock-api-ghcjs - Spock-auth - spoonutil + - spotify # test failure in job https://hydra.nixos.org/build/230953177 at 2023-08-16 - spoty - Sprig - spritz - spsa - spy + - sqids # test failure in job https://hydra.nixos.org/build/230970531 at 2023-08-16 - sqlcipher - sqlite - sqlite-easy @@ -5045,11 +5375,13 @@ broken-packages: - sql-simple - sqlvalue-list - srcinst + - srt-attoparsec # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966533 at 2023-08-16 - srt-dhall - sscan - ssh - ssh-tunnel - SSTG + - st2 # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965507 at 2023-08-16 - stable-heap - stable-maps - stable-marriage @@ -5072,6 +5404,7 @@ broken-packages: - standalone-derive-topdown - standalone-haddock - starling + - starter # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947332 at 2023-08-16 - stash - Stasis - state @@ -5112,6 +5445,7 @@ broken-packages: - Stomp - stooq-api - storable + - storable-offset # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956457 at 2023-08-16 - storable-static-array - stp - str @@ -5136,10 +5470,13 @@ broken-packages: - streaming-png - streaming-postgresql-simple - streaming-sort + - streaming-with # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956271 at 2023-08-16 - streamly-binary - streamly-cassava - streamly-examples + - streamly-fsnotify # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946720 at 2023-08-16 - streamly-lz4 + - streamly-posix # failure building library in job https://hydra.nixos.org/build/230968738 at 2023-08-16 - streamly-process - stream-monad - streamproc @@ -5150,6 +5487,7 @@ broken-packages: - strict-ghc-plugin - strictly - strict-tuple-lens + - string-class # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230948470 at 2023-08-16 - string-conv-tests - string-fromto - string-isos @@ -5167,6 +5505,7 @@ broken-packages: - stt - stunclient - stylish-cabal + - stylist # failure building test suite 'test-stylist' in job https://hydra.nixos.org/build/230952543 at 2023-08-16 - stylized - subG-instances - subleq-toolchain @@ -5218,15 +5557,16 @@ broken-packages: - swiss-ephemeris - sws - syb-extras + - syb-with-class # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230970380 at 2023-08-16 - syb-with-class-instances-text - sydtest-hedis # test failure in job https://hydra.nixos.org/build/225562212 at 2023-06-28 + - sydtest-hspec # failure building library in job https://hydra.nixos.org/build/230968205 at 2023-08-16 - sydtest-mongo # failure in job https://hydra.nixos.org/build/225574398 at 2023-06-28 - sydtest-persistent-postgresql # test failure in job https://hydra.nixos.org/build/225560820 at 2023-06-28 - sydtest-persistent-sqlite # test failure in job https://hydra.nixos.org/build/225566898 at 2023-06-28 - sydtest-rabbitmq # test failure in job https://hydra.nixos.org/build/225569272 at 2023-06-28 - sydtest-webdriver # test failure in job https://hydra.nixos.org/build/225552802 at 2023-06-28 - syfco - - sym - symantic - symantic-cli - symantic-http-client @@ -5237,6 +5577,7 @@ broken-packages: - symengine-hs - sync - sync-mht + - syntactic # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958352 at 2023-08-16 - syntax-trees - syntax-trees-fork-bairyn - synthesizer # dependency missing in job https://hydra.nixos.org/build/217577245 at 2023-04-29 @@ -5268,8 +5609,10 @@ broken-packages: - tagsoup-megaparsec - tagsoup-parsec - tagsoup-selection + - tagtree # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961266 at 2023-08-16 - tai - tai64 + - tailwind # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/231536572 at 2023-08-16 - tak - takahashi - Takusen @@ -5287,6 +5630,7 @@ broken-packages: - tasty-mgolden - tasty-papi # test failure in job https://hydra.nixos.org/build/216756583 at 2023-04-20 - tasty-stats + - tasty-test-reporter # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958587 at 2023-08-16 - tasty-test-vector - TastyTLT - TBC @@ -5312,6 +5656,8 @@ broken-packages: - teleshell - tellbot - template-default + - template # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971653 at 2023-08-16 + - template-haskell-optics # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946806 at 2023-08-16 - template-haskell-util - template-hsml - templateify @@ -5331,6 +5677,7 @@ broken-packages: - tesla - testCom - testcontainers + - TestExplode # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964283 at 2023-08-16 - test-fixture - test-framework-doctest - test-framework-quickcheck @@ -5347,11 +5694,13 @@ broken-packages: - test-shouldbe - tex2txt - texbuilder + - tex-join-bib # failure building library in job https://hydra.nixos.org/build/230946498 at 2023-08-16 - text1 - text-all - text-and-plots - text-ascii - text-builder-linear + - text-compression # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952349 at 2023-08-16 - text-containers - text-display - text-format-heavy @@ -5365,6 +5714,7 @@ broken-packages: - text-offset - text-position - text-register-machine + - text-stream-decode # failure building library in job https://hydra.nixos.org/build/230960721 at 2023-08-16 - text-trie - textual - text-utf7 @@ -5378,6 +5728,7 @@ broken-packages: - th-build - th-dict-discovery - THEff + - themoviedb # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961888 at 2023-08-16 - thentos-cookie-session - Theora - theoremquest @@ -5401,6 +5752,7 @@ broken-packages: - Thrift - throttled-io-loop - throttle-io-stream + - through-text # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972325 at 2023-08-16 - throwable-exceptions - th-sccs - th-tc @@ -5453,9 +5805,12 @@ broken-packages: - Titim - tkhs - tkyprof + - tls-debug # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964438 at 2023-08-16 + - TLT # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947319 at 2023-08-16 - tmp-proc-example - tofromxml - to-haskell + - toilet # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230965271 at 2023-08-16 - token-bucket - tokenify - tokenizer @@ -5466,7 +5821,6 @@ broken-packages: - tokyocabinet-haskell - tokyotyrant-haskell - toml - - toml-parser - tonalude - tonaparser - toodles @@ -5503,6 +5857,7 @@ broken-packages: - transient - translatable-intset - translate + - traverse-code # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230968928 at 2023-08-16 - travis - travis-meta-yaml - trawl @@ -5526,6 +5881,7 @@ broken-packages: - trivia - tropical - tropical-geometry + - trust-chain # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230956012 at 2023-08-16 - tsession - tslib - tsparse @@ -5547,6 +5903,7 @@ broken-packages: - turing-machines - turing-music - turtle-options + - twain # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230972118 at 2023-08-16 - tweak - twentefp-websockets - twfy-api-client @@ -5558,6 +5915,7 @@ broken-packages: - twirp - twisty - twitchapi + - twitch # failure building test suite 'unit-tests' in job https://hydra.nixos.org/build/230961695 at 2023-08-16 - twitter - twitter-feed - tx @@ -5567,10 +5925,12 @@ broken-packages: - typalyze - typeable-th - type-combinators + - type-compare # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964481 at 2023-08-16 - TypeCompose - typed-digits - typed-encoding - typedquery + - typed-spreadsheet # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959517 at 2023-08-16 - typed-time - typed-wire - type-eq @@ -5589,8 +5949,10 @@ broken-packages: - type-list - typelits-witnesses - type-of-html-static + - type-operators # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949643 at 2023-08-16 - typeparams - type-prelude + - typerep-map # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230969193 at 2023-08-16 - type-safe-avl - types-compat - type-settheory @@ -5604,6 +5966,7 @@ broken-packages: - uAgda - uberlast - ucam-webauth-types + - ucl # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952255 at 2023-08-16 - uconv - udbus - udp-conduit @@ -5632,7 +5995,9 @@ broken-packages: - unicode-symbols - unicode-tricks - uniform-json # failure building test suite 'json-test' in job https://hydra.nixos.org/build/214602707 at 2023-04-07 + - union-find # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230950510 at 2023-08-16 - union-map + - unionmount # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230961993 at 2023-08-16 - uniprot-kb - uniqueid - uniquely-represented-sets @@ -5641,6 +6006,7 @@ broken-packages: - uniqueness-periods-vector-common - units-attoparsec - unittyped + - unitym # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230958411 at 2023-08-16 - unitym-yesod - uni-util - universal-binary @@ -5660,6 +6026,7 @@ broken-packages: - unordered-intmap - unpacked-either - unpacked-maybe + - unpacked-maybe-numeric # failure building library in job https://hydra.nixos.org/build/230962818 at 2023-08-16 - unpack-funcs - unroll-ghc-plugin - unsafely @@ -5670,6 +6037,7 @@ broken-packages: - Updater - uploadcare - upskirt + - urbit-hob # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966459 at 2023-08-16 - uri - uri-conduit - uri-encoder @@ -5682,11 +6050,13 @@ broken-packages: - urldecode - url-decoders - urldisp-happstack + - urlencoded # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946607 at 2023-08-16 - url-generic - urn - urn-random - urxml - useragents + - userid # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230959568 at 2023-08-16 - users-persistent - utc - utf8-conversions @@ -5705,15 +6075,18 @@ broken-packages: - uxadt - vabal-lib - vacuum + - vado # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947987 at 2023-08-16 - validated-types - Validation - validations + - validators # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966128 at 2023-08-16 - validity-network-uri - valid-names - value-supply - vampire - var - varan + - variable-media-field # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230971903 at 2023-08-16 - variables - variadic - variation @@ -5727,6 +6100,7 @@ broken-packages: - vect-floating - vect-opengl - vector-bytestring + - vector-circular # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951925 at 2023-08-16 - vector-clock - vector-conduit - vector-doublezip @@ -5737,11 +6111,13 @@ broken-packages: - vector-quicksort # dependency missing in job https://hydra.nixos.org/build/216753081 at 2023-04-20 - vector-random - vector-read-instances + - vector-shuffling # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963853 at 2023-08-16 - vector-space-map - vector-space-opengl - vector-space-points - vector-static - vega-view + - velma # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230963085 at 2023-08-16 - Verba - verbalexpressions - verdict @@ -5813,6 +6189,7 @@ broken-packages: - wai-responsible - wai-router - wai-routes + - wai-saml2 # test failure in job https://hydra.nixos.org/build/230969677 at 2023-08-16 - wai-secure-cookies - wai-session-mysql - wai-session-postgresql @@ -5821,6 +6198,7 @@ broken-packages: - waitfree - wai-throttler - waitra + - wakame # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947444 at 2023-08-16 - wallpaper - warc - warp-dynamic @@ -5838,7 +6216,9 @@ broken-packages: - web3-ipfs - webapi - webapp + - webauthn # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230964346 at 2023-08-16 - WebBits + - webby # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230952008 at 2023-08-16 - webcrank - webcrank-dispatch - web-css @@ -5852,6 +6232,7 @@ broken-packages: - webmention - web-output - web-page + - web-plugins # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962603 at 2023-08-16 - web-push - Webrexp - web-routes-quasi @@ -5872,10 +6253,13 @@ broken-packages: - whois - why3 - wide-word-instances # failure building library in job https://hydra.nixos.org/build/211245524 at 2023-03-13 + - wikicfp-scraper # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946581 at 2023-08-16 - WikimediaParser + - wild-bind # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230951433 at 2023-08-16 - willow - windns - windowslive + - window-utils # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962777 at 2023-08-16 - winerror - wireguard-hs - wires @@ -5948,11 +6332,13 @@ broken-packages: - xml-conduit-decode - xml-conduit-parse - xml-conduit-selectors + - xml-conduit-stylist # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230949082 at 2023-08-16 - xml-html-conduit-lens - XmlHtmlWriter - xml-parsec - xml-prettify - xml-prettify-text + - xml-query # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230947454 at 2023-08-16 - xml-query-xml-types - xml-syntax - xml-to-json @@ -6062,6 +6448,7 @@ broken-packages: - yesod-sass - yesod-static-angular - yesod-static-remote + - yesod-static-streamly # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230966153 at 2023-08-16 - yesod-test-json - yesod-text-markdown - yesod-tls @@ -6087,6 +6474,7 @@ broken-packages: - z85 - zabt - zampolit + - zbar # failure in setupCompilerEnvironmentPhase in job https://hydra.nixos.org/build/230967764 at 2023-08-16 - Z-Data - ZEBEDDE - zendesk-api @@ -6107,6 +6495,7 @@ broken-packages: - zipedit - zipkin - ziptastic-core + - zlib-bytes # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230946586 at 2023-08-16 - zlib-lens - ZMachine - zmidi-score @@ -6117,6 +6506,7 @@ broken-packages: - zsdd - zsh-battery - zsyntax + - ztail # failure in updateAutotoolsGnuConfigScriptsPhase in job https://hydra.nixos.org/build/230962012 at 2023-08-16 - ztar - zuul - Zwaluw diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index 83824730c817..9f32c9011113 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -36,18 +36,6 @@ default-package-overrides: # hnix < 0.17 (unreleased) needs hnix-store-* 0.5.* - hnix-store-core == 0.5.0.0 # 2022-06-17: Until hnix 0.17 - hnix-store-remote == 0.5.0.0 # 2022-06-17: Until hnix 0.17 - # reflex-dom-core 0.7.0.2 has no reflex 0.9 compatible release and most likely most people will want to use them together - - reflex < 0.9.0.0 - # required by haskell-language-server 1.9.0.0 - - implicit-hie < 0.1.3 - # latest version requires Cabal >= 3.8 - - shake-cabal < 0.2.2.3 - # needed as long as we have pandoc < 3.0, i.e. stackage lts 20 - - pandoc-crossref < 0.3.15.0 - # Needs to match hspec which is tracked in stackage - - hspec-api < 2.10 - # 2023-04-13: latest version requires ghc-events >= 0.19 but it's not on LTS yet - - eventlog2html < 0.10 # 2023-04-22: For dhall < 1.42 compatibility - dhall-nixpkgs == 1.0.9 @@ -58,14 +46,25 @@ default-package-overrides: - lsp-types == 1.6.* - lsp-test == 0.14.* + # 2023-07-06: ghcide-2.0.0.1 explicitly needs implicit-hie < 0.1.3, because some sort of + # breaking change was introduced in implicit-hie-0.1.3.0. + # https://github.com/haskell/haskell-language-server/blob/feb596592de95f09cf4ee885f3e74178161919f1/ghcide/ghcide.cabal#L107-L111 + - implicit-hie < 0.1.3 + + # 2023-07-06: newer versions of stylish-haskell require + # ghc-lib-parser-ex >= 9.6, but LTS-21 contains ghc-lib-parser-ex-9.4 + - stylish-haskell < 0.14.5.0 + + # Only an older version of dependent-sum-template is compatible with ghc 9.4 + # https://github.com/obsidiansystems/dependent-sum-template/issues/5 + - dependent-sum-template < 0.1.2 + extra-packages: - - Cabal == 2.2.* # required for jailbreak-cabal etc. - - Cabal == 2.4.* # required for cabal-install etc. - - Cabal == 3.2.* # required for cabal2spec - - Cabal == 3.4.* # required for cabal-install etc. - - Cabal == 3.6.* - - Cabal-syntax == 3.8.* # required for cabal-install{,-parsers} - - Cabal == 3.8.* # required for cabal-install{,-parsers} + - Cabal-syntax == 3.6.* # Dummy package that ensures packages depending on Cabal-syntax can work for Cabal < 3.8 + - Cabal == 3.2.* # Used for packages needing newer Cabal on ghc 8.6 and 8.8 + - Cabal == 3.6.* # used for packages needing newer Cabal on ghc 8.10 and 9.0 + - Cabal-syntax == 3.8.* # version required for ormolu and fourmolu on ghc 9.2 and 9.0 + - Cabal-syntax == 3.10.* # newest version required for cabal-install and other packages - cachix < 1.4 # 2023-04-02: cachix 1.4{,.1} have known on multi-user Nix systems - directory == 1.3.7.* # required to build cabal-install 3.10.* with GHC 9.2 - Diff < 0.4 # required by liquidhaskell-0.8.10.2: https://github.com/ucsd-progsys/liquidhaskell/issues/1729 @@ -86,10 +85,10 @@ extra-packages: - dhall == 1.38.1 # required for spago - doctest == 0.18.* # 2021-11-19: closest to stackage version for GHC 9.* - foundation < 0.0.29 # 2022-08-30: last version to support GHC < 8.10 - - fourmolu == 0.3.0.0 # 2022-09-21: needed for hls on ghc 8.8 - ghc-api-compat == 8.10.7 # 2022-02-17: preserve for GHC 8.10.7 - ghc-api-compat == 8.6 # 2021-09-07: preserve for GHC 8.8.4 - ghc-exactprint == 0.6.* # 2022-12-12: needed for GHC < 9.2 + - ghc-exactprint == 1.5.* # 2023-03-30: needed for GHC == 9.2 - ghc-exactprint == 1.6.* # 2023-03-30: needed for GHC == 9.4 - ghc-lib == 8.10.7.* # 2022-02-17: preserve for GHC 8.10.7 - ghc-lib == 9.2.* # 2022-02-17: preserve for GHC 9.2 @@ -105,11 +104,9 @@ extra-packages: - haddock-api == 2.23.* # required on GHC < 8.10.x - haddock-library ==1.7.* # required by stylish-cabal-0.5.0.0 - happy == 1.19.12 # for ghcjs - - hermes-json == 0.2.* # 2023-03-22: for nix-output-monitor-2.0.0.5 - hinotify == 0.3.9 # for xmonad-0.26: https://github.com/kolmodin/hinotify/issues/29 - hlint == 3.2.8 # 2022-09-21: needed for hls on ghc 8.8 - hlint == 3.4.1 # 2022-09-21: needed for hls with ghc-lib-parser 9.2 - - hpack == 0.35.0 # 2022-09-29: Needed for stack-2.9.1 - hspec < 2.8 # 2022-04-07: Needed for tasty-hspec 1.1.6 - hspec-core < 2.8 # 2022-04-07: Needed for tasty-hspec 1.1.6 - hspec-discover < 2.8 # 2022-04-07: Needed for tasty-hspec 1.1.6 @@ -124,26 +121,28 @@ extra-packages: - mmorph == 1.1.3 # Newest working version of mmorph on ghc 8.6.5. needed for hls - network == 2.6.3.1 # required by pkgs/games/hedgewars/default.nix, 2020-11-15 - optparse-applicative < 0.16 # needed for niv-0.2.19 - - ormolu == 0.1.4.1 # 2022-09-21: needed for hls on ghc 8.8 - - ormolu == 0.2.* # 2022-02-21: For ghc 8.8 and 8.10 - - ormolu == 0.5.* # 2022-04-12: For ghc 9.4 + - ormolu == 0.5.0.1 # 2022-02-21: for hls on ghc 8.10 + - ormolu == 0.5.2.0 # 2023-08-08: for hls on ghc 9.0 and 9.2 + - fourmolu == 0.9.0.0 # 2022-09-21: for hls on ghc 8.10 + - fourmolu == 0.10.1.0 # 2023-04-18: for hls on ghc 9.0 and 9.2 + - mod == 0.1.2.2 # needed for hls on ghc 8.10 - pantry == 0.5.2.1 # needed for stack-2.7.3 - path == 0.9.0 # 2021-12-03: path version building with stackage genvalidity and GHC 9.0.2 - - relude == 0.7.0.0 # 2022-02-25: Needed for ema 0.6 - - resolv == 0.1.1.2 # required to build cabal-install-3.0.0.0 with pre ghc-8.8.x + - resolv < 0.2 # required to build cabal-install-3.10.1.0 with Stackage LTS 21 - sbv == 7.13 # required for pkgs.petrinizer - - stylish-haskell == 0.13.0.0 # 2022-09-19: needed for hls on ghc 8.8 + - stylish-haskell == 0.14.3.0 # 2022-09-19: needed for hls on ghc 8.8 - tasty-hspec == 1.1.6 # 2022-04-07: Needed for elm-format - vty == 5.35.1 # 2022-07-08: needed for glirc-2.39.0.1 - weeder == 2.2.* # 2022-02-21: preserve for GHC 8.10.7 - weeder == 2.3.* # 2022-05-31: preserve for GHC 9.0.2 - weeder == 2.4.* # 2023-02-02: preserve for GHC 9.2.* - commonmark-extensions < 0.2.3.3 # 2022-12-17: required by emanote 1.0.0.0 (to avoid a bug in 0.2.3.3) - - ShellCheck == 0.8.0 # 2022-12-28: required by haskell-ci 0.14.3 - retrie < 1.2.0.0 # 2022-12-30: required for hls on ghc < 9.2 - ghc-tags == 1.5.* # 2023-02-18: preserve for ghc-lib == 9.2.* - - primitive == 0.7.4.0 # 2023-03-04: primitive 0.8 is not compatible with too many packages on ghc 9.4 as of now - - fourmolu == 0.10.1.0 # 2023-04-18: for hls-fourmolu-plugin 1.1.1.0 + - ghc-tags == 1.6.* # 2023-02-18: preserve for ghc-lib == 9.4.* + - shake-cabal < 0.2.2.3 # 2023-07-01: last version to support Cabal 3.6.* + - unix-compat < 0.7 # 2023-07-04: Need System.PosixCompat.User for git-annex + - algebraic-graphs < 0.7 # 2023-08-14: Needed for building weeder < 2.6.0 package-maintainers: abbradar: @@ -164,8 +163,6 @@ package-maintainers: - password - password-instances - pretty-simple - - purenix - - spago - stack - termonad centromere: @@ -175,6 +172,8 @@ package-maintainers: - ghc-vis - patat - svgcairo + danielrolls: + - shellify domenkozar: - cachix - cachix-api @@ -352,8 +351,13 @@ package-maintainers: - shakespeare raehik: - strongweak + - generic-data-functions - binrep - bytepatch + - heystone + - refined + - refined1 + - flatparse roberth: - arion-compose - cabal-pkg-config-version-hook @@ -425,6 +429,8 @@ package-maintainers: - irc-client - chatter - envy + tbidne: + - rest-rewrite terlar: - nix-diff turion: @@ -741,6 +747,7 @@ supported-platforms: seqalign: [ platforms.x86 ] # x86 intrinsics streamed: [ platforms.linux] # alsa-core only supported on linux swisstable: [ platforms.x86_64 ] # Needs AVX2 + systemd-api: [ platforms.linux ] tasty-papi: [ platforms.linux ] # limited by pkgs.papi udev: [ platforms.linux ] Win32-console: [ platforms.windows ] diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml index 8c84d73081ac..120d09d88c05 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml @@ -1,4 +1,4 @@ -# Stackage LTS 20.26 +# Stackage LTS 21.3 # This file is auto-generated by # maintainers/scripts/haskell/update-stackage.sh default-package-overrides: @@ -6,7 +6,7 @@ default-package-overrides: - abstract-deque-tests ==0.3 - abstract-par ==0.3.3 - AC-Angle ==1.0 - - acc ==0.2.0.1 + - acc ==0.2.0.2 - ace ==0.6 - acid-state ==0.16.1.2 - action-permutations ==0.0.0.1 @@ -17,41 +17,38 @@ default-package-overrides: - adler32 ==0.1.2.0 - advent-of-code-api ==0.2.8.4 - aern2-mp ==0.2.15.0 - - aern2-real ==0.2.11.0 - - aeson ==2.0.3.0 + - aern2-real ==0.2.15 + - aeson ==2.1.2.1 - aeson-attoparsec ==0.0.0 - - aeson-better-errors ==0.9.1.1 - aeson-casing ==0.2.0.0 - aeson-combinators ==0.1.0.1 - - aeson-commit ==1.6.0 - - aeson-compat ==0.3.10 - aeson-diff ==1.1.0.13 - aeson-extra ==0.5.1.2 - aeson-generic-compat ==0.0.1.3 - aeson-iproute ==0.3.0 - - aeson-optics ==1.2.0.1 + - aeson-optics ==1.2.1 - aeson-picker ==0.1.0.6 - aeson-pretty ==0.8.9 - aeson-qq ==0.8.4 - aeson-schemas ==1.4.1.0 - - aeson-typescript ==0.4.2.0 + - aeson-typescript ==0.6.0.0 - aeson-value-parser ==0.19.7.1 - aeson-yak ==0.1.1.3 - aeson-yaml ==1.1.0.1 - - agda2lagda ==0.2021.6.1 - - airship ==0.9.5 + - agda2lagda ==0.2023.6.9 - al ==0.1.4.2 - alarmclock ==0.7.0.6 - - alerts ==0.1.2.0 - - alex ==3.2.7.4 + - alex ==3.3.0.0 - alex-meta ==0.3.0.13 - algebra ==4.3.1 - - algebraic-graphs ==0.6.1 + - algebraic-graphs ==0.7 + - align-audio ==0.0.0.1 - Allure ==0.11.0.0 - almost-fix ==0.0.2 - alsa-core ==0.5.0.1 - alsa-mixer ==0.3.0 - alsa-pcm ==0.6.1.1 + - alsa-seq ==0.6.0.9 - alternative-vector ==0.0.0 - alternators ==1.0.0.0 - ALUT ==2.4.0.3 @@ -59,51 +56,47 @@ default-package-overrides: - amqp-utils ==0.6.3.2 - annotated-exception ==0.2.0.4 - annotated-wl-pprint ==0.7.0 - - ansi-terminal ==0.11.4 - - ansi-terminal-game ==1.8.1.0 + - ansi-terminal ==0.11.5 + - ansi-terminal-game ==1.9.1.3 + - ansi-terminal-types ==0.11.5 - ansi-wl-pprint ==0.6.9 - ANum ==0.2.0.2 - aos-signature ==0.1.1 - apecs ==0.9.5 - - apecs-gloss ==0.2.4 - - apecs-physics ==0.4.5 - api-field-json-th ==0.1.0.2 - api-maker ==0.1.0.6 - ap-normalize ==0.1.0.1 - appar ==0.1.8 - appendful ==0.1.0.0 - - appendful-persistent ==0.1.0.0 - appendmap ==0.1.5 - - apply-refact ==0.10.0.0 + - apply-refact ==0.13.0.0 - apportionment ==0.0.0.4 - approximate ==0.3.5 - approximate-equality ==1.1.0.2 - app-settings ==0.2.0.12 - arbor-lru-cache ==0.1.1.1 - - arbtt ==0.12.0.1 - arithmoi ==0.12.1.0 - array-memoize ==0.6.0 - arrow-extras ==0.1.0.1 - arrows ==0.4.4.2 - - ascii ==1.2.4.0 - - ascii-case ==1.0.1.2 - - ascii-char ==1.0.0.17 - - asciidiagram ==1.3.3.3 - - ascii-group ==1.0.0.15 - - ascii-numbers ==1.1.0.2 - - ascii-predicates ==1.0.1.2 + - ascii ==1.7.0.1 + - ascii-case ==1.0.1.3 + - ascii-caseless ==0.0.0.1 + - ascii-char ==1.0.1.0 + - ascii-group ==1.0.0.16 + - ascii-numbers ==1.2.0.1 + - ascii-predicates ==1.0.1.3 - ascii-progress ==0.3.3.0 - - ascii-superset ==1.0.1.15 - - ascii-th ==1.0.0.14 + - ascii-superset ==1.3.0.1 + - ascii-th ==1.2.0.1 - asn1-encoding ==0.9.6 - asn1-parse ==0.9.5 - asn1-types ==0.3.4 - assert-failure ==0.1.2.6 - - assoc ==1.0.2 + - assoc ==1.1 - astro ==0.4.3.0 - async ==2.2.4 - async-extra ==0.2.0.0 - - async-pool ==0.9.1 - async-refresh ==0.3.0.0 - async-refresh-tokens ==0.4.0.0 - atom-basic ==0.2.5 @@ -115,21 +108,26 @@ default-package-overrides: - attoparsec-binary ==0.2 - attoparsec-data ==1.0.5.3 - attoparsec-expr ==0.1.1.2 - - attoparsec-iso8601 ==1.0.2.1 + - attoparsec-framer ==0.1.0.0 + - attoparsec-iso8601 ==1.1.0.0 - attoparsec-path ==0.0.0.1 + - attoparsec-run ==0.0.2.0 - attoparsec-time ==1.0.3 - - aur ==7.0.7 - - aura ==3.2.9 + - audacity ==0.0.2.1 - authenticate ==1.3.5.1 - authenticate-oauth ==1.7 - autodocodec ==0.2.0.3 - autodocodec-openapi3 ==0.2.1.1 - autodocodec-schema ==0.1.0.3 - autodocodec-yaml ==0.2.0.3 - - autoexporter ==2.0.0.2 + - autoexporter ==2.0.0.8 - auto-update ==0.1.6 - avro ==0.6.1.2 + - aws ==0.24.1 - aws-cloudfront-signed-cookies ==0.2.0.12 + - aws-lambda-haskell-runtime ==4.1.2 + - aws-lambda-haskell-runtime-wai ==2.0.2 + - aws-sns-verify ==0.0.0.2 - aws-xray-client ==0.1.0.2 - aws-xray-client-persistent ==0.1.0.5 - aws-xray-client-wai ==0.1.0.2 @@ -138,7 +136,7 @@ default-package-overrides: - barbies ==2.0.4.0 - base16 ==0.3.2.1 - base16-bytestring ==1.0.2.0 - - base32 ==0.2.2.0 + - base32 ==0.3.1.0 - base32string ==0.9.1 - base58-bytestring ==0.1.0 - base58string ==0.10.0 @@ -146,10 +144,10 @@ default-package-overrides: - base64-bytestring ==1.2.1.0 - base64-bytestring-type ==1.0.1 - base64-string ==0.2 - - base-compat ==0.12.2 - - base-compat-batteries ==0.12.2 + - base-compat ==0.12.3 + - base-compat-batteries ==0.12.3 - basement ==0.0.16 - - base-orphans ==0.8.8.2 + - base-orphans ==0.9.0 - base-prelude ==1.6.1 - base-unicode-symbols ==0.2.4.2 - basic-prelude ==0.7.0 @@ -159,27 +157,23 @@ default-package-overrides: - bcp47 ==0.2.0.6 - bcp47-orphans ==0.1.0.6 - bcrypt ==0.0.11 - - beam-core ==0.9.2.1 - - beam-migrate ==0.5.1.2 - - beam-postgres ==0.5.2.1 - - beam-sqlite ==0.5.1.2 - bech32 ==1.1.3 - bech32-th ==1.1.1 - bench ==1.0.12 - benchpress ==0.2.2.22 - - bench-show ==0.3.2 - bencode ==0.6.1.1 - bencoding ==0.4.5.4 - benri-hspec ==0.1.0.1 - between ==0.11.0.0 - bhoogle ==0.1.4.2 - bibtex ==0.1.0.6 + - bifunctor-classes-compat ==0.1 - bifunctors ==5.5.15 - bimap ==0.5.0 - bimaps ==0.1.0.2 - bimap-server ==0.1.0.1 - - bin ==0.1.2 - - binance-exports ==0.1.1.0 + - bin ==0.1.3 + - binance-exports ==0.1.2.0 - binary-conduit ==1.3.1 - binaryen ==0.0.6.0 - binary-generic-combinators ==0.4.4.0 @@ -203,7 +197,7 @@ default-package-overrides: - bitvec ==1.1.4.0 - bitwise-enum ==1.0.1.0 - blake2 ==0.3.0 - - Blammo ==1.1.2.0 + - Blammo ==1.1.2.1 - blank-canvas ==0.7.3 - blanks ==0.5.0 - blas-carray ==0.1.0.2 @@ -212,19 +206,20 @@ default-package-overrides: - blas-hs ==0.1.1.0 - blaze-bootstrap ==0.1.0.1 - blaze-builder ==0.4.2.2 + - blaze-colonnade ==1.2.2.1 - blaze-html ==0.9.1.2 - blaze-markup ==0.8.2.8 - blaze-svg ==0.3.7 - blaze-textual ==0.2.3.1 - bloodhound ==0.21.0.0 - - bm ==0.1.1.0 + - bm ==0.2.0.0 - bmp ==1.2.6.3 - bnb-staking-csvs ==0.2.1.0 - BNFC ==2.9.4.1 - BNFC-meta ==0.6.1 + - board-games ==0.4 - bodhi ==0.1.0 - boltzmann-samplers ==0.1.1.0 - - bookkeeping ==0.4.0.1 - Boolean ==0.2.4 - boolsimplifier ==0.1.8 - boomerang ==1.4.9 @@ -235,10 +230,10 @@ default-package-overrides: - BoundedChan ==1.0.3.0 - bounded-queue ==1.0.0 - boundingboxes ==0.2.3 - - bower-json ==1.1.0.0 + - box ==0.9.1 - boxes ==0.1.5 - breakpoint ==0.1.2.1 - - brick ==1.4 + - brick ==1.9 - broadcast-chan ==0.2.1.2 - brotli ==0.0.0.1 - brotli-streams ==0.0.0.0 @@ -249,12 +244,11 @@ default-package-overrides: - buffer-pipe ==0.0 - bugsnag ==1.0.0.1 - bugsnag-haskell ==0.0.4.4 - - bugsnag-hs ==0.2.0.9 + - bugsnag-hs ==0.2.0.11 - bugsnag-wai ==1.0.0.1 - bugsnag-yesod ==1.0.0.1 - bugzilla-redhat ==1.0.1 - burrito ==2.0.1.6 - - butcher ==1.3.3.2 - bv ==0.5 - byteable ==0.1.1 - bytebuild ==0.3.13.0 @@ -265,13 +259,11 @@ default-package-overrides: - byteorder ==1.0.4 - bytes ==0.17.2 - byteset ==0.1.1.0 - - byteslice ==0.2.7.0 + - byteslice ==0.2.10.0 - bytesmith ==0.3.9.1 - bytestring-builder ==0.10.8.2.0 - - bytestring-conversion ==0.3.2 - bytestring-lexing ==0.5.0.10 - bytestring-mmap ==0.2.2 - - bytestring-progress ==1.4 - bytestring-strict-builder ==0.4.5.6 - bytestring-to-vector ==0.3.0.1 - bytestring-tree-builder ==0.2.7.10 @@ -280,24 +272,20 @@ default-package-overrides: - bzlib-conduit ==0.3.0.2 - c14n ==0.1.0.2 - c2hs ==0.28.8 - - cabal2spec ==2.6.3 - - cabal-appimage ==0.3.0.5 + - cabal2spec ==2.7.0 + - cabal-appimage ==0.4.0.1 - cabal-clean ==0.2.20230609 - - cabal-debian ==5.2.1 - cabal-doctest ==1.0.9 - cabal-file ==0.1.1 - - cabal-file-th ==0.2.7 - - cabal-flatpak ==0.1.0.4 - - cabal-plan ==0.7.2.3 - - cabal-rpm ==2.0.11.1 - - Cabal-syntax ==3.6.0.0 + - cabal-install-solver ==3.8.1.0 + - cabal-rpm ==2.1.1 - cache ==0.1.3.0 - cached-json-file ==0.1.1 - cacophony ==0.10.1 - cairo ==0.13.10.0 - calendar-recycling ==0.0.0.1 - call-alloy ==0.4.0.3 - - calligraphy ==0.1.4 + - calligraphy ==0.1.6 - call-plantuml ==0.0.1.2 - call-stack ==0.4.0 - can-i-haz ==0.3.1.1 @@ -312,9 +300,9 @@ default-package-overrides: - cases ==0.1.4.2 - casing ==0.1.4.1 - cassava ==0.5.3.0 + - cassava-conduit ==0.6.5 - cassava-megaparsec ==2.0.4 - cast ==0.1.0.2 - - cayley-client ==0.4.19.2 - cborg ==0.2.9.0 - cborg-json ==0.2.5.0 - cdar-mBound ==0.1.0.4 @@ -325,24 +313,22 @@ default-package-overrides: - cereal-unordered-containers ==0.1 - cereal-vector ==0.2.0.1 - cfenv ==0.1.0.0 + - cgi ==3001.5.0.1 - chan ==0.0.4.1 - character-cases ==0.1.0.6 - charset ==0.3.9 - charsetdetect-ae ==1.1.0.4 - Chart ==1.9.4 - - Chart-cairo ==1.9.3 - Chart-diagrams ==1.9.4 - - chart-svg ==0.3.3 - ChasingBottoms ==1.3.1.12 - - cheapskate ==0.1.1.2 - - cheapskate-highlight ==0.1.0.0 - - cheapskate-lucid ==0.1.0.0 - check-email ==1.0.2 - checkers ==0.6.0 - checksum ==0.0.0.1 - chimera ==0.3.3.0 - choice ==0.2.2 - chronologique ==0.3.1.3 + - chronos ==1.1.5 + - chronos-bench ==0.2.0.2 - chunked-data ==0.3.1 - cipher-aes ==0.2.11 - cipher-camellia ==0.0.2 @@ -354,51 +340,50 @@ default-package-overrides: - classy-prelude-conduit ==1.5.0 - classy-prelude-yesod ==1.5.0 - cleff ==0.3.3.0 - - cleff-plugin ==0.1.0.0 - clientsession ==0.9.1.2 - - climb ==0.4.1 - Clipboard ==2.3.2.0 - clock ==0.8.3 - closed ==0.2.0.2 - clumpiness ==0.17.0.2 - ClustalParser ==1.3.0 - - cmark ==0.6 - cmark-gfm ==0.2.5 - - cmark-lucid ==0.1.0.0 - cmdargs ==0.10.22 - codec-beam ==0.2.0 - code-conjure ==0.5.2 - code-page ==0.2.1 + - coinor-clp ==0.0 - cointracking-imports ==0.1.0.2 - collect-errors ==0.1.5.0 + - co-log-concurrent ==0.5.1.0 - co-log-core ==0.3.2.0 + - colonnade ==1.2.0.2 - Color ==0.3.3 - colorful-monoids ==0.2.1.3 - colorize-haskell ==1.0.1 - colour ==2.3.6 + - colourista ==0.1.0.2 - columnar ==1.0.0.0 - combinatorial ==0.1.1 - comfort-array ==0.5.2.3 - comfort-array-shape ==0.0 + - comfort-blas ==0.0.0.1 - comfort-fftw ==0.0.0.1 + - comfort-glpk ==0.1 - comfort-graph ==0.0.3.2 - - commonmark ==0.2.2 - - commonmark-extensions ==0.2.3.4 + - commonmark ==0.2.3 + - commonmark-extensions ==0.2.3.5 - commonmark-pandoc ==0.2.1.3 - commutative ==0.0.2 + - commutative-semigroups ==0.1.0.1 - comonad ==5.0.8 - comonad-extras ==4.0.1 - compactmap ==0.1.4.3 + - compdata ==0.13.0 - compensated ==0.8.3 - compiler-warnings ==0.1.0 - componentm ==0.0.0.2 - componentm-devel ==0.0.0.2 - composable-associations ==0.1.0.0 - - composite-base ==0.8.2.1 - - composite-binary ==0.8.2.1 - - composite-ekg ==0.8.2.1 - - composite-tuple ==0.1.2.0 - - composite-xstep ==0.1.0.0 - composition ==1.0.2.2 - composition-extra ==2.0.0 - composition-prelude ==3.0.0.2 @@ -419,19 +404,17 @@ default-package-overrides: - conduit-zstd ==0.0.2.0 - conferer ==1.1.0.0 - conferer-aeson ==1.1.0.2 + - conferer-warp ==1.1.0.1 - ConfigFile ==1.1.4 - - config-ini ==0.2.5.0 + - config-ini ==0.2.6.0 - configuration-tools ==0.6.1 - configurator ==0.3.0.0 - configurator-export ==0.1.0.1 - - configurator-pg ==0.2.7 - connection ==0.3.1 - - connection-pool ==0.2.2 - console-style ==0.0.2.1 - constraints ==0.13.4 - - constraints-extras ==0.3.2.1 + - constraints-extras ==0.4.0.0 - constraint-tuples ==0.1.2 - - construct ==0.3.1.1 - context ==0.2.0.1 - context-http-client ==0.2.0.1 - context-resource ==0.2.0.1 @@ -447,11 +430,11 @@ default-package-overrides: - cookie ==0.4.6 - copr-api ==0.1.0 - core-data ==0.3.9.1 - - core-program ==0.6.8.0 - - core-telemetry ==0.2.9.3 + - core-program ==0.6.9.4 + - core-telemetry ==0.2.9.4 - core-text ==0.3.8.1 - countable ==1.2 - - country ==0.2.3 + - country ==0.2.3.1 - covariance ==0.2.0.1 - cpphs ==1.20.9.1 - cprng-aes ==0.6.1 @@ -459,10 +442,11 @@ default-package-overrides: - cpuinfo ==0.1.0.2 - cql ==4.0.4 - cql-io ==1.1.1 - - crackNum ==3.2 + - crackNum ==3.4 + - crc32c ==0.1.0 - credential-store ==0.1.2 - - criterion ==1.5.13.0 - - criterion-measurement ==0.1.4.0 + - criterion ==1.6.1.0 + - criterion-measurement ==0.2.1.0 - cron ==0.7.0 - crypto-api ==0.13.3 - crypto-api-tests ==0.3 @@ -476,35 +460,36 @@ default-package-overrides: - cryptohash-sha1 ==0.11.101.0 - cryptohash-sha256 ==0.11.102.1 - cryptohash-sha512 ==0.11.102.0 + - crypton ==0.32 - cryptonite ==0.30 - cryptonite-conduit ==0.2.2 - cryptonite-openssl ==0.7 - crypto-pubkey-types ==0.4.3 - crypto-random ==0.0.9 - crypto-random-api ==0.2.0 - - cryptostore ==0.2.3.0 + - cryptostore ==0.3.0.1 - crypt-sha512 ==0 - csp ==1.4.0 + - css-syntax ==0.1.0.1 - css-text ==0.1.3.0 - c-struct ==0.1.3.0 - csv ==0.1.2 - csv-conduit ==0.7.3.0 - ctrie ==0.2 - - cubicbezier ==0.6.0.6 + - cubicbezier ==0.6.0.7 - cubicspline ==0.1.2 - cue-sheet ==2.0.2 - curl ==1.3.8 - curl-runnings ==0.17.0 - - currencies ==0.2.0.0 - currency ==0.2.0.0 - currycarbon ==0.2.1.1 - cursor ==0.3.2.0 - cursor-brick ==0.1.0.1 - cursor-fuzzy-time ==0.0.0.0 - cursor-gen ==0.4.0.0 + - cutter ==0.0 - cyclotomic ==1.1.2 - - czipwith ==1.0.1.4 - - d10 ==1.0.1.2 + - d10 ==1.0.1.3 - data-accessor ==0.2.3.1 - data-accessor-mtl ==0.2.0.5 - data-accessor-transformers ==0.2.1.8 @@ -513,6 +498,7 @@ default-package-overrides: - data-bword ==0.1.0.2 - data-checked ==0.3 - data-clist ==0.2 + - data-compat ==0.1.0.4 - data-default ==0.7.1.1 - data-default-class ==0.1.2.0 - data-default-instances-base ==0.1.0.1 @@ -521,7 +507,6 @@ default-package-overrides: - data-default-instances-containers ==0.0.1 - data-default-instances-dlist ==0.0.1 - data-default-instances-old-locale ==0.0.1 - - data-default-instances-text ==0.0.1 - data-default-instances-unordered-containers ==0.0.1 - data-default-instances-vector ==0.0.1 - data-diverse ==4.7.1.0 @@ -529,8 +514,7 @@ default-package-overrides: - data-dword ==0.3.2.1 - data-endian ==0.1.1 - data-fix ==0.3.2 - - data-forest ==0.1.0.10 - - data-functor-logistic ==0.0 + - data-forest ==0.1.0.12 - data-has ==0.4.0.0 - data-hash ==0.2.0.1 - data-interval ==2.1.1 @@ -541,17 +525,14 @@ default-package-overrides: - data-msgpack-types ==0.0.3 - data-or ==1.0.0.7 - data-ordlist ==0.4.7.0 - - data-ref ==0.0.2 + - data-ref ==0.1 - data-reify ==0.6.3 - data-serializer ==0.3.5 - - datasets ==0.4.0 - data-sketches ==0.3.1.0 - data-sketches-core ==0.1.0.0 - data-textual ==0.3.0.3 - - data-tree-print ==0.1.0.2 - dataurl ==0.1.0.0 - DAV ==1.3.4 - - dawg-ord ==0.5.1.2 - dbcleaner ==0.1.3 - DBFunctor ==0.1.2.1 - dbus ==1.2.29 @@ -568,13 +549,14 @@ default-package-overrides: - dense-linear-algebra ==0.1.0.0 - dependent-map ==0.4.0.0 - dependent-sum ==0.7.2.0 - - dependent-sum-template ==0.1.1.1 - depq ==0.4.2 - deque ==0.4.4 - deriveJsonNoPrefix ==0.1.0.1 + - derive-storable ==0.3.1.0 - derive-topdown ==0.0.3.0 - deriving-aeson ==0.2.9 - deriving-compat ==0.6.3 + - deriving-trans ==0.5.2.0 - detour-via-sci ==1.0.0 - df1 ==0.4.1 - dhall ==1.41.2 @@ -582,21 +564,22 @@ default-package-overrides: - dhall-json ==1.7.11 - dhall-yaml ==1.2.12 - di ==1.3 - - diagrams ==1.4.0.1 - - diagrams-builder ==0.8.0.5 - - diagrams-cairo ==1.4.2 - - diagrams-canvas ==1.4.1.1 - - diagrams-contrib ==1.4.5 + - diagrams ==1.4.1 + - diagrams-canvas ==1.4.1.2 + - diagrams-contrib ==1.4.5.1 - diagrams-core ==1.5.1 - - diagrams-lib ==1.4.5.2 + - diagrams-html5 ==1.4.2 + - diagrams-lib ==1.4.6 - diagrams-postscript ==1.5.1.1 - diagrams-rasterific ==1.4.2.3 - diagrams-solve ==0.1.3 - diagrams-svg ==1.4.3.1 + - dice ==0.1.1 - di-core ==1.0.4 - dictionary-sharing ==0.1.0.0 - di-df1 ==1.2.1 - Diff ==0.4.1 + - diff-loc ==0.1.0.0 - digest ==0.0.1.7 - digits ==0.3.1 - di-handle ==1.0.1 @@ -609,25 +592,26 @@ default-package-overrides: - discover-instances ==0.1.0.0 - discrimination ==0.5 - disk-free-space ==0.1.0.1 - - distribution-opensuse ==1.1.3 + - distributed-static ==0.3.9 + - distribution-opensuse ==1.1.4 - distributive ==0.6.2.1 - diversity ==0.8.1.0 - djinn-lib ==0.0.1.4 - dl-fedora ==0.9.5 - dlist ==1.0 - dlist-instances ==0.1.1.1 - - dlist-nonempty ==0.1.2 + - dlist-nonempty ==0.1.3 - dns ==4.1.1 - - docker ==0.7.0.1 - dockerfile ==0.2.0 - doclayout ==0.4.0.1 - - doctemplates ==0.10.0.2 + - doctemplates ==0.11 - doctest ==0.20.1 - doctest-discover ==0.2.0.0 - doctest-driver-gen ==0.3.0.7 - doctest-exitcode-stdio ==0.0 + - doctest-extract ==0.1.1 - doctest-lib ==0.1 - - doctest-parallel ==0.2.6 + - doctest-parallel ==0.3.0.1 - doldol ==0.4.1.2 - do-list ==1.0.1 - domain ==0.1.1.4 @@ -637,7 +621,7 @@ default-package-overrides: - domain-optics ==0.1.0.3 - do-notation ==0.1.0.2 - dot ==0.3 - - dotenv ==0.10.0.0 + - dotenv ==0.11.0.2 - dotgen ==0.4.3 - dotnet-timespan ==0.0.1.0 - double-conversion ==2.0.4.2 @@ -651,7 +635,7 @@ default-package-overrides: - dual ==0.1.1.1 - dual-tree ==0.2.3.1 - dublincore-xml-conduit ==0.1.0.2 - - dunai ==0.9.2 + - dunai ==0.11.1 - duration ==0.2.0.0 - dvorak ==0.1.0.0 - dynamic-state ==0.3.1 @@ -670,7 +654,7 @@ default-package-overrides: - editor-open ==0.6.0.0 - effectful ==2.2.2.0 - effectful-core ==2.2.2.2 - - effectful-plugin ==1.0.0.0 + - effectful-plugin ==1.1.0.1 - effectful-th ==1.0.0.1 - either ==5.0.2 - either-both ==0.1.1.1 @@ -678,34 +662,35 @@ default-package-overrides: - ekg-core ==0.1.1.7 - elerea ==2.9.0 - elf ==0.31 - - eliminators ==0.9 + - eliminators ==0.9.2 - elm2nix ==0.3.0 - elm-bridge ==0.8.2 - elm-core-sources ==1.0.0 - elm-export ==0.6.0.1 - - elynx ==0.7.2.1 - - elynx-markov ==0.7.2.1 - - elynx-nexus ==0.7.2.1 - - elynx-seq ==0.7.2.1 + - elynx ==0.7.2.2 + - elynx-markov ==0.7.2.2 + - elynx-nexus ==0.7.2.2 + - elynx-seq ==0.7.2.2 - elynx-tools ==0.7.2.1 - - elynx-tree ==0.7.2.1 + - elynx-tree ==0.7.2.2 - emacs-module ==0.1.1.1 - email-validate ==2.3.2.18 - emojis ==0.1.2 - enclosed-exceptions ==1.0.3 - ENIG ==0.0.1.0 - entropy ==0.4.1.10 - - enummapset ==0.6.0.3 + - enummapset ==0.7.1.0 - enumset ==0.1 + - enum-subset-generate ==0.1.0.1 - enum-text ==0.5.3.0 - envelope ==0.2.2.0 - envparse ==0.5.0 - envy ==2.1.2.0 - eq ==4.3 + - equal-files ==0.0.5.4 - equational-reasoning ==0.7.0.1 - equivalence ==0.4.1 - erf ==2.0.0.0 - - errata ==0.4.0.0 - error ==1.0.0.0 - errorcall-eq-instance ==0.3.0 - error-or ==0.3.0 @@ -714,11 +699,6 @@ default-package-overrides: - errors-ext ==0.4.2 - ersatz ==0.4.13 - esqueleto ==3.5.10.0 - - essence-of-live-coding ==0.2.7 - - essence-of-live-coding-gloss ==0.2.7 - - essence-of-live-coding-pulse ==0.2.7 - - essence-of-live-coding-quickcheck ==0.2.7 - - essence-of-live-coding-warp ==0.2.7 - event-list ==0.1.2 - eventstore ==1.4.2 - every ==0.0.1 @@ -730,23 +710,25 @@ default-package-overrides: - exception-transformers ==0.4.0.11 - executable-hash ==0.2.0.4 - executable-path ==0.0.3.1 + - exinst ==0.9 - exit-codes ==1.0.0 - exomizer ==1.0.0 - experimenter ==0.1.0.14 - expiring-cache-map ==0.0.6.1 - explainable-predicates ==0.1.2.3 - - explicit-exception ==0.1.10.1 + - explicit-exception ==0.2 - exp-pairs ==0.2.1.0 - - express ==1.0.10 + - express ==1.0.12 - extended-reals ==0.2.4.0 - extensible ==0.9 - extensible-effects ==5.0.0.1 - extensible-exceptions ==0.1.1.4 - - extra ==1.7.13 + - extra ==1.7.14 - extractable-singleton ==0.0.1 - extrapolate ==0.4.6 - fail ==4.9.0.0 - failable ==1.2.4.0 + - FailT ==0.1.2.0 - fakedata ==1.0.3 - fakedata-parser ==0.1.0.0 - fakedata-quickcheck ==0.2.0 @@ -754,10 +736,11 @@ default-package-overrides: - fakepull ==0.3.0.2 - faktory ==1.1.2.4 - fasta ==0.10.4.2 - - fast-logger ==3.1.2 + - fast-logger ==3.2.2 - fast-math ==1.0.2 + - fastmemo ==0.1.1 - fb ==2.1.1.1 - - fclabels ==2.0.5.1 + - fcf-family ==0.2.0.0 - fdo-notify ==0.3.1 - feature-flags ==0.1.0.1 - fedora-dists ==2.1.1 @@ -766,21 +749,20 @@ default-package-overrides: - FenwickTree ==0.1.2.1 - fft ==0.1.8.7 - fftw-ffi ==0.1 - - fgl ==5.7.0.3 + - fgl ==5.8.0.0 - fields-json ==0.4.0.0 - - filecache ==0.4.1 - file-embed ==0.0.15.0 - file-embed-lzma ==0.0.1 - filelock ==0.1.1.6 - filemanip ==0.3.6.3 - file-modules ==0.1.2.4 - - filepath-bytestring ==1.4.2.1.12 + - filepath-bytestring ==1.4.2.1.13 - file-path-th ==0.1.0.0 - filepattern ==0.1.3 - fileplow ==0.1.0.0 - filter-logger ==0.6.0.0 - filtrable ==0.1.6.0 - - fin ==0.2.1 + - fin ==0.3 - FindBin ==0.0.5 - fingertree ==0.1.5.0 - finite-typelits ==0.1.6.0 @@ -795,10 +777,9 @@ default-package-overrides: - flac ==0.2.0 - flac-picture ==0.1.2 - flags-applicative ==0.1.0.3 - - flat-mcmc ==1.5.2 - - flatparse ==0.3.5.1 + - flat ==0.6 + - flatparse ==0.4.1.0 - flay ==0.4 - - flexible-defaults ==0.0.3 - FloatingHex ==0.5 - floatshow ==0.2.4 - flow ==2.0.0.3 @@ -808,7 +789,9 @@ default-package-overrides: - fn ==0.3.0.2 - focus ==1.0.3.1 - focuslist ==0.1.1.0 - - foldl ==1.4.14 + - foldable1-classes-compat ==0.1 + - fold-debounce ==0.2.0.11 + - foldl ==1.4.15 - folds ==0.7.8 - follow-file ==0.0.3 - FontyFruity ==0.5.3.5 @@ -816,47 +799,44 @@ default-package-overrides: - foreign-store ==0.2 - ForestStructures ==0.0.1.1 - forkable-monad ==0.2.0.3 - - forma ==1.2.0 - - formatn ==0.2.2 + - formatn ==0.3.0 - format-numbers ==0.1.0.1 - - formatting ==7.1.3 - - fortran-src ==0.12.0 + - formatting ==7.2.0 - foundation ==0.0.30 - - fourmolu ==0.9.0.0 - - freckle-app ==1.3.0.0 + - fourmolu ==0.11.0.0 - free ==5.1.10 - free-categories ==0.2.0.2 - freenect ==1.2.1 - - freer-simple ==1.2.1.2 - freetype2 ==0.2.0 - free-vl ==0.1.4 + - friday ==0.2.3.2 + - friday-juicypixels ==0.1.2.4 - friendly-time ==0.4.1 - frisby ==0.2.4 - from-sum ==0.2.3.0 - frontmatter ==0.1.0.2 - - fsnotify ==0.3.0.1 - - fsnotify-conduit ==0.1.1.1 + - fsnotify ==0.4.1.0 - ftp-client ==0.5.1.4 - funcmp ==1.9 - function-builder ==0.3.0.1 - functor-classes-compat ==2.0.0.2 + - functor-combinators ==0.4.1.2 - fused-effects ==1.1.2.2 - fusion-plugin ==0.2.6 - fusion-plugin-types ==0.1.0 - fuzzcheck ==0.1.1 - fuzzy ==0.1.0.1 - fuzzy-dates ==0.1.1.2 - - fuzzyset ==0.2.3 - fuzzy-time ==0.2.0.3 - gauge ==0.2.5 - gd ==3000.7.3 - gdp ==0.0.3.0 - gemini-exports ==0.1.0.0 - general-games ==1.1.1 - - generic-aeson ==0.2.0.14 + - generically ==0.1.1 - generic-arbitrary ==1.0.1 - generic-constraints ==1.1.1.1 - - generic-data ==1.0.0.1 + - generic-data ==1.1.0.0 - generic-data-surgery ==0.3.0.0 - generic-deriving ==1.14.4 - generic-functor ==1.1.0.0 @@ -869,6 +849,7 @@ default-package-overrides: - generics-eot ==0.4.0.1 - generics-sop ==0.5.1.3 - generics-sop-lens ==0.2.0.1 + - geniplate-mirror ==0.7.9 - genvalidity ==1.1.0.0 - genvalidity-aeson ==1.0.0.1 - genvalidity-appendful ==0.1.0.0 @@ -901,33 +882,28 @@ default-package-overrides: - genvalidity-uuid ==1.0.0.1 - genvalidity-vector ==1.0.0.0 - geodetics ==0.1.2 - - geojson ==4.1.1 - getopt-generics ==0.13.1.0 - - ghc-bignum-orphans ==0.1.1 - ghc-byteorder ==4.11.0.0.10 - ghc-check ==0.5.0.8 - - ghc-compact ==0.1.0.0 - ghc-core ==0.5.6 - - ghc-events ==0.18.0 - - ghc-exactprint ==1.5.0 - - ghcid ==0.8.7 + - ghc-events ==0.19.0.1 + - ghc-exactprint ==1.6.1.3 + - ghcid ==0.8.9 - ghci-hexcalc ==0.1.1.0 - ghcjs-codemirror ==0.0.0.2 - ghcjs-perch ==0.3.3.3 - - ghc-lib ==9.2.7.20230228 - - ghc-lib-parser ==9.2.7.20230228 - - ghc-lib-parser-ex ==9.2.0.4 - - ghc-parser ==0.2.4.0 + - ghc-lib ==9.4.5.20230430 + - ghc-lib-parser ==9.4.5.20230430 + - ghc-lib-parser-ex ==9.4.0.0 - ghc-paths ==0.1.0.12 - ghc-prof ==1.4.1.12 - - ghc-source-gen ==0.4.3.0 - - ghc-syntax-highlighter ==0.0.8.0 + - ghc-syntax-highlighter ==0.0.9.0 - ghc-tcplugins-extra ==0.4.4 - ghc-trace-events ==0.1.2.7 - ghc-typelits-extra ==0.4.5 - ghc-typelits-knownnat ==0.7.8 - ghc-typelits-natnormalise ==0.7.8 - - ghc-typelits-presburger ==0.6.2.0 + - ghc-typelits-presburger ==0.7.2.0 - ghost-buster ==0.1.1.0 - gi-atk ==2.0.27 - gi-cairo ==1.0.29 @@ -946,24 +922,25 @@ default-package-overrides: - gi-graphene ==1.0.7 - gi-gtk ==3.0.41 - gi-gtk-hs ==0.3.16 - - gi-gtksource ==3.0.28 - gi-harfbuzz ==0.0.9 - gi-javascriptcore ==4.0.27 - gio ==0.13.10.0 - gi-pango ==1.0.29 - - githash ==0.1.6.3 + - gi-soup ==2.4.28 + - githash ==0.1.7.0 - github ==0.28.0.1 - - github-release ==2.0.0.6 - - github-rest ==1.1.3 + - github-release ==2.0.0.8 + - github-rest ==1.1.4 - github-types ==0.2.1 - - github-webhooks ==0.16.0 + - github-webhooks ==0.17.0 - gitlab-haskell ==1.0.0.1 - - git-lfs ==1.2.0 - gitlib ==3.1.3 - gitrev ==1.3.1 - gi-vte ==2.91.31 + - gi-webkit2 ==4.0.30 - gi-xlib ==2.0.13 - gl ==0.9 + - glabrous ==2.0.6.2 - glasso ==0.1.0 - GLFW-b ==3.3.0.0 - glib ==0.13.10.0 @@ -971,9 +948,8 @@ default-package-overrides: - glob-posix ==0.2.0.1 - gloss ==1.13.2.2 - gloss-algorithms ==1.13.0.3 - - gloss-examples ==1.13.0.4 - - gloss-raster ==1.13.1.2 - gloss-rendering ==1.13.1.2 + - glpk-headers ==0.5.1 - GLURaw ==2.0.0.5 - GLUT ==2.7.0.16 - gmail-simple ==0.1.0.4 @@ -981,19 +957,19 @@ default-package-overrides: - goldplate ==0.2.1.1 - google-isbn ==1.0.3 - gopher-proxy ==0.1.1.3 - - gotyno-hs ==1.1.0 - gpolyline ==0.1.0.1 - graph-core ==0.3.0.0 - graphite ==0.10.0.1 + - graphql ==1.2.0.1 - graphql-client ==1.2.2 - graphs ==0.7.2 - graphula ==2.0.2.2 - graphviz ==2999.20.1.0 - graph-wrapper ==0.2.6.0 - gravatar ==0.8.1 - - gridtables ==0.0.3.0 + - gridtables ==0.1.0.0 - groom ==0.1.2.1 - - grouped-list ==0.2.3.0 + - group-by-date ==0.1.0.5 - groups ==0.5.3 - gtk ==0.15.8 - gtk2hs-buildtools ==0.13.10.0 @@ -1001,11 +977,12 @@ default-package-overrides: - gtk-sni-tray ==0.1.8.1 - gtk-strut ==0.1.3.2 - guarded-allocation ==0.0.1 - - hackage-cli ==0.0.3.6 + - H ==1.0.0 + - hackage-cli ==0.1.0.1 - hackage-security ==0.6.2.3 - - haddock-library ==1.10.0 - - hakyll ==4.15.1.1 - - hakyll-convert ==0.3.0.4 + - haddock-library ==1.11.0 + - haha ==0.3.1.1 + - hakyll ==4.16.0.0 - hal ==1.0.0.1 - half ==0.3.1 - hall-symbols ==0.1.0.6 @@ -1015,7 +992,7 @@ default-package-overrides: - handwriting ==0.1.0.3 - happstack-hsp ==7.3.7.7 - happstack-jmacro ==7.0.12.5 - - happstack-server ==7.7.2 + - happstack-server ==7.8.0.2 - happstack-server-tls ==7.2.1.3 - happy ==1.20.1.1 - happy-meta ==0.2.1.0 @@ -1023,10 +1000,9 @@ default-package-overrides: - HasBigDecimal ==0.2.0.0 - hasbolt ==0.1.6.2 - hashable ==1.4.2.0 - - hashids ==1.0.2.7 + - hashing ==0.1.1.0 - hashmap ==1.3.3 - hashtables ==1.3.1 - - haskeline ==0.8.2.1 - haskell-gi ==0.26.7 - haskell-gi-base ==0.26.4 - haskell-gi-overloading ==1.0 @@ -1038,93 +1014,92 @@ default-package-overrides: - haskell-src-exts-simple ==1.23.0.0 - haskell-src-exts-util ==0.2.5 - haskell-src-meta ==0.8.12 - - haskey-btree ==0.3.0.1 - - haskintex ==0.8.0.1 - haskoin-core ==0.21.2 + - haskoin-node ==0.18.1 - haskoin-store-data ==0.65.5 - hasktags ==0.72.0 - hasql ==1.6.3 - hasql-dynamic-statements ==0.3.1.2 - hasql-implicits ==0.1.1 + - hasql-interpolate ==0.1.0.4 + - hasql-listen-notify ==0.1.0 - hasql-migration ==0.3.0 - hasql-notifications ==0.2.0.5 - - hasql-optparse-applicative ==0.5 - - hasql-pool ==0.8.0.7 + - hasql-optparse-applicative ==0.7 + - hasql-pool ==0.9.0.1 - hasql-queue ==1.2.0.2 - hasql-th ==0.4.0.18 - hasql-transaction ==1.0.1.2 - has-transformers ==0.1.0.4 - hasty-hamiltonian ==1.3.4 - HaTeX ==3.22.3.2 - - HaXml ==1.25.12 + - HaXml ==1.25.13 - haxr ==3000.11.5 - HCodecs ==0.5.2 - - hdaemonize ==0.5.6 + - hdaemonize ==0.5.7 - HDBC ==2.4.0.4 - HDBC-session ==0.1.2.0 - - headed-megaparsec ==0.2.1.1 + - headed-megaparsec ==0.2.1.2 - heap ==1.0.4 - heaps ==0.4 - heatshrink ==0.1.0.0 - hebrew-time ==0.1.2 - - hedgehog ==1.1.2 + - hedgehog ==1.2 - hedgehog-classes ==0.2.5.4 - hedgehog-corpus ==0.2.0 - hedgehog-fakedata ==0.0.1.5 - hedgehog-fn ==1.0 + - hedgehog-optics ==1.0.0.3 - hedgehog-quickcheck ==0.1.1 - hedis ==0.15.2 - hedn ==0.3.0.4 + - heist ==1.1.1.1 - here ==1.2.13 - heredoc ==0.2.0.0 - heterocephalus ==1.0.5.7 + - hetzner ==0.2.1.1 - hex ==0.2.0 - hexml ==0.3.4 - hexml-lens ==0.2.2 - hexpat ==0.20.13 - - hex-text ==0.1.0.8 + - hex-text ==0.1.0.9 - hformat ==0.3.3.1 - hfsevents ==0.1.6 - - hgeometry ==0.14 - - hgeometry-combinatorial ==0.14 + - hgal ==2.0.0.3 - hidapi ==0.1.8 - - hierarchical-clustering ==0.4.7 - hi-file-parser ==0.1.4.0 - highlighting-kate ==0.6.4 - - hindent ==5.3.4 + - hindent ==6.0.0 - hinfo ==0.0.3.0 - hinotify ==0.4.1 - hint ==0.9.0.7 - - hip ==1.5.6.0 - histogram-fill ==0.9.1.0 - - hjsmin ==0.2.0.4 + - hjsmin ==0.2.1 - hkd-default ==1.1.0.0 - - hkgr ==0.4.2 - - hledger ==1.27.1 + - hkgr ==0.4.3.1 + - hledger ==1.30.1 - hledger-interest ==1.6.5 - - hledger-lib ==1.27.1 + - hledger-lib ==1.30 - hledger-stockquotes ==0.1.2.1 - - hledger-ui ==1.27.1 - - hledger-web ==1.27.1 + - hledger-ui ==1.30 + - hledger-web ==1.30 - hlibcpuid ==0.2.0 - hlibgit2 ==0.18.0.16 - hlibsass ==0.1.10.1 - - hlint ==3.4.1 + - hlint ==3.5 - hmatrix ==0.20.2 - hmatrix-gsl ==0.19.0.1 - hmatrix-gsl-stats ==0.4.1.8 - hmatrix-morpheus ==0.1.1.2 - - hmatrix-repa ==0.1.2.2 - hmatrix-special ==0.19.0.0 - - hmatrix-vector-sized ==0.1.3.0 - - HMock ==0.5.1.0 - - hnock ==0.4.0 - - hoauth2 ==2.6.0 + - hmm-lapack ==0.5.0.1 + - hmpfr ==0.4.5 + - hoauth2 ==2.8.0 - hoogle ==5.0.18.3 - hopenssl ==2.2.5 - hopfli ==0.2.2.1 - - horizontal-rule ==0.5.0.0 - - hosc ==0.19.1 + - horizontal-rule ==0.6.0.0 + - hosc ==0.20 - hostname ==1.0 - hostname-validate ==1.0.0 - hourglass ==0.2.12 @@ -1136,7 +1111,8 @@ default-package-overrides: - hpc-lcov ==1.1.1 - HPDF ==1.6.1 - hpp ==0.6.5 - - hpqtypes ==1.9.4.0 + - hpqtypes ==1.11.1.1 + - hpqtypes-extras ==1.16.4.3 - hreader ==1.1.0 - hreader-lens ==0.1.3.0 - hruby ==0.5.0.0 @@ -1151,32 +1127,34 @@ default-package-overrides: - hs-GeoIP ==0.3 - hsignal ==0.2.7.5 - hsini ==0.5.1.2 - - hsinstall ==2.7 + - hsinstall ==2.8 - HSlippyMap ==3.0.1 - hslogger ==1.3.1.0 - - hslua ==2.2.1 - - hslua-aeson ==2.2.1 - - hslua-classes ==2.2.0 - - hslua-core ==2.2.1 - - hslua-marshalling ==2.2.1 - - hslua-module-doclayout ==1.0.4 - - hslua-module-path ==1.0.3 - - hslua-module-system ==1.0.3 - - hslua-module-text ==1.0.3.1 - - hslua-module-version ==1.0.3 - - hslua-objectorientation ==2.2.1 - - hslua-packaging ==2.2.1 + - hslua ==2.3.0 + - hslua-aeson ==2.3.0.1 + - hslua-classes ==2.3.0 + - hslua-core ==2.3.1 + - hslua-list ==1.1.1 + - hslua-marshalling ==2.3.0 + - hslua-module-doclayout ==1.1.0 + - hslua-module-path ==1.1.0 + - hslua-module-system ==1.1.0.1 + - hslua-module-text ==1.1.0.1 + - hslua-module-version ==1.1.0 + - hslua-objectorientation ==2.3.0 + - hslua-packaging ==2.3.0 + - hslua-typing ==0.1.0 - hsndfile ==0.8.0 - hsndfile-vector ==0.5.2 - - HsOpenSSL ==0.11.7.5 + - HsOpenSSL ==0.11.7.6 - HsOpenSSL-x509-system ==0.1.0.4 - hsp ==0.10.0 - - hspec ==2.9.7 + - hspec ==2.10.10 - hspec-attoparsec ==0.1.0.2 - hspec-checkers ==0.1.0.2 - hspec-contrib ==0.5.2 - - hspec-core ==2.9.7 - - hspec-discover ==2.9.7 + - hspec-core ==2.10.10 + - hspec-discover ==2.10.10 - hspec-expectations ==0.8.2 - hspec-expectations-json ==1.0.0.7 - hspec-expectations-lifted ==0.10.0 @@ -1187,15 +1165,14 @@ default-package-overrides: - hspec-junit-formatter ==1.1.0.2 - hspec-leancheck ==0.0.6 - hspec-megaparsec ==2.2.0 - - hspec-meta ==2.9.3 - - hspec-need-env ==0.1.0.10 + - hspec-meta ==2.10.5 - hspec-parsec ==0 - - hspec-smallcheck ==0.5.2 + - hspec-smallcheck ==0.5.3 - hspec-tmp-proc ==0.5.1.2 - hspec-wai ==0.11.1 - hspec-wai-json ==0.11.0 + - hspec-webdriver ==1.2.2 - hs-php-session ==0.0.9.3 - - hsshellscript ==3.5.0 - hstatistics ==0.3.1 - HStringTemplate ==0.8.8 - HSvm ==0.1.1.3.25 @@ -1213,9 +1190,9 @@ default-package-overrides: - html-entity-map ==0.1.0.0 - htoml-megaparsec ==2.1.0.4 - htoml-parse ==0.1.0.1 - - http2 ==3.0.3 + - http2 ==4.1.4 - HTTP ==4000.4.1 - - http-api-data ==0.4.3 + - http-api-data ==0.5 - http-api-data-qq ==0.1.0.0 - http-client ==0.7.13.1 - http-client-openssl ==0.3.3 @@ -1233,20 +1210,19 @@ default-package-overrides: - http-media ==0.8.0.0 - http-query ==0.1.3 - http-reverse-proxy ==0.6.0.1 - - http-streams ==0.8.9.6 + - http-streams ==0.8.9.8 - http-types ==0.12.3 - human-readable-duration ==0.2.1.4 - HUnit ==1.6.2.0 - HUnit-approx ==1.1.1.1 - hunit-dejafu ==2.0.0.6 - hvect ==0.4.0.1 - - hvega ==0.12.0.3 + - hvega ==0.12.0.5 - hw-balancedparens ==0.4.1.3 - hw-bits ==0.7.2.2 - hw-conduit ==0.2.1.1 - hw-conduit-merges ==0.2.1.0 - hw-diagnostics ==0.0.1.0 - - hw-dsv ==0.4.1.1 - hweblib ==0.6.3 - hw-eliasfano ==0.1.2.1 - hw-excess ==0.2.3.0 @@ -1256,7 +1232,6 @@ default-package-overrides: - hw-hspec-hedgehog ==0.1.1.1 - hw-int ==0.0.2.0 - hw-ip ==2.4.2.1 - - hw-json ==1.3.2.4 - hw-json-simd ==0.1.1.2 - hw-json-simple-cursor ==0.1.1.1 - hw-json-standard-cursor ==0.2.3.2 @@ -1270,10 +1245,8 @@ default-package-overrides: - hw-rankselect ==0.13.4.1 - hw-rankselect-base ==0.3.4.1 - hw-simd ==0.1.2.2 - - hw-streams ==0.0.1.0 - hw-string-parse ==0.0.0.5 - hw-succinct ==0.1.0.1 - - hw-xml ==0.5.1.1 - hxt ==9.3.1.22 - hxt-charproperties ==9.5.0.0 - hxt-css ==0.1.0.3 @@ -1284,45 +1257,46 @@ default-package-overrides: - hxt-tagsoup ==9.1.4 - hxt-unicode ==9.0.2.4 - hybrid-vectors ==0.2.3 + - hyper ==0.2.1.1 - hyperloglog ==0.4.6 - hyphenation ==0.8.2 - identicon ==0.2.2 - ieee754 ==0.8.0 - if ==0.1.0.0 - IfElse ==0.85 - - ihaskell ==0.10.3.0 - - ihaskell-hvega ==0.5.0.3 + - iff ==0.0.6.1 - ihs ==0.1.0.3 - - ilist ==0.4.0.1 - imagesize-conduit ==1.1 - Imlib ==0.1.2 - immortal ==0.3 - immortal-queue ==0.1.0.1 - inbox ==0.2.0 + - incipit-base ==0.5.1.0 + - incipit-core ==0.5.1.0 - include-file ==0.1.0.4 - incremental ==0.3.1 - - incremental-parser ==0.5.0.5 - indents ==0.5.0.1 - indexed ==0.1.3 - indexed-containers ==0.1.0.2 - indexed-list-literals ==0.2.1.3 - - indexed-profunctors ==0.1.1 + - indexed-profunctors ==0.1.1.1 - indexed-traversable ==0.1.2.1 - indexed-traversable-instances ==0.1.1.2 + - inf-backprop ==0.1.0.2 - infer-license ==0.2.0 - - inflections ==0.4.0.6 - - influxdb ==1.9.2.2 + - infinite-list ==0.1 - ini ==0.4.2 - inj ==1.0 - inline-c ==0.9.1.8 - - inline-c-cpp ==0.5.0.0 - - inliterate ==0.1.0 - - input-parsers ==0.2.3.2 - - insert-ordered-containers ==0.2.5.2 - - inspection-testing ==0.4.6.1 + - inline-c-cpp ==0.5.0.1 + - inline-r ==1.0.1 + - input-parsers ==0.3.0.1 + - insert-ordered-containers ==0.2.5.3 + - inspection-testing ==0.5.0.2 - instance-control ==0.1.2.0 - integer-logarithms ==1.0.3.1 - integer-roots ==1.0.2.0 + - integer-types ==0.1.4.0 - integration ==0.2.1 - intern ==0.9.4 - interpolate ==0.2.1 @@ -1333,7 +1307,7 @@ default-package-overrides: - intervals ==0.9.2 - intset-imperative ==0.1.0.0 - invariant ==0.6.1 - - invert ==1.0.0.2 + - invert ==1.0.0.4 - invertible-grammar ==0.1.3.4 - io-machine ==0.2.0.0 - io-manager ==0.1.0.4 @@ -1345,7 +1319,7 @@ default-package-overrides: - ip ==1.7.6 - ip6addr ==1.0.3 - iproute ==1.7.12 - - IPv6Addr ==2.0.5 + - IPv6Addr ==2.0.5.1 - ipynb ==0.2 - ipython-kernel ==0.10.3.0 - irc ==0.6.1.0 @@ -1358,65 +1332,66 @@ default-package-overrides: - isocline ==1.0.9 - isomorphism-class ==0.1.0.9 - iterable ==3.0 - - ixset ==1.1.1.2 - - ixset-typed ==0.5.1.0 - - ixset-typed-binary-instance ==0.1.0.2 - - ixset-typed-conversions ==0.1.2.0 - - ixset-typed-hashable-instance ==0.1.0.2 - ix-shapable ==0.1.0 + - jack ==0.7.2.2 - jalaali ==1.0.0.0 - java-adt ==0.2018.11.4 - - jira-wiki-markup ==1.4.0 + - jira-wiki-markup ==1.5.1 - jl ==0.1.0 - jmacro ==0.6.18 - - jose ==0.9 - - jose-jwt ==0.9.5 + - jose ==0.10 + - jose-jwt ==0.9.6 + - journalctl-stream ==0.6.0.4 - js-chart ==2.9.4.1 - js-dgtable ==0.5.2 - js-flot ==0.8.3 - js-jquery ==3.3.1 - json ==0.10 - - json-feed ==2.0.0.8 + - json-feed ==2.0.0.9 - jsonifier ==0.2.1.2 - jsonpath ==0.3.0.0 - json-rpc ==1.0.4 - - json-stream ==0.4.5.2 - - JuicyPixels ==3.3.7 - - JuicyPixels-extra ==0.5.2 + - json-stream ==0.4.5.3 + - JuicyPixels ==3.3.8 + - JuicyPixels-extra ==0.6.0 - JuicyPixels-scale-dct ==0.1.2 - junit-xml ==0.1.0.2 - justified-containers ==0.3.0.0 - jwt ==0.11.0 - kan-extensions ==5.2.5 - - kanji ==3.5.0 - kansas-comet ==0.4.1 - katip ==0.8.7.4 - katip-logstash ==0.1.0.2 - - katip-wai ==0.1.2.1 + - katip-wai ==0.1.2.2 - kazura-queue ==0.1.0.4 - kdt ==0.2.5 - keep-alive ==0.2.1.0 + - keter ==2.1.1 - keycode ==0.2.2 + - keyed-vals ==0.2.2.0 + - keyed-vals-hspec-tests ==0.2.2.0 + - keyed-vals-mem ==0.2.2.0 + - keyed-vals-redis ==0.2.2.0 - keys ==3.12.3 - ki ==1.0.1.0 - - kind-apply ==0.3.2.1 - - kind-generics ==0.4.1.4 - - kind-generics-th ==0.2.2.3 + - kind-apply ==0.4.0.0 + - kind-generics ==0.5.0.0 + - kind-generics-th ==0.2.3.2 - ki-unlifted ==1.0.0.1 - kleene ==0.1 - kmeans ==0.1.3 - knob ==0.2.2 - koji ==0.0.2 - - l10n ==0.1.0.1 + - krank ==0.3.0 - labels ==0.3.3 - lackey ==2.0.0.6 - LambdaHack ==0.11.0.0 - - lame ==0.2.0 + - lame ==0.2.1 - language-avro ==0.1.4.0 - language-bash ==0.9.2 - language-c ==0.9.2 - language-c-quote ==0.13.0.1 - - language-docker ==12.0.0 + - language-docker ==12.1.0 - language-dot ==0.1.1 - language-glsl ==0.3.0 - language-java ==0.2.9 @@ -1424,30 +1399,31 @@ default-package-overrides: - language-protobuf ==1.0.1 - language-python ==0.5.8 - language-thrift ==0.12.0.1 + - lapack ==0.5.1 - lapack-carray ==0.0.3 - lapack-comfort-array ==0.0.1 - lapack-ffi ==0.0.3 - lapack-ffi-tools ==0.1.3.1 + - lapack-hmatrix ==0.0.0.2 - largeword ==1.2.5 - latex ==0.1.0.4 - - lattices ==2.0.3 + - lattices ==2.1 - lawful ==0.1.0.0 - lazy-csv ==0.5.1 - lazyio ==0.1.0.4 - lazysmallcheck ==0.6 - lca ==0.4 - - leancheck ==0.9.12 + - leancheck ==1.0.0 - leancheck-instances ==0.0.5 - leapseconds-announced ==2017.1.0.1 - learn-physics ==0.6.5 - leb128-cereal ==1.2 - - lens ==5.1.1 + - lens ==5.2.2 - lens-action ==0.2.6 - - lens-aeson ==1.2.2 + - lens-aeson ==1.2.3 - lens-csv ==0.1.1.0 - lens-family ==2.1.2 - lens-family-core ==2.1.2 - - lens-family-th ==0.5.2.1 - lens-misc ==0.0.2.0 - lens-properties ==4.11.1 - lens-regex ==0.1.3 @@ -1459,8 +1435,6 @@ default-package-overrides: - libBF ==0.6.5.1 - libffi ==0.2.1 - libgit ==0.3.1 - - libgraph ==1.14 - - libmpd ==0.10.0.0 - liboath-hs ==0.0.1.2 - libyaml ==0.1.2 - lifted-async ==0.10.2.4 @@ -1468,53 +1442,50 @@ default-package-overrides: - lift-generics ==0.2.1 - lift-type ==0.1.1.1 - line ==4.0.1 - - linear ==1.21.10 + - linear ==1.22 - linear-base ==0.3.1 + - linear-circuit ==0.1.0.4 - linear-generics ==0.2.1 + - linear-programming ==0.0 - linebreak ==1.1.0.4 - - linenoise ==0.3.2 - linux-capabilities ==0.1.1.0 - linux-file-extents ==0.2.0.0 - linux-namespaces ==0.1.3.0 - List ==0.6.2 - - ListLike ==4.7.8 + - ListLike ==4.7.8.1 - list-predicate ==0.1.0.1 - listsafe ==0.1.0.1 - list-t ==1.0.5.6 - list-transformer ==1.0.9 - ListTree ==0.2.3 - ListZipper ==1.2.0.2 - - literatex ==0.2.1.0 - - little-logger ==1.0.1 - - little-rio ==1.0.1 + - literatex ==0.3.0.0 - lmdb ==0.2.5 - load-env ==0.2.1.0 - loc ==0.1.4.1 - locators ==0.3.0.3 - loch-th ==0.2.2 - lockfree-queue ==0.2.4 + - log-base ==0.12.0.1 - log-domain ==0.13.2 - - logfloat ==0.13.4 + - logfloat ==0.14.0 - logger-thread ==0.1.0.2 - logging ==3.0.5 - - logging-effect ==1.3.13 + - logging-effect ==1.4.0 - logging-facade ==0.3.1 - logging-facade-syslog ==1 - logict ==0.8.0.0 - - logstash ==0.1.0.3 + - logstash ==0.1.0.4 - loop ==0.3.0 - lpeg ==1.0.4 - - LPFP ==1.1 - lrucache ==1.2.0.1 - - lrucaching ==0.3.3 - - lua ==2.2.1 + - lua ==2.3.1 - lua-arbitrary ==1.0.1.1 - - lucid2 ==0.0.20221012 + - lucid2 ==0.0.20230706 - lucid ==2.11.20230408 - lucid-cdn ==0.2.2.0 - lucid-extras ==0.2.2 - lukko ==0.1.1.3 - - lxd-client-config ==0.1.0.1 - lz4 ==0.2.3.1 - lz4-frame-conduit ==0.1.0.1 - lzma ==0.0.1.0 @@ -1522,6 +1493,8 @@ default-package-overrides: - lzma-conduit ==1.2.3 - machines ==0.7.3 - magic ==1.1 + - magico ==0.0.2.3 + - mail-pool ==2.2.3 - mainland-pretty ==0.7.1 - main-tester ==0.2.0.1 - managed ==1.0.10 @@ -1534,13 +1507,13 @@ default-package-overrides: - mason ==0.2.6 - massiv ==1.0.4.0 - massiv-io ==1.0.0.1 - - massiv-persist ==1.0.0.3 - massiv-serialise ==1.0.0.2 - massiv-test ==1.0.0.0 + - matchable ==0.1.2.1 - mathexpr ==0.3.1.0 - math-extras ==0.1.1.0 - math-functions ==0.3.4.2 - - mathlist ==0.1.0.4 + - mathlist ==0.2.0.0 - matplotlib ==0.7.7 - matrices ==0.5.0 - matrix ==0.3.6.1 @@ -1548,56 +1521,55 @@ default-package-overrides: - matrix-market-attoparsec ==0.1.1.3 - matrix-static ==0.3 - maximal-cliques ==0.1.1 + - mbox-utility ==0.0.3.1 - mcmc ==0.8.2.0 - mcmc-types ==1.0.3 - median-stream ==0.7.0.0 - med-module ==0.1.3 - - megaparsec ==9.2.2 - - megaparsec-tests ==9.2.2 - - mega-sdist ==0.4.2.1 + - megaparsec ==9.3.1 + - megaparsec-tests ==9.3.1 + - mega-sdist ==0.4.3.0 - membership ==0.0.1 - memcache ==0.3.0.1 - memfd ==1.0.1.3 - - memory ==0.17.0 - - MemoTrie ==0.6.10 + - memory ==0.18.0 + - MemoTrie ==0.6.11 - mergeful ==0.3.0.0 - - mergeful-persistent ==0.1.0.0 - mergeless ==0.4.0.0 - - mergeless-persistent ==0.1.0.0 - merkle-tree ==0.1.1 - mersenne-random ==1.0.0.1 - mersenne-random-pure64 ==0.2.2.0 - messagepack ==0.5.5 - metrics ==0.4.1.1 - - mfsolve ==0.3.2.1 + - mfsolve ==0.3.2.2 - microaeson ==0.1.0.1 - - microlens ==0.4.12.0 + - microlens ==0.4.13.1 - microlens-aeson ==2.5.0 - microlens-contra ==0.1.0.3 - - microlens-ghc ==0.4.13.2 + - microlens-ghc ==0.4.14.1 - microlens-mtl ==0.2.0.3 - - microlens-platform ==0.4.2.1 - - microlens-process ==0.2.0.2 + - microlens-platform ==0.4.3.3 - microlens-th ==0.4.3.13 - microspec ==0.2.1.3 - microstache ==1.0.2.3 - midair ==0.2.0.1 - midi ==0.2.2.4 + - midi-alsa ==0.2.1 - midi-music-box ==0.0.1.2 - mighty-metropolis ==2.0.0 - mime-mail ==0.5.1 - mime-mail-ses ==0.4.3 - - mime-types ==0.1.0.9 + - mime-types ==0.1.1.0 - minimal-configuration ==0.1.4 - minimorph ==0.3.0.1 - - minio-hs ==1.6.0 + - minio-hs ==1.7.0 - minisat-solver ==0.1 - miniutter ==0.5.1.2 - min-max-pqueue ==0.1.0.2 - mintty ==0.1.4 - misfortune ==0.1.2.1 - missing-foreign ==0.1.1 - - MissingH ==1.5.0.1 + - MissingH ==1.6.0.0 - mixed-types-num ==0.5.11 - mmap ==0.5.9 - mmark ==0.0.7.6 @@ -1608,12 +1580,13 @@ default-package-overrides: - mnist-idx-conduit ==0.4.0.0 - mockery ==0.3.5 - mock-time ==0.1.0 - - mod ==0.1.2.2 + - mod ==0.2.0.1 - model ==0.5 - modern-uri ==0.3.6.0 - modular ==0.1.0.8 - monad-chronicle ==1.0.1 - monad-control ==1.0.3.1 + - monad-control-identity ==0.2.0.0 - monad-coroutine ==0.9.2 - monad-extras ==0.6.0 - monadic-arrays ==0.2.2 @@ -1621,13 +1594,11 @@ default-package-overrides: - monadlist ==0.0.2 - monadloc ==0.7.1 - monad-logger ==0.3.40 - - monad-logger-aeson ==0.4.0.4 + - monad-logger-aeson ==0.4.1.1 - monad-logger-json ==0.1.0.0 - monad-logger-logstash ==0.2.0.2 - - monad-logger-prefix ==0.1.12 - monad-loops ==0.4.3 - monad-memo ==0.5.4 - - monad-metrics ==0.2.2.0 - monadoid ==0.0.3 - monadology ==0.1 - monad-par ==0.3.5 @@ -1637,22 +1608,19 @@ default-package-overrides: - monad-primitive ==0.1 - monad-products ==4.0.1 - MonadPrompt ==1.0.0.5 - - MonadRandom ==0.5.3 + - MonadRandom ==0.6 - monad-resumption ==0.1.4.0 - - monad-schedule ==0.1.2.0 - - monad-skeleton ==0.2 - monad-st ==0.2.4.1 - monads-tf ==0.1.0.3 - - monad-time ==0.3.1.0 + - monad-time ==0.4.0.0 - mongoDB ==2.7.1.2 - monoidal-containers ==0.6.4.0 - monoid-extras ==0.6.2 - - monoid-subclasses ==1.1.3 + - monoid-subclasses ==1.2.3 - monoid-transformer ==0.0.4 - - monomer ==1.5.1.0 - mono-traversable ==1.0.15.3 - mono-traversable-instances ==0.1.1.0 - - mono-traversable-keys ==0.2.0 + - mono-traversable-keys ==0.3.0 - more-containers ==0.2.2.2 - morpheus-graphql ==0.27.3 - morpheus-graphql-app ==0.27.3 @@ -1674,8 +1642,9 @@ default-package-overrides: - multiarg ==0.30.0.10 - multi-containers ==0.2 - multimap ==1.2.1 + - multipart ==0.2.1 + - MultipletCombiner ==0.0.4 - multiset ==0.3.4.3 - - multistate ==0.8.0.4 - murmur3 ==1.0.5 - murmur-hash ==0.1.0.10 - MusicBrainz ==0.4.1 @@ -1693,7 +1662,6 @@ default-package-overrides: - named ==0.3.0.1 - names-th ==0.3.0.1 - nano-erl ==0.1.0.1 - - NanoID ==3.2.1 - nanospec ==0.2.2 - nanovg ==0.8.1.0 - nats ==1.1.2 @@ -1711,6 +1679,7 @@ default-package-overrides: - net-mqtt-lens ==0.1.1.0 - netpbm ==1.0.4 - netrc ==0.2.0.0 + - nettle ==0.3.0 - netwire ==5.0.3 - netwire-input ==0.0.7 - netwire-input-glfw ==0.0.11 @@ -1724,7 +1693,7 @@ default-package-overrides: - network-messagepack-rpc-websocket ==0.1.1.1 - network-multicast ==0.3.2 - Network-NineP ==0.4.7.2 - - network-run ==0.2.5 + - network-run ==0.2.6 - network-simple ==0.4.5 - network-simple-tls ==0.4.1 - network-transport ==0.5.6 @@ -1748,8 +1717,8 @@ default-package-overrides: - nonempty-zipper ==1.0.0.4 - non-negative ==0.1.2 - normaldistribution ==1.1.0.3 - - normalization-insensitive ==2.0.2 - not-gloss ==0.7.7.0 + - nothunks ==0.1.4 - no-value ==1.0.0.0 - nowdoc ==0.1.1.0 - nqe ==0.6.4 @@ -1761,7 +1730,6 @@ default-package-overrides: - numeric-quest ==0.2.0.2 - numhask ==0.10.1.1 - numhask-array ==0.10.2 - - numhask-space ==0.10.0.1 - NumInstances ==1.4 - numtype-dk ==0.5.0.3 - nuxeo ==0.3.2 @@ -1771,17 +1739,18 @@ default-package-overrides: - oauthenticated ==0.3.0.0 - ObjectName ==1.1.0.2 - oblivious-transfer ==0.1.0 - - ochintin-daicho ==0.3.4.2 - o-clock ==1.3.0 - ofx ==0.4.4.0 + - oidc-client ==0.7.0.1 - old-locale ==1.0.0.7 - old-time ==1.1.0.3 - once ==0.4 - one-liner ==2.1 - one-liner-instances ==0.1.3.0 - - OneTuple ==0.3.1 + - OneTuple ==0.4.1.1 - Only ==0.1 - oo-prototypes ==0.1.0.0 + - oops ==0.2.0.1 - opaleye ==0.9.7.0 - OpenAL ==1.7.0.5 - openapi3 ==3.2.3 @@ -1800,9 +1769,10 @@ default-package-overrides: - operational ==0.2.4.2 - operational-class ==0.3.0.0 - opml-conduit ==0.9.0.0 - - optics ==0.4.2 - - optics-core ==0.4.1 + - optics ==0.4.2.1 + - optics-core ==0.4.1.1 - optics-extra ==0.4.2.1 + - optics-operators ==0.1.0.1 - optics-th ==0.4.1 - optics-vl ==0.2.1 - optima ==0.4.0.4 @@ -1815,23 +1785,23 @@ default-package-overrides: - optparse-text ==0.1.1.0 - OrderedBits ==0.0.2.0 - ordered-containers ==0.2.3 - - ormolu ==0.5.0.1 + - ormolu ==0.5.3.0 - overhang ==1.0.0 - packcheck ==0.6.0 - pager ==0.1.1.0 - pagination ==0.2.2 - pagure ==0.1.1 - pagure-cli ==0.2.1 - - palette ==0.3.0.2 - - pandoc ==2.19.2 - - pandoc-csv2table ==1.0.9 + - palette ==0.3.0.3 + - pandoc ==3.0.1 - pandoc-dhall-decoder ==0.1.0.1 - - pandoc-lua-marshal ==0.1.7 - - pandoc-plot ==1.5.5 + - pandoc-lua-marshal ==0.2.2 + - pandoc-plot ==1.7.0 + - pandoc-symreg ==0.2.0.0 - pandoc-throw ==0.1.0.0 - - pandoc-types ==1.22.2.1 + - pandoc-types ==1.23.0.1 - pango ==0.13.10.0 - - pantry ==0.5.7 + - pantry ==0.8.3 - parallel ==3.2.2.0 - parallel-io ==0.3.5 - parameterized ==0.5.0.0 @@ -1846,7 +1816,7 @@ default-package-overrides: - partial-handler ==1.0.3 - partial-isomorphisms ==0.2.3.0 - partial-order ==0.2.0.0 - - partial-semigroup ==0.6.0.1 + - partial-semigroup ==0.6.0.2 - password ==3.0.2.1 - password-instances ==3.0.0.0 - password-types ==1.0.0.0 @@ -1855,19 +1825,19 @@ default-package-overrides: - path-dhall-instance ==0.2.1.0 - path-extensions ==0.1.1.0 - path-extra ==0.2.0 - - path-formatting ==0.1.0.0 - - path-io ==1.7.0 + - path-io ==1.8.1 - path-like ==0.2.0.2 - path-pieces ==0.2.1 - - path-text-utf8 ==0.0.1.11 + - path-text-utf8 ==0.0.1.12 - pathtype ==0.8.1.2 - path-utils ==0.1.1.0 - pathwalk ==0.3.1.2 + - patrol ==1.0.0.5 - pattern-arrows ==0.0.2 - pava ==0.1.1.4 - pcf-font ==0.2.2.1 - pcg-random ==0.1.4.0 - - pcre2 ==2.1.1.1 + - pcre2 ==2.2.1 - pcre-heavy ==1.0.0.3 - pcre-light ==0.4.1.0 - pcre-utils ==0.1.9 @@ -1878,35 +1848,35 @@ default-package-overrides: - peano ==0.1.0.1 - pedersen-commitment ==0.2.0 - pem ==0.2.4 - - percent-format ==0.0.2 - - peregrin ==0.3.3 + - percent-format ==0.0.4 - perfect-hash-generator ==1.0.0 - - persist ==0.1.1.5 - - persistent ==2.13.3.5 + - persistent ==2.14.5.1 - persistent-discover ==0.1.0.6 - persistent-documentation ==0.1.0.4 - persistent-iproute ==0.2.5 + - persistent-lens ==1.0.0 - persistent-mongoDB ==2.13.0.1 + - persistent-mtl ==0.5.0.1 - persistent-mysql ==2.13.1.4 - persistent-pagination ==0.1.1.2 - persistent-postgresql ==2.13.5.2 - - persistent-qq ==2.12.0.2 + - persistent-qq ==2.12.0.5 - persistent-redis ==2.13.0.1 - persistent-refs ==0.4 - persistent-sqlite ==2.13.1.1 - persistent-template ==2.12.0.0 - - persistent-test ==2.13.1.2 + - persistent-test ==2.13.1.3 - persistent-typed-db ==0.1.0.7 - pg-harness-client ==0.6.0 - pgp-wordlist ==0.1.0.3 - pg-transact ==0.3.2.0 - phantom-state ==0.2.1.2 - - phatsort ==0.5.0.1 + - phatsort ==0.6.0.0 - picosat ==0.1.6 - pid1 ==0.1.3.1 - pinch ==0.4.3.0 - pipes ==4.3.16 - - pipes-attoparsec ==0.5.1.5 + - pipes-attoparsec ==0.6.0 - pipes-bytestring ==2.1.7 - pipes-concurrency ==2.0.14 - pipes-csv ==1.4.3 @@ -1914,6 +1884,7 @@ default-package-overrides: - pipes-fastx ==0.3.0.0 - pipes-fluid ==0.6.0.1 - pipes-group ==1.0.12 + - pipes-http ==1.0.6 - pipes-mongodb ==0.1.0.0 - pipes-ordered-zip ==1.2.1 - pipes-parse ==3.0.9 @@ -1932,19 +1903,13 @@ default-package-overrides: - pointedlist ==0.6.1 - pointless-fun ==1.1.0.8 - poll ==0.0.0.2 - - poly ==0.5.1.0 - poly-arity ==0.1.0 - polynomials-bernstein ==1.1.2 - polyparse ==1.13 - - polysemy ==1.7.1.0 - - polysemy-extra ==0.2.1.0 + - polysemy ==1.9.1.0 - polysemy-fs ==0.1.0.0 - - polysemy-kvstore ==0.1.3.0 - - polysemy-methodology ==0.2.2.0 - polysemy-plugin ==0.4.5.0 - - polysemy-several ==0.1.1.0 - - polysemy-webserver ==0.2.1.1 - - polysemy-zoo ==0.8.1.0 + - polysemy-webserver ==0.2.1.2 - pontarius-xmpp ==0.5.6.6 - pooled-io ==0.0.2.3 - portable-lines ==0.1 @@ -1957,21 +1922,20 @@ default-package-overrides: - postgresql-libpq ==0.9.5.0 - postgresql-libpq-notify ==0.2.0.0 - postgresql-migration ==0.2.1.7 - - postgresql-query ==3.10.0 - postgresql-schema ==0.1.14 - - postgresql-simple ==0.6.4 + - postgresql-simple ==0.6.5.1 - postgresql-simple-url ==0.2.1.0 - postgresql-syntax ==0.4.1 - postgresql-typed ==0.6.2.2 - post-mess-age ==0.2.1.0 - pptable ==0.3.0.0 - pqueue ==1.4.3.0 - - prefix-units ==0.2.0 + - prairie ==0.0.2.0 + - prefix-units ==0.3.0.1 - prelude-compat ==0.0.0.2 - prelude-safeenum ==0.1.1.3 - prettyclass ==1.0.0.0 - pretty-class ==1.0.1.1 - - pretty-diff ==0.4.0.3 - pretty-hex ==1.1 - prettyprinter ==1.7.1 - prettyprinter-ansi-terminal ==1.1.3 @@ -1987,9 +1951,9 @@ default-package-overrides: - pretty-terminal ==0.1.0.0 - pretty-types ==0.4.0.0 - primes ==0.2.1.0 - - primitive ==0.7.3.0 + - primitive ==0.8.0.0 - primitive-addr ==0.1.0.2 - - primitive-extras ==0.10.1.6 + - primitive-extras ==0.10.1.7 - primitive-offset ==0.2.0.0 - primitive-unaligned ==0.1.1.2 - primitive-unlifted ==0.1.3.1 @@ -1999,14 +1963,11 @@ default-package-overrides: - process-extras ==0.7.4 - product-profunctors ==0.11.1.1 - profiterole ==0.1 - - profiteur ==0.4.6.1 - profunctors ==5.6.2 - projectroot ==0.2.0.1 - project-template ==0.2.1.0 - - prometheus ==2.2.3 - prometheus-client ==1.1.0 - prometheus-metrics-ghc ==1.0.1.2 - - prometheus-wai-middleware ==1.0.1.0 - promises ==0.3 - prompt ==0.1.1.2 - prospect ==0.1.0.0 @@ -2015,23 +1976,20 @@ default-package-overrides: - protocol-radius ==0.0.1.1 - protocol-radius-test ==0.1.0.1 - proto-lens ==0.7.1.3 - - proto-lens-arbitrary ==0.1.2.11 - proto-lens-optparse ==0.1.1.10 - - proto-lens-protobuf-types ==0.7.1.2 - - proto-lens-protoc ==0.7.1.1 - proto-lens-runtime ==0.7.0.4 - - proto-lens-setup ==0.4.0.6 - protolude ==0.3.3 - proxied ==0.3.1 - psql-helpers ==0.1.0.0 + - PSQueue ==1.2.0 - psqueues ==0.2.7.3 - pthread ==0.2.1 - ptr ==0.16.8.4 - - ptr-poker ==0.1.2.8 + - ptr-poker ==0.1.2.13 - pulse-simple ==0.1.14 - pureMD5 ==2.1.4 - - purescript-bridge ==0.14.0.0 - - pusher-http-haskell ==2.1.0.13 + - purescript-bridge ==0.15.0.0 + - pusher-http-haskell ==2.1.0.15 - pvar ==1.0.0.0 - pwstore-fast ==2.4.4 - PyF ==0.11.1.1 @@ -2039,6 +1997,7 @@ default-package-overrides: - qm-interpolated-string ==0.3.1.0 - qrcode-core ==0.9.8 - qrcode-juicypixels ==0.8.5 + - quaalude ==0.0.0.1 - quadratic-irrational ==0.1.1 - QuasiText ==0.1.2.6 - QuickCheck ==2.14.3 @@ -2046,9 +2005,11 @@ default-package-overrides: - quickcheck-assertions ==0.3.0 - quickcheck-classes ==0.6.5.0 - quickcheck-classes-base ==0.6.2.0 + - quickcheck-groups ==0.0.0.0 - quickcheck-higherorder ==0.1.0.1 - quickcheck-instances ==0.3.29.1 - quickcheck-io ==0.2.0 + - quickcheck-monoid-subclasses ==0.1.0.0 - quickcheck-simple ==0.1.1.1 - quickcheck-special ==0.1.0.6 - quickcheck-state-machine ==0.7.3 @@ -2071,49 +2032,53 @@ default-package-overrides: - random-shuffle ==0.0.4 - random-tree ==0.6.0.5 - range ==0.3.0.2 - - ranged-list ==0.1.2.0 + - ranged-list ==0.1.2.1 - Ranged-sets ==0.4.0 - ranges ==0.2.4 - range-set-list ==0.1.3.1 - rank1dynamic ==0.4.1 - - rank2classes ==1.4.6 - Rasterific ==0.7.5.4 - rasterific-svg ==0.3.3.2 - - ratel ==2.0.0.8 + - ratel ==2.0.0.9 + - rate-limit ==1.4.3 - ratel-wai ==2.0.0.4 - ratio-int ==0.1.2 - rattle ==0.2 - - rattletrap ==11.2.14 + - rattletrap ==12.0.3 - Rattus ==0.5.1 - rawfilepath ==1.0.1 - rawstring-qm ==0.2.3.0 - raw-strings-qq ==1.1 - rcu ==0.2.6 + - rdf ==0.1.0.7 - rdtsc ==1.3.0.1 - re2 ==0.3 + - reactive-balsa ==0.4.0.1 - reactive-banana ==1.3.2.0 + - reactive-banana-bunch ==1.0.0.1 + - reactive-jack ==0.4.1.2 + - reactive-midyim ==0.4.1.1 + - readable ==0.3.1 - read-editor ==0.1.0.2 - read-env-var ==1.0.0.0 - - rebase ==1.16.1 + - rebase ==1.19 - rec-def ==0.2.1 - record-dot-preprocessor ==0.2.16 - record-hasfield ==1.0 - - rec-smallarray ==0.1.0.0 - recursion-schemes ==5.2.2.4 - - recv ==0.0.0 - - redact ==0.4.0.0 + - recv ==0.1.0 + - redact ==0.5.0.0 - reddit-scrape ==0.0.1 - - redis-resp ==1.0.0 + - redis-glob ==0.1.0.5 - reducers ==3.12.4 - refact ==0.3.0.2 - ref-fd ==0.5.0.1 - refined ==0.8.1 + - refinery ==0.4.0.0 - reflection ==2.1.7 - reform ==0.2.7.5 - reform-blaze ==0.2.4.4 - - reform-hamlet ==0.0.5.3 - reform-happstack ==0.2.5.6 - - reform-hsp ==0.2.7.2 - RefSerialize ==0.4.0 - ref-tf ==0.5.0.1 - regex ==1.1.0.2 @@ -2127,31 +2092,24 @@ default-package-overrides: - regex-posix-clib ==2.7 - regex-tdfa ==1.3.2.1 - regex-with-pcre ==1.1.0.2 - - registry ==0.3.3.4 - - registry-aeson ==0.2.3.3 - - registry-hedgehog ==0.7.2.0 - - registry-hedgehog-aeson ==0.2.0.0 - - registry-options ==0.1.0.0 - reinterpret-cast ==0.1.0 - rel8 ==1.4.1.0 - relapse ==1.0.0.1 - reliable-io ==0.0.2 - - relude ==1.1.0.0 + - relude ==1.2.0.0 - renderable ==0.2.0.1 - - reorder-expression ==0.1.0.0 - - repa ==3.4.1.5 - - repa-algorithms ==3.4.1.5 - - repa-io ==3.4.1.2 - - replace-attoparsec ==1.4.5.0 - - replace-megaparsec ==1.4.5.0 + - replace-attoparsec ==1.5.0.0 + - replace-megaparsec ==1.5.0.1 - repline ==0.4.2.0 - req ==3.13.0 - req-conduit ==1.0.1 - - rerebase ==1.16.1 + - rerebase ==1.19 - reroute ==0.7.0.0 - - resolv ==0.1.2.0 - - resource-pool ==0.2.3.2 + - resistor-cube ==0.0.1.4 + - resolv ==0.2.0.2 + - resource-pool ==0.4.0.0 - resourcet ==1.2.6 + - rest-rewrite ==0.4.2 - result ==0.2.6.0 - retry ==0.9.3.1 - rev-state ==0.1.2 @@ -2163,20 +2121,21 @@ default-package-overrides: - riak-protobuf ==0.25.0.0 - rio ==0.1.22.0 - rio-orphans ==0.1.2.0 - - rio-prettyprint ==0.1.3.0 + - rio-prettyprint ==0.1.4.0 - rng-utils ==0.3.1 - - roc-id ==0.1.0.0 - rocksdb-haskell ==1.0.1 - rocksdb-haskell-jprupp ==2.1.4 - rocksdb-query ==0.4.2 - roles ==0.2.1.0 - rollbar ==1.1.3 + - rope-utf16-splay ==0.4.0.0 - rosezipper ==0.2 - rot13 ==0.2.0.1 + - row-types ==1.0.1.2 - rpmbuild-order ==0.4.10 - rpm-nvr ==0.1.2 - rp-tree ==0.7.1 - - rrb-vector ==0.1.1.0 + - rrb-vector ==0.2.0.0 - RSA ==2.4.1 - rss ==3000.2.0.7 - rss-conduit ==0.6.0.1 @@ -2193,26 +2152,28 @@ default-package-overrides: - safe-coloured-text-terminfo ==0.1.0.0 - safecopy ==0.10.4.2 - safe-decimal ==0.2.1.0 - - safe-exceptions ==0.1.7.3 + - safe-exceptions ==0.1.7.4 - safe-exceptions-checked ==0.1.0 - safe-foldable ==0.1.0.0 + - safe-gen ==1.0.1 - safeio ==0.0.5.0 - - safe-json ==1.1.3.1 + - safe-json ==1.1.4.0 - safe-money ==0.9.1 - SafeSemaphore ==0.10.1 + - saltine ==0.2.1.0 - salve ==2.0.0.3 - sample-frame ==0.0.4 - sample-frame-np ==0.0.5 - sampling ==0.3.5 - sandi ==0.5 - - sandwich ==0.1.4.0 + - sandwich ==0.1.5.0 - sandwich-hedgehog ==0.1.3.0 - sandwich-quickcheck ==0.1.0.7 - - sandwich-slack ==0.1.1.0 - - sandwich-webdriver ==0.1.2.0 + - sandwich-slack ==0.1.2.0 + - sandwich-webdriver ==0.2.2.0 - say ==0.1.0.1 - - sbp ==4.9.0 - - sbv ==9.0 + - sbp ==4.15.0 + - sbv ==10.2 - scalpel ==0.6.2.1 - scalpel-core ==0.6.2.1 - scanf ==0.1.0.0 @@ -2231,14 +2192,9 @@ default-package-overrides: - search-algorithms ==0.3.2 - secp256k1-haskell ==0.6.1 - securemem ==0.1.10 - - selda ==0.5.2.0 - - selda-json ==0.1.1.1 - - selda-sqlite ==0.1.7.2 - selections ==0.3.0.0 - - selective ==0.5 - - semialign ==1.2.0.1 - - semialign-indexed ==1.2 - - semialign-optics ==1.2 + - selective ==0.7 + - semialign ==1.3 - semigroupoid-extras ==5 - semigroupoids ==5.3.7 - semigroups ==0.20 @@ -2248,18 +2204,15 @@ default-package-overrides: - sendfile ==0.7.11.4 - sendgrid-v3 ==1.0.0.1 - seqalign ==0.2.0.4 - - seqid ==0.6.2 + - seqid ==0.6.3 - seqid-streams ==0.7.2 - - sequence-formats ==1.6.6.1 - - sequenceTools ==1.5.2 - - serf ==0.1.1.0 + - sequence-formats ==1.7.1 + - sequenceTools ==1.5.3.1 - serialise ==0.2.6.0 - servant ==0.19.1 - servant-auth ==0.4.1.0 - - servant-auth-client ==0.4.1.0 + - servant-auth-client ==0.4.1.1 - servant-auth-docs ==0.2.10.0 - - servant-auth-server ==0.4.7.0 - - servant-auth-swagger ==0.2.10.1 - servant-auth-wordpress ==1.0.0.2 - servant-blaze ==0.9.1 - servant-cassava ==0.10.2 @@ -2274,7 +2227,6 @@ default-package-overrides: - servant-exceptions-server ==0.2.1 - servant-foreign ==0.15.4 - servant-http-streams ==0.18.4 - - servant-JuicyPixels ==0.3.1.0 - servant-lucid ==0.9.0.6 - servant-machines ==0.15.1 - servant-multipart ==0.12.1 @@ -2284,18 +2236,15 @@ default-package-overrides: - servant-pipes ==0.15.3 - servant-rate-limit ==0.2.0.0 - servant-rawm ==1.0.0.0 - - servant-ruby ==0.9.0.0 - servant-server ==0.19.2 - servant-static-th ==1.0.0.0 - servant-subscriber ==0.7.0.0 - servant-swagger ==1.1.11 - servant-swagger-ui ==0.3.5.5.0.0 - servant-swagger-ui-core ==0.3.5 - - servant-swagger-ui-redoc ==0.3.4.1.22.3 - servant-websockets ==2.0.0 - - servant-xml ==1.0.1.4 + - servant-xml ==1.0.2 - serversession ==1.0.3 - - serversession-backend-persistent ==2.0.1 - serversession-backend-redis ==1.0.5 - serversession-frontend-wai ==1.0.1 - serversession-frontend-yesod ==1.0.1 @@ -2307,64 +2256,67 @@ default-package-overrides: - set-monad ==0.3.0.0 - sets ==0.0.6.2 - sexp-grammar ==2.3.4.1 - - sexpr-parser ==0.2.2.0 - SHA ==1.6.4.4 - shake ==0.19.7 - - shake-language-c ==0.12.0 - shake-plus ==0.3.4.0 - - shake-plus-extended ==0.4.1.0 - - shakespeare ==2.0.30 + - shakespeare ==2.1.0 - shakespeare-text ==1.1.0 - shared-memory ==0.2.0.1 - shell-conduit ==5.0.0 - shell-escape ==0.2.0 - - shellmet ==0.0.4.1 - shelltestrunner ==1.9 - shell-utility ==0.1 - shellwords ==0.1.3.1 - - shelly ==1.10.0.1 - - shikensu ==0.4.1 + - shelly ==1.12.1 - should-not-typecheck ==2.1.0 - show-combinators ==0.2.0.0 + - shower ==0.2.0.3 - siggy-chardust ==1.0.0 - signal ==0.1.0.4 - silently ==1.2.5.3 - - simple-affine-space ==0.1.1 + - simple ==2.0.0 + - simple-affine-space ==0.2.1 - simple-cabal ==0.1.3.1 - simple-cmd ==0.2.7 - simple-cmd-args ==0.1.8 + - simple-expr ==0.1.0.2 - simple-media-timestamp ==0.2.1.0 - simple-media-timestamp-attoparsec ==0.1.0.0 - - simple-media-timestamp-formatting ==0.1.1.0 - - simple-prompt ==0.1.0 + - simple-prompt ==0.2.0.1 - simple-reflect ==0.3.3 - - simple-sendfile ==0.2.31 + - simple-sendfile ==0.2.32 + - simple-session ==2.0.0 + - simple-templates ==2.0.0 - simple-vec3 ==0.6.0.1 - since ==0.0.0 - singleton-bool ==0.1.6 - singleton-nats ==0.4.6 - - singletons ==3.0.1 - - singletons-base ==3.1 - - singletons-presburger ==0.6.1.0 - - singletons-th ==3.1 + - singletons ==3.0.2 + - singletons-base ==3.1.1 + - singletons-presburger ==0.7.2.0 + - singletons-th ==3.1.1 - Sit ==0.2022.3.18 - sitemap-gen ==0.1.0.0 - size-based ==0.1.3.1 - - sized ==1.0.0.2 + - sized ==1.1.0.0 - skein ==1.0.9.4 - skews ==0.1.0.3 - skip-var ==0.1.1.0 - - skylighting ==0.13.2.1 - - skylighting-core ==0.13.2.1 + - skylighting ==0.13.4 + - skylighting-core ==0.13.4 - skylighting-format-ansi ==0.1 - skylighting-format-blaze-html ==0.1.1 - skylighting-format-context ==0.1.0.2 - skylighting-format-latex ==0.1 - slack-progressbar ==0.1.0.1 - slave-thread ==1.1.0.2 - - slynx ==0.7.2.1 + - slick ==1.2.1.0 + - slist ==0.2.1.0 + - slynx ==0.7.2.2 - smallcheck ==1.2.1.1 - smtp-mail ==0.3.0.0 + - snap-blaze ==0.2.1.5 + - snap-core ==1.0.5.1 - snowflake ==0.1.1.1 - socket ==0.8.3.0 - socks ==0.6.1 @@ -2374,20 +2326,20 @@ default-package-overrides: - sop-core ==0.5.0.2 - sort ==1.0.0.0 - sorted-list ==0.2.1.0 + - sound-collage ==0.2.1 - sourcemap ==0.1.7 - sox ==0.2.3.2 + - soxlib ==0.0.3.2 - spacecookie ==1.0.0.2 - - sparse-linear-algebra ==0.3.1 - spatial-math ==0.2.7.0 - - spdx ==1.0.0.3 - special-values ==0.1.0.0 - speculate ==0.4.14 - speedy-slice ==0.3.2 - - Spintax ==0.3.6 - splice ==0.6.1.1 - split ==0.2.3.5 - splitmix ==0.1.0.4 - splitmix-distributions ==1.0.0 + - split-record ==0.1.1.4 - Spock ==0.14.0.0 - Spock-api ==0.14.0.0 - Spock-api-server ==0.14.0.0 @@ -2403,10 +2355,8 @@ default-package-overrides: - squeather ==0.8.0.0 - srcloc ==0.6.0.1 - srt ==0.1.2.0 - - srt-attoparsec ==0.1.0.0 - - srt-formatting ==0.1.0.0 - - stache ==2.3.3 - - stack ==2.9.1 + - srtree ==1.0.0.5 + - stache ==2.3.4 - stack-all ==0.4.1 - stack-clean-old ==0.4.6 - stack-templatizer ==0.1.1.0 @@ -2414,11 +2364,12 @@ default-package-overrides: - stateref ==0.3 - statestack ==0.3.1.1 - StateVar ==1.2.2 - - stateWriter ==0.3.0 + - stateWriter ==0.4.0 + - static-canvas ==0.2.0.3 - static-text ==0.2.0.7 - statistics ==0.16.2.0 + - statistics-linreg ==0.3 - status-notifier-item ==0.3.1.0 - - stb-image-redux ==0.2.1.2 - step-function ==0.2.0.1 - stitch ==0.6.0.0 - stm-chans ==3.0.0.9 @@ -2434,51 +2385,52 @@ default-package-overrides: - storable-complex ==0.2.3.0 - storable-endian ==0.2.6.1 - storable-record ==0.0.7 - - storable-tuple ==0.0.3.3 + - storable-tuple ==0.1 - storablevector ==0.2.13.1 - store ==0.7.16 - store-core ==0.4.4.4 - store-streaming ==0.2.0.3 - stratosphere ==0.60.0 - Stream ==0.4.7.2 - - streaming ==0.2.3.1 + - streaming ==0.2.4.0 - streaming-attoparsec ==1.0.0.1 - - streaming-bytestring ==0.2.4 - - streaming-cassava ==0.2.0.0 + - streaming-bytestring ==0.3.1 - streaming-commons ==0.2.2.6 - streaming-wai ==0.1.1 - - streamly ==0.8.1.1 + - streamly ==0.9.0 + - streamly-bytestring ==0.2.0 + - streamly-core ==0.1.0 + - streamly-examples ==0.1.3 + - streamly-process ==0.3.0 - streams ==3.3.2 - streamt ==0.5.0.1 - - strict ==0.4.0.1 - - strict-base-types ==0.7 + - strict ==0.5 + - strict-base-types ==0.8 - strict-concurrency ==0.2.4.3 - - strict-lens ==0.4.0.2 + - strict-lens ==0.4.0.3 - strict-list ==0.1.7.1 - strict-tuple ==0.1.5.2 - strict-wrapper ==0.0.0.0 - stringable ==0.1.3 - stringbuilder ==0.5.1 - - string-class ==0.1.7.0 - string-combinators ==0.6.0.5 - string-conv ==0.2.0 - string-conversions ==0.4.0.1 - string-interpolate ==0.3.2.1 - stringprep ==1.0.0 - - string-qq ==0.0.4 + - string-qq ==0.0.5 - string-random ==0.1.4.3 - stringsearch ==0.3.6.6 - string-transform ==1.1.1 - - stripe-concepts ==1.0.3.2 - - stripe-scotty ==1.1.0.3 - - stripe-signature ==1.0.0.15 - - stripe-wreq ==1.0.1.15 - - strive ==6.0.0.7 - - strongweak ==0.3.2 + - string-variants ==0.2.2.0 + - stripe-concepts ==1.0.3.3 + - stripe-scotty ==1.1.0.4 + - stripe-signature ==1.0.0.16 + - stripe-wreq ==1.0.1.16 + - strive ==6.0.0.9 - structs ==0.1.8 - structured ==0.1.1 - structured-cli ==2.7.0.1 - - stylish-haskell ==0.14.3.0 - subcategories ==0.2.0.1 - sundown ==0.6 - superbuffer ==0.3.1.2 @@ -2488,15 +2440,13 @@ default-package-overrides: - swagger2 ==2.8.7 - swish ==0.10.4.0 - syb ==0.7.2.3 - - syb-with-class ==0.6.1.14 - - sydtest ==0.13.0.4 + - sydtest ==0.15.0.0 - sydtest-aeson ==0.1.0.0 - sydtest-amqp ==0.1.0.0 - sydtest-autodocodec ==0.0.0.0 - sydtest-discover ==0.0.0.3 - - sydtest-hedgehog ==0.3.0.1 + - sydtest-hedgehog ==0.4.0.0 - sydtest-hedis ==0.0.0.0 - - sydtest-hspec ==0.3.0.2 - sydtest-mongo ==0.0.0.0 - sydtest-persistent ==0.0.0.1 - sydtest-persistent-postgresql ==0.2.0.2 @@ -2506,21 +2456,29 @@ default-package-overrides: - sydtest-servant ==0.2.0.2 - sydtest-typed-process ==0.0.0.0 - sydtest-wai ==0.2.0.0 + - sydtest-webdriver ==0.0.0.1 + - sydtest-webdriver-screenshot ==0.0.0.1 + - sydtest-webdriver-yesod ==0.0.0.1 - sydtest-yesod ==0.3.0.1 - symbol ==0.2.4 - symengine ==0.1.2.0 - symmetry-operations-symbols ==0.0.2.1 + - synthesizer-alsa ==0.5.0.6 - synthesizer-core ==0.8.3 + - synthesizer-dimensional ==0.8.1.1 + - synthesizer-midi ==0.6.1.2 - sysinfo ==0.1.1 - system-argv0 ==0.1.1 - systemd ==2.3.0 + - systemd-socket-activation ==1.1.0.1 - system-fileio ==0.3.16.4 - system-filepath ==0.4.14 - system-info ==0.5.2 - tabular ==0.2.2.8 - - tagged ==0.8.6.1 + - tagchup ==0.4.1.2 + - tagged ==0.8.7 - tagged-binary ==0.2.0.1 - - tagged-identity ==0.1.3 + - tagged-identity ==0.1.4 - tagged-transformer ==0.8.2 - tagshare ==0.0 - tagsoup ==0.14.8 @@ -2528,43 +2486,42 @@ default-package-overrides: - tao ==1.0.0 - tao-example ==1.0.0 - tar ==0.5.1.1 - - tar-conduit ==0.3.2 + - tar-conduit ==0.3.2.1 - tardis ==0.4.4.0 - tasty ==1.4.3 - tasty-ant-xml ==1.1.8 - - tasty-autocollect ==0.3.2.0 + - tasty-autocollect ==0.4.1 - tasty-bench ==0.3.4 - tasty-dejafu ==2.1.0.0 - - tasty-discover ==4.2.2 + - tasty-discover ==5.0.0 - tasty-expected-failure ==0.12.3 - tasty-fail-fast ==0.0.3 - tasty-focus ==1.0.1 - tasty-golden ==2.3.5 - - tasty-hedgehog ==1.3.1.0 - - tasty-hslua ==1.0.2 - - tasty-hspec ==1.2.0.2 + - tasty-hedgehog ==1.4.0.1 + - tasty-hslua ==1.1.0 + - tasty-hspec ==1.2.0.3 - tasty-html ==0.4.2.1 - tasty-hunit ==0.10.0.3 - tasty-hunit-compat ==0.2.0.1 - - tasty-inspection-testing ==0.1.0.1 + - tasty-inspection-testing ==0.2 - tasty-kat ==0.0.3 - tasty-leancheck ==0.0.2 - - tasty-lua ==1.0.2 - - tasty-program ==1.0.5 + - tasty-lua ==1.1.0 + - tasty-program ==1.1.0 - tasty-quickcheck ==0.10.2 - tasty-rerun ==1.1.18 - tasty-silver ==3.3.1.1 - tasty-smallcheck ==0.8.2 - tasty-tap ==0.1.0 - - tasty-test-reporter ==0.1.1.4 - tasty-th ==0.1.7 - tasty-wai ==0.1.2.0 - tce-conf ==1.3 - tcp-streams ==1.0.1.1 - - tdigest ==0.2.1.1 + - tdigest ==0.3 - teardown ==0.5.0.1 - - telegram-bot-simple ==0.6.2 - - template ==0.2.0.10 + - telegram-bot-api ==6.7.1 + - telegram-bot-simple ==0.12 - template-haskell-compat-v0208 ==0.1.9.2 - temporary ==1.3 - temporary-rc ==1.2.0.3 @@ -2578,7 +2535,7 @@ default-package-overrides: - termbox-tea ==0.1.0 - terminal-progress-bar ==0.4.2 - terminal-size ==0.3.4 - - termonad ==4.4.0.0 + - termonad ==4.5.0.0 - test-framework ==0.8.2.0 - test-framework-hunit ==0.3.0.2 - test-framework-leancheck ==0.0.4 @@ -2587,12 +2544,14 @@ default-package-overrides: - test-fun ==0.1.0.0 - testing-feat ==1.1.1.1 - testing-type-modifiers ==0.1.0.1 - - texmath ==0.12.5.5 + - texmath ==0.12.8 - text-ansi ==0.2.1.1 - text-binary ==0.2.1.1 - text-builder ==0.6.7 - text-builder-dev ==0.3.3.2 + - text-builder-linear ==0.1.1 - text-conversions ==0.3.1.1 + - text-format ==0.3.2.1 - text-icu ==0.8.0.2 - text-latin1 ==0.3.1 - text-ldap ==0.1.1.14 @@ -2606,7 +2565,7 @@ default-package-overrides: - text-short ==0.1.5 - text-show ==3.10.3 - text-show-instances ==3.9.5 - - text-zipper ==0.12 + - text-zipper ==0.13 - tfp ==1.0.2 - tf-random ==0.5 - th-abstraction ==0.4.5.0 @@ -2614,14 +2573,13 @@ default-package-overrides: - th-compat ==0.1.4 - th-constraint-compat ==0.0.1.0 - th-data-compat ==0.1.2.0 - - th-desugar ==1.13.1 + - th-desugar ==1.14 - th-env ==0.1.1 - - these ==1.1.1.1 - - these-lens ==1.0.1.2 + - these ==1.2 + - these-lens ==1.0.1.3 - these-optics ==1.0.1.2 - these-skinny ==0.7.5 - th-expand-syns ==0.4.11.0 - - th-extras ==0.0.0.6 - th-lego ==0.3.0.2 - th-lift ==0.8.3 - th-lift-instances ==0.1.20 @@ -2635,11 +2593,11 @@ default-package-overrides: - thread-supervisor ==0.2.0.0 - th-reify-compat ==0.0.1.5 - th-reify-many ==0.1.10 - - through-text ==0.1.0.0 - th-strict-compat ==0.1.0.1 - th-test-utils ==1.2.1 - th-utilities ==0.2.5.0 - - tidal ==1.9.2 + - thyme ==0.4 + - tidal ==1.9.4 - tidal-link ==1.0.1 - tile ==0.3.0.0 - time-compat ==1.9.6.1 @@ -2650,7 +2608,7 @@ default-package-overrides: - time-locale-compat ==0.1.1.5 - time-locale-vietnamese ==1.0.0.0 - time-manager ==0.0.0 - - time-parsers ==0.1.2.1 + - time-parsers ==0.2 - timerep ==2.1.0.0 - timers-tick ==0.5.0.4 - timer-wheel ==0.4.0.1 @@ -2661,19 +2619,19 @@ default-package-overrides: - timezone-olson-th ==0.1.0.11 - timezone-series ==0.1.13 - titlecase ==1.0.1 - - tldr ==0.9.2 - - tls ==1.5.8 - - tls-debug ==0.4.8 + - tls ==1.6.0 - tls-session-manager ==0.0.4 - - tlynx ==0.7.2.1 + - tlynx ==0.7.2.2 - tmapchan ==0.0.3 - tmapmvar ==0.0.4 - tmp-postgres ==1.34.1.0 - - tmp-proc ==0.5.1.3 - - tmp-proc-postgres ==0.5.2.2 - - tmp-proc-rabbitmq ==0.5.1.2 - - tmp-proc-redis ==0.5.1.2 + - tmp-proc ==0.5.1.4 + - tmp-proc-postgres ==0.5.2.3 + - tmp-proc-rabbitmq ==0.5.1.4 + - tmp-proc-redis ==0.5.1.4 + - token-bucket ==0.1.0.1 - toml-reader ==0.2.1.0 + - toml-reader-parse ==0.1.1.1 - tophat ==1.0.5.1 - topograph ==1.0.0.2 - torrent ==10000.1.3 @@ -2688,9 +2646,10 @@ default-package-overrides: - transformers-fix ==1.0 - transient ==0.7.0.0 - traverse-with-class ==1.0.1.1 - - tree-diff ==0.2.2 + - tree-diff ==0.3.0.1 - tree-fun ==0.8.1.0 - tree-view ==0.5.1 + - trie-simple ==0.4.2 - trifecta ==2.1.2 - trimdent ==0.1.0.0 - triplesec ==0.2.2.1 @@ -2703,11 +2662,11 @@ default-package-overrides: - tuples-homogenous-h98 ==0.1.1.0 - tuple-sop ==0.3.1.0 - tuple-th ==0.2.5 - - turtle ==1.5.25 + - turtle ==1.6.1 - twitter-conduit ==0.6.1 - twitter-types ==0.11.0 - twitter-types-lens ==0.11.0 - - typecheck-plugin-nat-simple ==0.1.0.7 + - typecheck-plugin-nat-simple ==0.1.0.9 - typed-process ==0.2.11.0 - typed-uuid ==0.2.0.0 - type-equality ==1 @@ -2719,14 +2678,14 @@ default-package-overrides: - type-level-natural-number ==2.0 - type-level-numbers ==0.1.1.2 - type-map ==0.1.7.0 - - type-natural ==1.1.0.1 + - type-natural ==1.3.0.0 - typenums ==0.1.4 - type-of-html ==1.6.2.0 - type-of-html-static ==0.1.0.2 - - type-operators ==0.2.0.0 - type-rig ==0.1 - type-spec ==0.4.0.0 - typography-geometry ==1.0.1.0 + - typst-symbols ==0.1.2 - tz ==0.1.3.6 - tzdata ==0.2.20230322.0 - tztime ==0.1.0.0 @@ -2745,13 +2704,13 @@ default-package-overrides: - unfork ==1.0.0.1 - unicode ==0.0.1.1 - unicode-collation ==0.1.3.4 - - unicode-data ==0.3.1 + - unicode-data ==0.4.0.1 - unicode-show ==0.1.1.1 - unicode-transforms ==0.4.0.1 - unidecode ==0.1.0.4 - unification-fd ==0.11.2 + - union ==0.1.2 - union-angle ==0.1.0.1 - - union-find ==0.2 - unipatterns ==0.0.0.0 - uniplate ==1.6.13 - uniq-deep ==1.2.1 @@ -2766,28 +2725,26 @@ default-package-overrides: - universe-instances-extended ==1.1.3 - universe-reverse-instances ==1.1.1 - universe-some ==1.2.1 - - universum ==1.8.1.1 - - unix-bytestring ==0.3.7.8 - - unix-compat ==0.5.4 - - unix-time ==0.4.9 + - universum ==1.8.2 + - unix-bytestring ==0.4.0 + - unix-compat ==0.7 + - unix-time ==0.4.10 - unjson ==0.15.4 - unliftio ==0.2.25.0 - unliftio-core ==0.2.1.0 - unliftio-path ==0.0.2.0 - - unliftio-pool ==0.2.2.0 - - unliftio-streams ==0.1.1.1 + - unliftio-pool ==0.4.2.0 - unlit ==0.4.0.0 - unordered-containers ==0.2.19.1 - unsafe ==0.0 - - urbit-hob ==0.3.3 - uri-bytestring ==0.3.3.1 - uri-bytestring-aeson ==0.1.0.8 - uri-encode ==1.5.0.7 - url ==2.1.3 - - userid ==0.1.3.7 - users ==0.5.0.0 - users-postgresql-simple ==0.5.0.2 - users-test ==0.5.0.1 + - utf8-light ==0.4.4.0 - utf8-string ==1.0.2 - utility-ht ==0.0.17 - uuid ==1.3.15 @@ -2795,7 +2752,6 @@ default-package-overrides: - valida ==1.1.0 - valida-base ==0.2.0 - validate-input ==0.5.0.0 - - validation ==1.1.2 - validationt ==0.3.0 - validity ==0.12.0.1 - validity-aeson ==0.2.0.5 @@ -2812,20 +2768,16 @@ default-package-overrides: - validity-uuid ==0.1.0.3 - validity-vector ==0.2.0.3 - valor ==1.0.0.0 - - variable-media-field ==0.1.0.0 - - variable-media-field-dhall ==0.1.0.0 - - variable-media-field-optics ==0.1.0.0 - varying ==0.8.1.0 - vault ==0.3.1.5 - vcs-ignore ==0.0.2.0 - - vec ==0.4.1 - - vector ==0.12.3.1 - - vector-algorithms ==0.8.0.4 + - vec ==0.5 + - vector ==0.13.0.0 + - vector-algorithms ==0.9.0.1 - vector-binary-instances ==0.2.5.2 - vector-buffer ==0.4.1 - vector-builder ==0.3.8.4 - vector-bytes-instances ==0.1.1 - - vector-circular ==0.1.4 - vector-extras ==0.2.8 - vector-hashtables ==0.1.1.3 - vector-instances ==3.4.2 @@ -2837,7 +2789,7 @@ default-package-overrides: - vector-stream ==0.1.0.0 - vector-th-unbox ==0.2.2 - verbosity ==0.4.0.0 - - versions ==5.0.5 + - versions ==6.0.1 - vformat ==0.14.1.0 - vformat-time ==0.1.0.0 - ViennaRNAParser ==1.3.3 @@ -2847,16 +2799,17 @@ default-package-overrides: - vivid-osc ==0.5.0.0 - vivid-supercollider ==0.4.1.2 - void ==0.7.3 - - vty ==5.37 + - vty ==5.38 - wai ==3.2.3 - wai-app-static ==3.1.7.4 - wai-cli ==0.2.3 - wai-conduit ==3.0.0.4 + - wai-control ==0.2.0.0 - wai-cors ==0.2.7 - wai-enforce-https ==1.0.0.0 - wai-eventsource ==3.0.0 - wai-extra ==3.1.13.0 - - wai-feature-flags ==0.1.0.4 + - wai-feature-flags ==0.1.0.6 - wai-handler-launch ==3.0.3.1 - wai-logger ==2.4.0 - wai-middleware-bearer ==1.0.3 @@ -2868,29 +2821,27 @@ default-package-overrides: - wai-middleware-metrics ==0.2.4 - wai-middleware-prometheus ==1.0.0.1 - wai-middleware-static ==0.9.2 + - wai-middleware-throttle ==0.3.0.1 - wai-rate-limit ==0.3.0.0 - wai-rate-limit-redis ==0.2.0.1 - - wai-saml2 ==0.3.0.1 + - wai-saml2 ==0.4 - wai-session ==0.3.3 - wai-session-postgresql ==0.2.1.3 - wai-session-redis ==0.1.0.5 - wai-slack-middleware ==0.2.0 - wai-websockets ==3.0.1.2 - wakame ==0.1.0.0 - - warp ==3.3.23 - - warp-tls ==3.3.4 + - warp ==3.3.25 + - warp-tls ==3.3.6 - warp-tls-uid ==0.2.0.6 - wave ==0.2.0 - wcwidth ==0.0.2 - - webby ==1.1.1 - - webdriver ==0.10.0.1 + - webdriver ==0.11.0.0 - webex-teams-api ==0.2.0.1 - webex-teams-conduit ==0.2.0.1 - webgear-core ==1.0.5 - webgear-openapi ==1.0.5 - - webgear-server ==1.0.5 - webpage ==0.0.5.1 - - web-plugins ==0.4.1 - web-routes ==0.27.15 - web-routes-boomerang ==0.28.4.4 - web-routes-happstack ==0.23.12.3 @@ -2900,11 +2851,11 @@ default-package-overrides: - webrtc-vad ==0.1.0.3 - websockets ==0.12.7.3 - weigh ==0.0.16 + - welford-online-mean-variance ==0.2.0.0 - wide-word ==0.1.5.0 - - Win32 ==2.12.0.1 - Win32-notify ==0.3.0.3 - windns ==0.1.0.1 - - witch ==1.1.6.1 + - witch ==1.2.0.2 - withdependencies ==0.3.0 - witherable ==0.4.2 - within ==0.2.0.1 @@ -2941,15 +2892,14 @@ default-package-overrides: - xdg-desktop-entry ==0.1.1.1 - xdg-userdirs ==0.1.0.2 - xeno ==0.6 - - xlsx ==1.0.0.1 - - xlsx-tabular ==0.2.2.1 + - xlsx ==1.1.1 - xml ==1.3.14 - xml-basic ==0.1.3.2 - - xmlbf ==0.6.2 - - xmlbf-xeno ==0.2.1 - - xmlbf-xmlhtml ==0.2 - - xml-conduit ==1.9.1.2 - - xml-conduit-writer ==0.1.1.2 + - xmlbf ==0.7 + - xmlbf-xeno ==0.2.2 + - xmlbf-xmlhtml ==0.2.2 + - xml-conduit ==1.9.1.3 + - xml-conduit-writer ==0.1.1.4 - xmlgen ==0.6.2.2 - xml-hamlet ==0.5.0.2 - xml-helpers ==1.0.0 @@ -2963,23 +2913,22 @@ default-package-overrides: - xml-types ==0.3.8 - xmonad ==0.17.2 - xmonad-contrib ==0.17.1 - - xmonad-extras ==0.17.0 - xor ==0.0.1.1 - xss-sanitize ==0.3.7.2 - xxhash-ffi ==0.2.0.0 - - yaml ==0.11.11.1 - - yaml-unscrambler ==0.1.0.13 - - Yampa ==0.13.7 + - yaml ==0.11.11.2 + - yaml-unscrambler ==0.1.0.17 + - Yampa ==0.14.3 - yarn-lock ==0.6.5 - yeshql-core ==4.2.0.0 - yesod ==1.6.2.1 - - yesod-alerts ==0.1.3.0 - yesod-auth ==1.6.11.1 - yesod-auth-basic ==0.1.0.3 - yesod-auth-hashdb ==1.7.1.7 - yesod-auth-oauth2 ==0.7.1.0 + - yesod-auth-oidc ==0.1.4 - yesod-bin ==1.6.2.2 - - yesod-core ==1.6.24.2 + - yesod-core ==1.6.24.3 - yesod-eventsource ==1.6.0.1 - yesod-fb ==0.6.1 - yesod-form ==1.7.4 @@ -2987,6 +2936,7 @@ default-package-overrides: - yesod-gitrepo ==0.3.0 - yesod-gitrev ==0.2.2 - yesod-markdown ==0.12.6.13 + - yesod-middleware-csp ==1.2.0 - yesod-newsfeed ==1.7.0.0 - yesod-page-cursor ==2.0.1.0 - yesod-paginator ==1.1.2.2 @@ -3002,14 +2952,15 @@ default-package-overrides: - yjsvg ==0.2.0.1 - yjtools ==0.9.18 - yoga ==0.0.0.5 - - zenacy-html ==2.0.7 + - youtube ==0.2.1.1 + - zenacy-html ==2.1.0 - zenacy-unicode ==1.0.2 - zeromq4-haskell ==0.8.0 - zeromq4-patterns ==0.3.1.0 - zigzag ==0.0.1.0 - zim-parser ==0.2.1.0 - zio ==0.1.0.2 - - zip ==1.7.2 + - zip ==2.0.0 - zip-archive ==0.4.3 - zipper-extra ==0.1.3.2 - zippers ==0.3.2 @@ -3018,4 +2969,3 @@ default-package-overrides: - zlib-bindings ==0.1.1.5 - zot ==0.0.3 - zstd ==0.1.3.0 - - ztail ==1.2.0.3 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index ec59875b4e71..10340d5afe6c 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -108,7 +108,6 @@ dont-distribute-packages: - FComp - FM-SBLEX - FTPLine - - Facts - FailureT - FermatsLastMargin - FieldTrip @@ -155,6 +154,7 @@ dont-distribute-packages: - GtkTV - GuiHaskell - GuiTV + - H - HAppS-Data - HAppS-IxSet - HAppS-Server @@ -205,6 +205,7 @@ dont-distribute-packages: - HaTeX-meta - HaTeX-qq - HaVSA + - HaXPath - Hach - HarmTrace - HasGP @@ -228,6 +229,7 @@ dont-distribute-packages: - HsParrot - HsWebots - Hsed + - Hungarian-Munkres - Hydrogen - INblobs - IORefCAS @@ -240,6 +242,7 @@ dont-distribute-packages: - JsContracts - JsonGrammar - JuPyTer-notebook + - JuicyPixels-repa - JunkDB-driver-gdbm - JunkDB-driver-hashtables - KiCS @@ -279,6 +282,7 @@ dont-distribute-packages: - MonadLab - Monaris - Monatron-IO + - Mondrian - Monocle - MuCheck-HUnit - MuCheck-Hspec @@ -329,6 +333,7 @@ dont-distribute-packages: - RNAdraw - RNAlien - RNAwolf + - Raincat - Ranka - ReplaceUmlaut - RollingDirectory @@ -449,7 +454,9 @@ dont-distribute-packages: - adhoc-network - adict - adp-multi-monadiccp + - aeson-extra_0_5_1_3 - aeson-native + - aeson-pretty_0_8_10 - affine - afv - agda-server @@ -616,6 +623,8 @@ dont-distribute-packages: - amby - ampersand - amqp-streamly + - amqp-utils_0_6_4_0 + - amqp_0_22_2 - anatomy - animate-example - animate-frames @@ -638,6 +647,8 @@ dont-distribute-packages: - antiope-sqs - antiope-swf - antlrc + - apecs-gloss + - apecs-physics-gloss - apelsin - api-rpc-accumulate - api-rpc-pegnet @@ -661,6 +672,7 @@ dont-distribute-packages: - apotiki - approx-rand-test - arbor-monad-metric-datadog + - archive-libarchive - archive-tar-bytestring - archlinux-web - arduino-copilot @@ -672,11 +684,12 @@ dont-distribute-packages: - arithmetic-circuits - array-forth - arraylist + - ascii - ascii-cows - - ascii-superset_1_3_0_0 + - ascii-numbers + - ascii-superset - ascii-table - - ascii-th_1_2_0_0 - - ascii_1_7_0_0 + - ascii-th - asic - assert4hs-hspec - assert4hs-tasty @@ -689,7 +702,6 @@ dont-distribute-packages: - atom-msp430 - atomic-primops-foreign - atp - - ats-format - attoparsec-enumerator - attoparsec-iteratee - attoparsec-text-enumerator @@ -698,6 +710,7 @@ dont-distribute-packages: - aura - authoring - autodocodec-openapi3 + - autodocodec-servant-multipart - automata - autonix-deps-kf5 - avers @@ -760,6 +773,8 @@ dont-distribute-packages: - battleships - bayes-stack - bbi + - bcp47 + - bcp47-orphans - bdcs - bdcs-api - beam-automigrate @@ -770,6 +785,7 @@ dont-distribute-packages: - bein - belka - bff + - bglib - bidirectionalization-combined - bifunctor - billboard-parser @@ -798,6 +814,7 @@ dont-distribute-packages: - bip32 - birch-beer - bird + - bisc - biscuit-servant - bit-array - bitcoin-address @@ -820,6 +837,8 @@ dont-distribute-packages: - ble - blink1 - blip + - blockfrost-client + - blockfrost-client-core - blogination - bloodhound-amazonka-auth - bloxorz @@ -836,6 +855,7 @@ dont-distribute-packages: - bookhound-format - bookkeeper - bookkeeper-permissions + - bookkeeping-jp - boomslang - boots-app - boots-cloud @@ -868,12 +888,16 @@ dont-distribute-packages: - bv-sized - bv-sized-lens - bytable + - bytehash + - bytelog + - bytepatch - bytestring-builder-varword - bytestring-read - ca - cabal-bounds - cabal-cache - cabal-cargs + - cabal-flatpak - cabal-query - cabal-test - cabal2arch @@ -884,6 +908,7 @@ dont-distribute-packages: - cakyrespa - cal3d-examples - cal3d-opengl + - calamity - calc - calculator - caldims @@ -942,8 +967,12 @@ dont-distribute-packages: - chapelure - charade - chart-cli + - chart-svg - chart-svg-various - chart-unit + - chassis + - cheapskate-highlight + - cheapskate-lucid - cheapskate-terminal - check-pvp - chevalier-common @@ -981,13 +1010,21 @@ dont-distribute-packages: - clashilator - classify-frog - classy-miso + - clckwrks + - clckwrks-cli - clckwrks-dot-com - clckwrks-plugin-ircbot + - clckwrks-plugin-media + - clckwrks-plugin-page + - clckwrks-plugin-redirect + - clckwrks-theme-bootstrap + - cleff-plugin - cless - cleveland - click-clack - clickhouse-haskell - clifford + - climb - clippings - cloud-haskell - cloud-seeder @@ -1001,6 +1038,8 @@ dont-distribute-packages: - cmv - cnc-spec-compiler - co-feldspar + - co-log + - co-log-polysemy-formatting - cobot-io - codec - codec-libevent @@ -1009,6 +1048,7 @@ dont-distribute-packages: - coformat - cognimeta-utils - coinbase-exchange + - coincident-root-loci - colada - collapse-duplication - collection-json @@ -1031,7 +1071,24 @@ dont-distribute-packages: - compdata-automata - compdata-dags - compdata-param + - compdoc + - compdoc-dhall-decoder - complexity + - composite-aeson + - composite-aeson-cofree-list + - composite-aeson-throw + - composite-aeson-writeonly + - composite-binary + - composite-dhall + - composite-ekg + - composite-hashable + - composite-ix + - composite-lens-extra + - composite-opaleye + - composite-swagger + - composite-tuple + - composite-xml + - composite-xstep - comprehensions-ghc - compstrat - comptrans @@ -1047,10 +1104,14 @@ dont-distribute-packages: - conduit-throttle - conduit-vfs-zip - confcrypt + - conferer-aeson + - conferer-hedis - conferer-provider-dhall - conferer-provider-yaml - conferer-source-dhall - conferer-source-yaml + - conferer-warp + - conferer-yaml - conffmt - config-select - configifier @@ -1086,6 +1147,8 @@ dont-distribute-packages: - coroutine-iteratee - couch-simple - couchdb-enumerator + - country + - country_0_2_4_0 - cpkg - cprng-aes-effect - cql-io-tinylog @@ -1096,7 +1159,6 @@ dont-distribute-packages: - cqrs-test - cqrs-testkit - crackNum - - crackNum_3_4 - craft - craftwerk-cairo - craftwerk-gtk @@ -1108,7 +1170,6 @@ dont-distribute-packages: - crf-chain2-generic - crf-chain2-tiers - criu-rpc - - crockford - cron-compat - crypto-classical - crypto-conduit @@ -1118,10 +1179,7 @@ dont-distribute-packages: - cryptoids - cryptoids-class - cryptol - - crypton-connection - - crypton-x509-store - - crypton-x509-system - - crypton-x509-validation + - cryptonite-cd - crystalfontz - csound-catalog - csound-controllers @@ -1202,6 +1260,8 @@ dont-distribute-packages: - delimiter-separated - delta - delta-h + - dep-t-advice + - dependent-literals - dependent-literals-plugin - dependent-state - depends @@ -1220,7 +1280,6 @@ dont-distribute-packages: - dia-functions - diagrams-haddock - diagrams-html5 - - diagrams-input - diagrams-pandoc - diagrams-reflex - diagrams-wx @@ -1266,6 +1325,7 @@ dont-distribute-packages: - distribution-plot - dixi - dl-fedora + - dl-fedora_0_9_5_1 - dmenu-pkill - dmenu-pmount - dmenu-search @@ -1309,6 +1369,7 @@ dont-distribute-packages: - ec2-unikernel - eccrypto-ed25519-bindings - ecdsa + - ecta - edenskel - edentv - edge @@ -1325,15 +1386,18 @@ dont-distribute-packages: - ekg - ekg-carbon - ekg-cloudwatch + - ekg-prometheus-adapter - ekg-wai - elasticsearch-interchange - electrs-client - elerea-examples - elliptic-curve - elsa + - ema-extra - emacs-keys - email - emailparse + - emanote - embroidery - emd - engine-io-growler @@ -1356,6 +1420,7 @@ dont-distribute-packages: - errors-ext - ersatz-toysat - esotericbot + - esqueleto-streaming - essence-of-live-coding-PortMidi - essence-of-live-coding-gloss - essence-of-live-coding-gloss-example @@ -1420,6 +1485,7 @@ dont-distribute-packages: - fair - fallingblocks - family-tree + - fast-arithmetic - fast-bech32 - fastcdc - fastcgi @@ -1456,12 +1522,14 @@ dont-distribute-packages: - fei-nn - feldspar-compiler - festung + - fficxx - ffmpeg-tutorials - ficketed - filepath-crypto - filepath-io-access - filesystem-abstractions - filesystem-enumerator + - fin-int - find-clumpiness - findhttp - finitary @@ -1491,8 +1559,8 @@ dont-distribute-packages: - fluent-logger-conduit - fmt-for-rio - foldable1 + - foldl-transduce-attoparsec - follower - - fontconfig-pure - foo - format - format-status @@ -1509,7 +1577,6 @@ dont-distribute-packages: - fpnla-examples - frame-markdown - freckle-app - - freckle-app_1_9_0_3 - free-functors - free-game - free-theorems-counterexamples @@ -1532,6 +1599,8 @@ dont-distribute-packages: - ftshell - funbot - funbot-git-hook + - funcons-simple + - funcons-tools - function-combine - functor - functor-combo @@ -1547,6 +1616,7 @@ dont-distribute-packages: - g2q - gact - galois-fft + - gargoyle-postgresql - gargoyle-postgresql-connect - gbu - gdax @@ -1577,6 +1647,7 @@ dont-distribute-packages: - geolite-csv - getemx - gf + - ghc-dump-util - ghc-imported-from - ghc-instances - ghc-mod @@ -1616,11 +1687,14 @@ dont-distribute-packages: - glazier-react - glazier-react-examples - glazier-react-widget + - glirc - global - global-config - glome-hs - gloss-accelerate - gloss-devil + - gloss-examples + - gloss-raster - gloss-raster-accelerate - gloss-sodium - gltf-loader @@ -1853,6 +1927,8 @@ dont-distribute-packages: - graphtype - greencard-lib - grenade + - greskell + - greskell-websocket - gridbounds - gridland - grisette @@ -1870,6 +1946,7 @@ dont-distribute-packages: - grpc-haskell-core - gruff - gruff-examples + - gsc-weighting - gscholar-rss - gsl-random-fu - gsmenu @@ -1885,7 +1962,9 @@ dont-distribute-packages: - gtkimageview - gtkrsync - guarded-rewriting + - hArduino - hOff-display + - hOpenPGP - hPDB - hPDB-examples - habit @@ -1913,6 +1992,7 @@ dont-distribute-packages: - haddock - haddock_2_23_1 - haddocset + - hadolint - hadoop-tools - haggis - hailgun-send @@ -1922,6 +2002,7 @@ dont-distribute-packages: - hakyll-ogmarkup - hakyll-shortcut-links - halberd + - halide-JuicyPixels - halide-arrayfire - hall-symbols - halma-gui @@ -1934,6 +2015,7 @@ dont-distribute-packages: - happs-hsp-template - happs-tutorial - happstack-auth + - happstack-authenticate - happstack-contrib - happstack-data - happstack-dlg @@ -1941,6 +2023,7 @@ dont-distribute-packages: - happstack-fastcgi - happstack-fay - happstack-fay-ajax + - happstack-foundation - happstack-helpers - happstack-ixset - happstack-plugins @@ -1959,6 +2042,7 @@ dont-distribute-packages: - hascat-setup - hascat-system - hashable-accelerate + - hasherize - hashflare - hask-home - haskdeep @@ -2063,7 +2147,6 @@ dont-distribute-packages: - hback - hbayes - hbb - - hbcd - hbf - hbro - hbro-contrib @@ -2112,6 +2195,7 @@ dont-distribute-packages: - hesh - hesql - heterolist + - hetzner - hevolisa - hevolisa-dph - hexpat-conduit @@ -2120,11 +2204,15 @@ dont-distribute-packages: - hfiar - hfractal - hgalib + - hgdal - hgen + - hgeometry + - hgeometry-combinatorial - hgeometry-svg - hgithub - hiccup - hie-core + - hierarchical-clustering-diagrams - hierarchical-env - hierarchical-spectral-clustering - highjson-swagger @@ -2135,6 +2223,7 @@ dont-distribute-packages: - hinduce-examples - hinvaders - hinze-streams + - hip - hipbot - hipsql-client - hipsql-server @@ -2156,6 +2245,7 @@ dont-distribute-packages: - hls-exactprint-utils - hmark - hmatrix-backprop + - hmatrix-repa - hmatrix-sundials - hmeap - hmeap-utils @@ -2188,6 +2278,7 @@ dont-distribute-packages: - horizon-gen-nix - horizon-spec-lens - horizon-spec-pretty + - horizontal-rule - hotswap - hp2any-graph - hp2any-manager @@ -2242,14 +2333,10 @@ dont-distribute-packages: - hscassandra - hscope - hsdev + - hsendxmpp - hsfacter - hsinspect-lsp - hslogstash - - hslua-cli - - hslua-module-zip - - hslua-objectorientation_2_3_0 - - hslua-packaging_2_3_0 - - hslua_2_3_0 - hspec-expectations-pretty - hspec-pg-transact - hspec-setup @@ -2272,11 +2359,13 @@ dont-distribute-packages: - hsyslog-tcp - htar - html-kure + - html-parse-util - htoml-parse - htsn-import - http-client-auth - http-client-rustls - http-client-tls_0_3_6_2 + - http-conduit_2_3_8_3 - http-enumerator - http2-client-grpc - http2-grpc-proto-lens @@ -2333,8 +2422,11 @@ dont-distribute-packages: - ideas-math - ideas-math-types - ideas-statistics + - identicon-style-squares + - idris - ige-mac-integration - igrf + - ihaskell-inline-r - ihaskell-rlangqq - ihttp - imap @@ -2362,9 +2454,9 @@ dont-distribute-packages: - inferno-core - inferno-lsp - inferno-vc - - infernu - infinity - inline-java + - inliterate - inspector-wrecker - instant-aeson - instant-bytes @@ -2418,8 +2510,14 @@ dont-distribute-packages: - ivory-stdlib - ivy-web - ix + - ixset + - ixset-typed-binary-instance + - ixset-typed-cassava + - ixset-typed-conversions + - ixset-typed-hashable-instance - iyql - j2hs + - jackpolynomials - java-bridge - java-bridge-extras - java-character @@ -2430,9 +2528,13 @@ dont-distribute-packages: - jespresso - jmacro-rpc-happstack - jmacro-rpc-snap + - jobs-ui - join - jordan-openapi + - jordan-servant + - jordan-servant-client - jordan-servant-openapi + - jordan-servant-server - jot - jsaddle-hello - jsc @@ -2446,10 +2548,13 @@ dont-distribute-packages: - json-pointer-hasql - json-query - json-rpc-client + - json-spec + - json-spec-openapi - json-togo - json-tokens - json2-hdbc - json2sg + - jsonrpc-conduit - jsons-to-schema - jspath - jvm @@ -2511,15 +2616,18 @@ dont-distribute-packages: - kubernetes-client - kure-your-boilerplate - kurita + - kvitable - laborantin-hs - labsat - labyrinth - labyrinth-server + - lackey - laika - lambda-devs - lambda-options - lambdaFeed - lambdaLit + - lambdabot-telegram-plugins - lambdabot-zulip - lambdacat - lambdacms-media @@ -2547,6 +2655,7 @@ dont-distribute-packages: - lapack - lapack-hmatrix - large-anon + - large-records - lat - latex-formulae-hakyll - latex-formulae-pandoc @@ -2571,7 +2680,6 @@ dont-distribute-packages: - leksah - leksah-server - lens-accelerate - - lens-toml-parser - lens-utils - levmar-chart - lex-applicative @@ -2581,6 +2689,7 @@ dont-distribute-packages: - lhe - libconfig - libcspm + - libgraph - liblastfm - liblawless - liblinear-enumerator @@ -2611,7 +2720,6 @@ dont-distribute-packages: - liquid-base - liquid-bytestring - liquid-containers - - liquid-fixpoint - liquid-ghc-prim - liquid-parallel - liquid-platform @@ -2670,10 +2778,10 @@ dont-distribute-packages: - lrucaching-haxl - ls-usb - lsystem + - ltext - luachunk - lucid-colonnade - lucienne - - luhn - lui - luminance-samples - lvish @@ -2725,6 +2833,8 @@ dont-distribute-packages: - marvin - masakazu-bot - matchers + - math-programming-glpk + - math-programming-tests - mathblog - mathlink - matsuri @@ -2739,6 +2849,7 @@ dont-distribute-packages: - mellon-web - memcache-conduit - memis + - memory-cd - memory-hexstring - merkle-patricia-db - meta-par-accelerate @@ -2757,6 +2868,7 @@ dont-distribute-packages: - minimung - minioperational - minirotate + - mismi-kernel - miss - miss-porcelain - missing-py2 @@ -2787,6 +2899,7 @@ dont-distribute-packages: - mongrel2-handler - monky - monoidmap + - monomer-hagrid - monte-carlo - moo - moonshine @@ -2924,6 +3037,7 @@ dont-distribute-packages: - nomyx-language - nomyx-library - nomyx-server + - nonlinear-optimization-ad - nonlinear-optimization-backprop - notmuch-web - now-haskell @@ -2935,6 +3049,7 @@ dont-distribute-packages: - nri-redis - nri-test-encoding - numerals-base + - numeric-kinds - numeric-ode - numeric-optimization-backprop - numerical @@ -2951,7 +3066,9 @@ dont-distribute-packages: - oberon0 - obj - objectid + - objective - ochan + - ochintin-daicho - octane - octohat - octopus @@ -2981,6 +3098,12 @@ dont-distribute-packages: - openssh-github-keys - opentelemetry-lightstep - opentok + - opentracing-http-client + - opentracing-jaeger + - opentracing-wai + - opentracing-zipkin-common + - opentracing-zipkin-v1 + - opentracing-zipkin-v2 - oplang - optima-for-hasql - optimal-blocks @@ -2997,7 +3120,6 @@ dont-distribute-packages: - padKONTROL - pairing - panda - - pandoc-crossref_0_3_16_0 - pandoc-highlighting-extensions - pandoc-japanese-filters - pandora-io @@ -3022,6 +3144,7 @@ dont-distribute-packages: - parsley-garnish - passman-cli - patch-image + - path-text-utf8_0_0_2_0 - patterns - pcap-enumerator - pcapng @@ -3037,6 +3160,7 @@ dont-distribute-packages: - penny-lib - penrose - peparser + - perceptual-hash - perdure - perf-analysis - perfecthash @@ -3060,6 +3184,7 @@ dont-distribute-packages: - peyotls - peyotls-codec - pg-entity + - phatsort - phladiprelio-general-shared - phladiprelio-general-simple - phladiprelio-ukrainian-shared @@ -3104,6 +3229,7 @@ dont-distribute-packages: - pipes-p2p-examples - pisigma - pitchtrack + - piyo - pkgtreediff - planet-mitchell - playlists-http @@ -3124,15 +3250,20 @@ dont-distribute-packages: - polysemy-account-api - polysemy-conc - polysemy-db + - polysemy-extra + - polysemy-fskvstore - polysemy-hasql - polysemy-hasql-test - polysemy-http - polysemy-log - polysemy-log-co - polysemy-log-di + - polysemy-methodology - polysemy-methodology-composite + - polysemy-optics - polysemy-process - polysemy-scoped-fs + - polysemy-uncontrolled - polyseq - polytypeable-utils - pomodoro @@ -3152,6 +3283,7 @@ dont-distribute-packages: - postgresql-tx-query - postgresql-tx-squeal - postgresql-tx-squeal-compat-simple + - postgrest - postmark - potoki - potoki-cereal @@ -3167,6 +3299,7 @@ dont-distribute-packages: - prefork - prelate - presto-hdbc + - pretty-diff - prettychart - preview - primal-memory @@ -3187,11 +3320,15 @@ dont-distribute-packages: - prolog-graph-lib - prologue - prolude + - prometheus-wai-middleware - proof-assistant-bot - propane - proplang - prosidyc - proto-lens-descriptors + - proto-lens-protobuf-types + - proto-lens-protoc + - proto-lens-setup - proto3-suite - proto3-wire - protobuf-native @@ -3210,9 +3347,12 @@ dont-distribute-packages: - puppetresources - pure-cdb - pure-priority-queue-tests + - purenix + - purescript - purescript-iso - pursuit-client - push-notify + - push-notify-apn - push-notify-ccs - push-notify-general - puzzle-draw-cmdline @@ -3234,7 +3374,6 @@ dont-distribute-packages: - queryparser-presto - queryparser-vertica - queuelike - - quic - quickbench - quickcheck-poly - quickcheck-regex @@ -3263,6 +3402,7 @@ dont-distribute-packages: - quiver-interleave - quiver-sort - qux + - rabocsv2qif - rail-compiler-editor - rails-session - rainbow-tests @@ -3314,8 +3454,10 @@ dont-distribute-packages: - records-th - recursion-schemes-ix - redHandlers + - redact - reddit - redis-io + - redis-resp - rediscaching-haxl - reduce-equations - refh @@ -3345,14 +3487,10 @@ dont-distribute-packages: - regions-monadstf - regions-mtl - registry-aeson - - registry-aeson_0_3_0_0 - registry-hedgehog - registry-hedgehog-aeson - - registry-hedgehog-aeson_0_3_0_0 - - registry-hedgehog_0_8_0_0 - registry-messagepack - registry-options - - registry-options_0_2_0_0 - regular-extras - regular-web - regular-xmlpickler @@ -3369,15 +3507,20 @@ dont-distribute-packages: - remote-json-client - remote-json-server - remotion + - repa-algorithms - repa-array - repa-convert + - repa-fftw - repa-flow + - repa-io - repa-plugin + - repa-sndfile - repa-stream - repa-v4l2 - replicant - repr - representable-tries + - req_3_13_1 - reserve - resin - resistor-cube @@ -3507,12 +3650,15 @@ dont-distribute-packages: - scope - scope-cairo - scotty-fay + - scotty-form - scotty-hastache - scotty-haxl - scp-streams - scrabble-bot - scrapbook - scroll + - scubature + - sdl2-sprite - sdp-binary - sdp-deepseq - sdp-hashable @@ -3527,6 +3673,8 @@ dont-distribute-packages: - secrm - sednaDBXML - seitz-symbol + - selda-json + - selda-sqlite - selenium-server - self-extract - semantic-source @@ -3535,6 +3683,7 @@ dont-distribute-packages: - semiring-num - sensenet - sentence-jp + - sentiwordnet-parser - seqaid - seqloc - seqloc-datafiles @@ -3556,22 +3705,31 @@ dont-distribute-packages: - servant-ekg - servant-examples - servant-haxl-client + - servant-js - servant-matrix-param + - servant-multipart + - servant-multipart-client - servant-oauth2 - servant-oauth2-examples - servant-openapi3 + - servant-options + - servant-polysemy - servant-postgresql - servant-pushbullet-client - servant-queryparam-openapi3 - servant-rate-limit - servant-reason + - servant-ruby + - servant-serialization - servant-server-namedargs - servant-snap - servant-streaming-client - servant-streaming-docs - servant-streaming-server + - servant-subscriber - servant-swagger-tags - servant-to-elm + - servant-typescript - servant-util - servant-util-beam-pg - servant-waargonaut @@ -3588,6 +3746,7 @@ dont-distribute-packages: - shake-bindist - shake-minify-css - shake-pack + - shake-plus-extended - shakebook - shaker - shapefile @@ -3631,6 +3790,7 @@ dont-distribute-packages: - smallcheck-laws - smallcheck-lens - smallstring + - smarties - smartword - smash-aeson - smash-lens @@ -3675,6 +3835,7 @@ dont-distribute-packages: - snow-white - snowflake-core - snowflake-server + - snumber - sock2stream - socket-io - socketson @@ -3699,6 +3860,7 @@ dont-distribute-packages: - sphinx-cli - spice - spike + - spline3 - splines - sprinkles - sproxy @@ -3716,6 +3878,7 @@ dont-distribute-packages: - squeal-postgresql-uuid-ossp - squeeze - sr-extra + - srt-formatting - sscgi - sshd-lint - sssp @@ -3739,6 +3902,8 @@ dont-distribute-packages: - static-closure - statsd-client - statsdi + - stdcxx + - steeloverseer - stern-brocot - stm-actor - stm-supply @@ -3749,6 +3914,7 @@ dont-distribute-packages: - stratux-demo - stratux-http - stratux-websockets + - streaming-base64 - streaming-fft - streaming-process - strelka @@ -3767,8 +3933,6 @@ dont-distribute-packages: - structured-mongoDB - stunts - stutter - - stylist - - stylist-traits - subhask - substring-parser - sugar-data @@ -3794,7 +3958,6 @@ dont-distribute-packages: - sydtest-webdriver-yesod - sydtest-yesod - sylvia - - sym-plot - symantic-atom - symantic-http-demo - symantic-http-test @@ -3811,6 +3974,7 @@ dont-distribute-packages: - syntaxnet-haskell - synthesizer-llvm - sys-process + - systemd-api - systemstats - t3-client - ta @@ -3833,20 +3997,30 @@ dont-distribute-packages: - tasty-bdd - tasty-checklist - tasty-groundhog-converters + - tasty-hspec_1_2_0_4 - tasty-integrate - tasty-jenkins-xml - tasty-laws - tasty-lens + - tasty-sugar - tateti-tateti - tbox - tcache-AWS - tccli - techlab - telegram-bot + - telegram-bot-api + - telegram-bot-simple - telegram-raw-api - temporal-csound - ten-lens - ten-unordered-containers + - tensorflow + - tensorflow-core-ops + - tensorflow-logging + - tensorflow-opgen + - tensorflow-ops + - tensorflow-proto - terminal-text - terrahs - test-sandbox-compose @@ -3888,7 +4062,7 @@ dont-distribute-packages: - tlex-encoding - tlex-th - tls-extra - - tls_1_7_0 + - tmpl - tn - to-string-instances - toboggan @@ -3942,6 +4116,7 @@ dont-distribute-packages: - tuple-append-instances - tuple-ops - turingMachine + - twee - tweet-hs - twentefp-eventloop-graphics - twentefp-eventloop-trees @@ -3970,6 +4145,7 @@ dont-distribute-packages: - typed-streams - typedflow - typelevel + - typesafe-precure - typescript-docs - typson-beam - typson-esqueleto @@ -3991,16 +4167,19 @@ dont-distribute-packages: - uni-reactor - uni-uDrawGraph - unicode-normalization + - unicoder - uniform-http - uniform-io - uniform-latex2pdf - uniform-pandoc - uniform-shake + - uniform-watch - uniqueness-periods - uniqueness-periods-vector-examples - uniqueness-periods-vector-filters - uniqueness-periods-vector-general - uniqueness-periods-vector-properties + - unitym-servant - universal - universe - universe-dependent-sum @@ -4043,6 +4222,8 @@ dont-distribute-packages: - vacuum-opengl - vacuum-ubigraph - valid + - variable-media-field-dhall + - variable-media-field-optics - variable-precision - vault-tool-server - vault-trans @@ -4083,6 +4264,7 @@ dont-distribute-packages: - wai-devel - wai-dispatch - wai-frontend-monadcgi + - wai-handler-hal - wai-handler-snap - wai-hastache - wai-log @@ -4104,7 +4286,6 @@ dont-distribute-packages: - waldo - warp-grpc - warp-quic - - warp_3_3_27 - warped - wavesurfer - wavy @@ -4125,6 +4306,7 @@ dont-distribute-packages: - webcrank-wai - webdriver-w3c - webgear-openapi + - webgear-server - webify - webserver - websockets-rpc @@ -4141,6 +4323,10 @@ dont-distribute-packages: - whitespace - wholepixels - wikipedia4epub + - wild-bind-indicator + - wild-bind-task-x11 + - wild-bind-x11 + - winery - winio - wire-streams - wl-pprint-ansiterm @@ -4176,10 +4362,10 @@ dont-distribute-packages: - wxturtle - wyvern - xdcc + - xdg-basedir-compliant - xhb-atom-cache - xhb-ewmh - xml-catalog - - xml-conduit-stylist - xml-enumerator - xml-enumerator-combinators - xml-isogen @@ -4214,12 +4400,14 @@ dont-distribute-packages: - yam-web - yaml-rpc-scotty - yaml-rpc-snap + - yaml-streamly - yarr-image-io - yasi - yavie - ycextra - yeamer - yeshql + - yesod-alerts - yesod-articles - yesod-auth-ldap - yesod-colonnade diff --git a/pkgs/development/haskell-modules/configuration-nix.nix b/pkgs/development/haskell-modules/configuration-nix.nix index e4c8d00167fe..6b8e254c3af9 100644 --- a/pkgs/development/haskell-modules/configuration-nix.nix +++ b/pkgs/development/haskell-modules/configuration-nix.nix @@ -93,6 +93,13 @@ self: super: builtins.intersectAttrs super { doCheck = false; }) super.ghcide; + # Test suite needs executable + agda2lagda = overrideCabal (drv: { + preCheck = '' + export PATH="$PWD/dist/build/agda2lagda:$PATH" + '' + drv.preCheck or ""; + }) super.agda2lagda; + hiedb = overrideCabal (drv: { preCheck = '' export PATH=$PWD/dist/build/hiedb:$PATH @@ -117,6 +124,7 @@ self: super: builtins.intersectAttrs super { hls-floskell-plugin hls-fourmolu-plugin hls-cabal-plugin + hls-overloaded-record-dot-plugin ; # PLUGINS WITH DISABLED TESTS @@ -293,6 +301,7 @@ self: super: builtins.intersectAttrs super { niv = enableSeparateBinOutput (self.generateOptparseApplicativeCompletions [ "niv" ] super.niv); ghcid = enableSeparateBinOutput super.ghcid; ormolu = self.generateOptparseApplicativeCompletions [ "ormolu" ] (enableSeparateBinOutput super.ormolu); + hnix = self.generateOptparseApplicativeCompletions [ "hnix" ] super.hnix; # Generate shell completion. cabal2nix = self.generateOptparseApplicativeCompletions [ "cabal2nix" ] super.cabal2nix; @@ -322,24 +331,26 @@ self: super: builtins.intersectAttrs super { gio = lib.pipe super.gio [ (disableHardening ["fortify"]) (addBuildTool self.buildHaskellPackages.gtk2hs-buildtools) - (addPkgconfigDepends (with pkgs; [ glib pcre2 pcre ] - ++ lib.optionals pkgs.stdenv.isLinux [ util-linux libselinux libsepol ])) ]; glib = disableHardening ["fortify"] (addPkgconfigDepend pkgs.glib (addBuildTool self.buildHaskellPackages.gtk2hs-buildtools super.glib)); gtk3 = disableHardening ["fortify"] (super.gtk3.override { inherit (pkgs) gtk3; }); gtk = lib.pipe super.gtk ( [ (disableHardening ["fortify"]) (addBuildTool self.buildHaskellPackages.gtk2hs-buildtools) - (addPkgconfigDepends (with pkgs; [ gtk2 pcre2 pcre fribidi - libthai libdatrie xorg.libXdmcp libdeflate - ] - ++ lib.optionals pkgs.stdenv.isLinux [ util-linux libselinux libsepol ])) ] ++ ( if pkgs.stdenv.isDarwin then [(appendConfigureFlag "-fhave-quartz-gtk")] else [] ) ); gtksourceview2 = addPkgconfigDepend pkgs.gtk2 super.gtksourceview2; gtk-traymanager = addPkgconfigDepend pkgs.gtk3 super.gtk-traymanager; + shelly = overrideCabal (drv: { + # /usr/bin/env is unavailable in the sandbox + preCheck = drv.preCheck or "" + '' + chmod +x ./test/data/*.sh + patchShebangs --build test/data + ''; + }) super.shelly; + # Add necessary reference to gtk3 package gi-dbusmenugtk3 = addPkgconfigDepend pkgs.gtk3 super.gi-dbusmenugtk3; @@ -657,6 +668,9 @@ self: super: builtins.intersectAttrs super { # Break infinite recursion cycle between QuickCheck and splitmix. splitmix = dontCheck super.splitmix; + # Break infinite recursion cycle with OneTuple and quickcheck-instances. + foldable1-classes-compat = dontCheck super.foldable1-classes-compat; + # Break infinite recursion cycle between tasty and clock. clock = dontCheck super.clock; @@ -1070,8 +1084,7 @@ self: super: builtins.intersectAttrs super { ''; }) (lib.pipe (super.cachix.override { - fsnotify = dontCheck super.fsnotify_0_4_1_0; - hnix-store-core = super.hnix-store-core_0_6_1_0; + hnix-store-core = self.hnix-store-core_0_6_1_0; nix = self.hercules-ci-cnix-store.nixPackage; }) [ @@ -1083,9 +1096,15 @@ self: super: builtins.intersectAttrs super { hercules-ci-agent = super.hercules-ci-agent.override { nix = self.hercules-ci-cnix-store.passthru.nixPackage; }; hercules-ci-cnix-expr = addTestToolDepend pkgs.git (super.hercules-ci-cnix-expr.override { nix = self.hercules-ci-cnix-store.passthru.nixPackage; }); - hercules-ci-cnix-store = (super.hercules-ci-cnix-store.override { nix = self.hercules-ci-cnix-store.passthru.nixPackage; }).overrideAttrs (_: { - passthru.nixPackage = pkgs.nixVersions.nix_2_14; - }); + hercules-ci-cnix-store = overrideCabal + (old: { + passthru = old.passthru or { } // { + nixPackage = pkgs.nixVersions.nix_2_16; + }; + }) + (super.hercules-ci-cnix-store.override { + nix = self.hercules-ci-cnix-store.passthru.nixPackage; + }); # the testsuite fails because of not finding tsc without some help aeson-typescript = overrideCabal (drv: { @@ -1296,8 +1315,18 @@ self: super: builtins.intersectAttrs super { scalendar = dontCheck super.scalendar; halide-haskell = super.halide-haskell.override { Halide = pkgs.halide; }; - # Sydtest has a brittle test suite that will only work with the exact + # Sydtest has a brittle test suite that will only work with the exact # versions that it ships with. sydtest = dontCheck super.sydtest; + + # Prevent argv limit being exceeded when invoking $CC. + inherit (lib.mapAttrs (_: overrideCabal { + __onlyPropagateKnownPkgConfigModules = true; + }) super) + gi-javascriptcore + webkit2gtk3-javascriptcore + gi-webkit2 + gi-webkit2webextension + ; } diff --git a/pkgs/development/haskell-modules/generic-builder.nix b/pkgs/development/haskell-modules/generic-builder.nix index 382f6715dc9f..7001e4220bae 100644 --- a/pkgs/development/haskell-modules/generic-builder.nix +++ b/pkgs/development/haskell-modules/generic-builder.nix @@ -33,8 +33,7 @@ in , doHaddockQuickjump ? doHoogle && lib.versionAtLeast ghc.version "8.6" , doInstallIntermediates ? false , editedCabalFile ? null -# aarch64 outputs otherwise exceed 2GB limit -, enableLibraryProfiling ? !(ghc.isGhcjs or stdenv.hostPlatform.isAarch64 or false) +, enableLibraryProfiling ? !(ghc.isGhcjs or false) , enableExecutableProfiling ? false , profilingDetail ? "exported-functions" # TODO enable shared libs for cross-compiling @@ -99,6 +98,22 @@ in # build products from that prior build as a starting point for accelerating # this build , previousIntermediates ? null +, # Cabal 3.8 which is shipped by default for GHC >= 9.3 always calls + # `pkg-config --libs --static` as part of the configure step. This requires + # Requires.private dependencies of pkg-config dependencies to be present in + # PKG_CONFIG_PATH which is normally not the case in nixpkgs (except in pkgsStatic). + # Since there is no patch or upstream patch yet, we replicate the automatic + # propagation of dependencies in pkgsStatic for allPkgConfigDepends for + # GHC >= 9.3 by default. This option allows overriding this behavior manually + # if mismatching Cabal and GHC versions are used. + # See also . + __propagatePkgConfigDepends ? lib.versionAtLeast ghc.version "9.3" +, # Propagation can easily lead to the argv limit being exceeded in linker or C + # compiler invocations. To work around this we can only propagate derivations + # that are known to provide pkg-config modules, as indicated by the presence + # of `meta.pkgConfigModules`. This option defaults to false for now, since + # this metadata is far from complete in nixpkgs. + __onlyPropagateKnownPkgConfigModules ? false } @ args: assert editedCabalFile != null -> revision != null; @@ -257,8 +272,47 @@ let isHaskellPkg = x: x ? isHaskellLibrary; - allPkgconfigDepends = pkg-configDepends ++ libraryPkgconfigDepends ++ executablePkgconfigDepends ++ - optionals doCheck testPkgconfigDepends ++ optionals doBenchmark benchmarkPkgconfigDepends; + # Work around a Cabal bug requiring pkg-config --static --libs to work even + # when linking dynamically, affecting Cabal 3.8 and 3.9. + # https://github.com/haskell/cabal/issues/8455 + # + # For this, we treat the runtime system/pkg-config dependencies of a Haskell + # derivation as if they were propagated from their dependencies which allows + # pkg-config --static to work in most cases. + allPkgconfigDepends = + let + # If __onlyPropagateKnownPkgConfigModules is set, packages without + # meta.pkgConfigModules will be filtered out, otherwise all packages in + # buildInputs and propagatePlainBuildInputs are propagated. + propagateValue = drv: + lib.isDerivation drv + && (__onlyPropagateKnownPkgConfigModules -> drv ? meta.pkgConfigModules); + + # Take list of derivations and return list of the transitive dependency + # closure, only taking into account buildInputs. Loosely based on + # closePropagationFast. + propagatePlainBuildInputs = drvs: + builtins.map (i: i.val) ( + builtins.genericClosure { + startSet = builtins.map (drv: + { key = drv.outPath; val = drv; } + ) (builtins.filter propagateValue drvs); + operator = { val, ... }: + builtins.concatMap (drv: + if propagateValue drv + then [ { key = drv.outPath; val = drv; } ] + else [ ] + ) (val.buildInputs or [ ] ++ val.propagatedBuildInputs or [ ]); + } + ); + in + + if __propagatePkgConfigDepends + then propagatePlainBuildInputs allPkgconfigDepends' + else allPkgconfigDepends'; + allPkgconfigDepends' = + pkg-configDepends ++ libraryPkgconfigDepends ++ executablePkgconfigDepends ++ + optionals doCheck testPkgconfigDepends ++ optionals doBenchmark benchmarkPkgconfigDepends; depsBuildBuild = [ nativeGhc ] # CC_FOR_BUILD may be necessary if we have no C preprocessor for the host @@ -269,7 +323,7 @@ let optionals doCheck testToolDepends ++ optionals doBenchmark benchmarkToolDepends; nativeBuildInputs = - [ ghc removeReferencesTo ] ++ optional (allPkgconfigDepends != []) pkg-config ++ + [ ghc removeReferencesTo ] ++ optional (allPkgconfigDepends != []) (assert pkg-config != null; pkg-config) ++ setupHaskellDepends ++ collectedToolDepends; propagatedBuildInputs = buildDepends ++ libraryHaskellDepends ++ executableHaskellDepends ++ libraryFrameworkDepends; otherBuildInputsHaskell = @@ -318,8 +372,6 @@ let intermediatesDir = "share/haskell/${ghc.version}/${pname}-${version}/dist"; in lib.fix (drv: -assert allPkgconfigDepends != [] -> pkg-config != null; - stdenv.mkDerivation ({ inherit pname version; diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index b2ca017da498..3d7bcf49a143 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -822,8 +822,8 @@ self: { pname = "Agda"; version = "2.6.3"; sha256 = "05k0insn1c2dbpddl1slcdn972j8vgkzzy870yxl43j75j0ckb5y"; - revision = "1"; - editedCabalFile = "1l0ds84k9ia12963flzjapa67ksywhpyqz88byhykrri4llrb62c"; + revision = "3"; + editedCabalFile = "1dhwih518sm0ldwcfvbgywmgvvdskkpwmrm6gj9pxyma8hrdsfsd"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -2071,8 +2071,8 @@ self: { }: mkDerivation { pname = "Blammo"; - version = "1.1.2.0"; - sha256 = "1lp71amm5bzky8w6rw7lr551yrxhzaza0mq6ph4vb77864wnf959"; + version = "1.1.2.1"; + sha256 = "0j71glqsvzrmvj5ag32n48ib8wyyasjw0vdz2g93l2g2zhmsyz8y"; libraryHaskellDepends = [ aeson base bytestring case-insensitive clock containers dlist envparse exceptions fast-logger http-types lens monad-logger-aeson @@ -2764,66 +2764,6 @@ self: { opencv_legacy = null; opencv_ml = null; opencv_objdetect = null; opencv_video = null;}; - "Cabal_2_2_0_1" = callPackage - ({ mkDerivation, array, base, base-compat, base-orphans, binary - , bytestring, containers, deepseq, Diff, directory, filepath - , integer-logarithms, mtl, optparse-applicative, parsec, pretty - , process, QuickCheck, tagged, tar, tasty, tasty-golden - , tasty-hunit, tasty-quickcheck, text, time, transformers - , tree-diff, unix - }: - mkDerivation { - pname = "Cabal"; - version = "2.2.0.1"; - sha256 = "0yqa6fm9jvr0ka6b1mf17bf43092dc1bai6mqyiwwwyz0h9k1d82"; - setupHaskellDepends = [ mtl parsec ]; - libraryHaskellDepends = [ - array base binary bytestring containers deepseq directory filepath - mtl parsec pretty process text time transformers unix - ]; - testHaskellDepends = [ - array base base-compat base-orphans bytestring containers deepseq - Diff directory filepath integer-logarithms optparse-applicative - pretty process QuickCheck tagged tar tasty tasty-golden tasty-hunit - tasty-quickcheck text tree-diff - ]; - doCheck = false; - description = "A framework for packaging Haskell software"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - - "Cabal_2_4_1_0" = callPackage - ({ mkDerivation, array, base, base-compat, base-orphans, binary - , bytestring, containers, deepseq, Diff, directory, filepath - , integer-logarithms, mtl, optparse-applicative, parsec, pretty - , process, QuickCheck, tagged, tar, tasty, tasty-golden - , tasty-hunit, tasty-quickcheck, temporary, text, time - , transformers, tree-diff, unix - }: - mkDerivation { - pname = "Cabal"; - version = "2.4.1.0"; - sha256 = "151mrrd9sskghvlwmj32da5gafwqj6sv9xz9fmp84b7vm4nr0skk"; - revision = "2"; - editedCabalFile = "04kg5xh8yabmp1ymk32gw2r66l76338rsglq8i4j2913bhq23vwa"; - setupHaskellDepends = [ mtl parsec ]; - libraryHaskellDepends = [ - array base binary bytestring containers deepseq directory filepath - mtl parsec pretty process text time transformers unix - ]; - testHaskellDepends = [ - array base base-compat base-orphans bytestring containers deepseq - Diff directory filepath integer-logarithms optparse-applicative - pretty process QuickCheck tagged tar tasty tasty-golden tasty-hunit - tasty-quickcheck temporary text tree-diff - ]; - doCheck = false; - description = "A framework for packaging Haskell software"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "Cabal_3_2_1_0" = callPackage ({ mkDerivation, array, base, base-compat, base-orphans, binary , bytestring, containers, deepseq, Diff, directory, filepath @@ -2855,38 +2795,6 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "Cabal_3_4_1_0" = callPackage - ({ mkDerivation, array, async, base, base-compat, base-orphans - , binary, bytestring, clock, containers, deepseq, Diff, directory - , filepath, integer-logarithms, mtl, optparse-applicative, parsec - , pretty, process, QuickCheck, rere, stm, tagged, tar, tasty - , tasty-golden, tasty-hunit, tasty-quickcheck, temporary, text - , time, transformers, tree-diff, unix - }: - mkDerivation { - pname = "Cabal"; - version = "3.4.1.0"; - sha256 = "1rqpq6l4b9990rmlgcyz44awps6r37ccyi6bgk7dhcsflad6prj4"; - revision = "1"; - editedCabalFile = "1l6jf1fkfppdxy4k6y0skddg2j3j2wq3i025ak0zljc1d2blrrj8"; - setupHaskellDepends = [ mtl parsec ]; - libraryHaskellDepends = [ - array base binary bytestring containers deepseq directory filepath - mtl parsec pretty process text time transformers unix - ]; - testHaskellDepends = [ - array async base base-compat base-orphans binary bytestring clock - containers deepseq Diff directory filepath integer-logarithms - optparse-applicative pretty process QuickCheck rere stm tagged tar - tasty tasty-golden tasty-hunit tasty-quickcheck temporary text - transformers tree-diff - ]; - doCheck = false; - description = "A framework for packaging Haskell software"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "Cabal_3_6_3_0" = callPackage ({ mkDerivation, array, base, binary, bytestring, containers , deepseq, directory, filepath, mtl, parsec, pretty, process, text @@ -2907,28 +2815,6 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "Cabal_3_8_1_0" = callPackage - ({ mkDerivation, array, base, bytestring, Cabal-syntax, containers - , deepseq, directory, filepath, mtl, parsec, pretty, process, text - , time, transformers, unix - }: - mkDerivation { - pname = "Cabal"; - version = "3.8.1.0"; - sha256 = "0236fddzhalsr2gjbjsk92rgh8866fks28r04g8fbmzkqbkcnr3l"; - revision = "2"; - editedCabalFile = "179y365wh9zgzkcn4n6m4vfsfy6vk4apajv8jpys057z3a71s4kp"; - setupHaskellDepends = [ mtl parsec ]; - libraryHaskellDepends = [ - array base bytestring Cabal-syntax containers deepseq directory - filepath mtl parsec pretty process text time transformers unix - ]; - doCheck = false; - description = "A framework for packaging Haskell software"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "Cabal_3_10_1_0" = callPackage ({ mkDerivation, array, base, bytestring, Cabal-syntax, containers , deepseq, directory, filepath, mtl, parsec, pretty, process, text @@ -2975,7 +2861,7 @@ self: { broken = true; }) {}; - "Cabal-syntax" = callPackage + "Cabal-syntax_3_6_0_0" = callPackage ({ mkDerivation, Cabal }: mkDerivation { pname = "Cabal-syntax"; @@ -2985,6 +2871,7 @@ self: { doHaddock = false; description = "A library for working with .cabal files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "Cabal-syntax_3_8_1_0" = callPackage @@ -3205,8 +3092,8 @@ self: { pname = "Chart-cairo"; version = "1.9.3"; sha256 = "0clm68alzsakkn5m4h49dgx33crajacsykb4hry2fh9zxp9j743f"; - revision = "3"; - editedCabalFile = "1d48i6y0lzj066swdb3x56jipxwlx1szwn7j43d50hxmcfjrsgc9"; + revision = "4"; + editedCabalFile = "1slarc4f1803psmikq79x81cx4kwfyhwdclyjwx4ax1xbmdh0vsx"; libraryHaskellDepends = [ array base cairo Chart colour data-default-class lens mtl old-locale operational time @@ -3700,7 +3587,9 @@ self: { ]; description = "Cluster algorithms, PCA, and chemical conformere analysis"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "conclusion"; + broken = true; }) {}; "Concurrent-Cache" = callPackage @@ -5951,6 +5840,8 @@ self: { libraryHaskellDepends = [ base containers matrix vector ]; description = "Basic concepts of finite state machines"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FTGL" = callPackage @@ -6044,6 +5935,7 @@ self: { description = "A collection of facts about the real world"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FailT" = callPackage @@ -6394,6 +6286,8 @@ self: { libraryHaskellDepends = [ base ]; description = "A version of Prelude suitable for teaching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "FixedPoint-simple" = callPackage @@ -8108,6 +8002,7 @@ self: { ]; description = "The Haskell/R mixed programming environment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "H"; }) {}; @@ -9095,6 +8990,8 @@ self: { ]; description = "Heterogeneous lists"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HListPP" = callPackage @@ -9197,6 +9094,8 @@ self: { ]; description = "A flexible mock framework for testing effectful code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "HNM" = callPackage @@ -10192,6 +10091,7 @@ self: { testHaskellDepends = [ base bytestring HUnit text ]; description = "An XPath-generating embedded domain specific language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "HaXml" = callPackage @@ -10200,10 +10100,8 @@ self: { }: mkDerivation { pname = "HaXml"; - version = "1.25.12"; - sha256 = "1xaqp519dw948v00q309msx07yhzxbd0k8ds5q434l6g6cmsqqgc"; - revision = "1"; - editedCabalFile = "1bx5gw3jg6j0rppf5297grw9cv1vccvj5av1hny5i60nrj1725rc"; + version = "1.25.13"; + sha256 = "0wxkp9bnbnjrjrzsmpm6nknzn0ijiiajd5kms81kgyfypm4m91ax"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -10329,8 +10227,8 @@ self: { }: mkDerivation { pname = "HangmanAscii"; - version = "0.1.1.1"; - sha256 = "1yhpblx3q4pkngzb030va0k3ncydbc6c5d8b71llghzv5w9pj3cq"; + version = "0.1.1.3"; + sha256 = "1fvcf3wl0c3rwy4vc11dnby4dl570ij30wpwjqhc39wa64ndvdbg"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -11266,20 +11164,6 @@ self: { }) {Judy = null;}; "HsOpenSSL" = callPackage - ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }: - mkDerivation { - pname = "HsOpenSSL"; - version = "0.11.7.5"; - sha256 = "0y0l5nb0jsc8lm12w66a2n7nwcrgjxy1q2xdy8a788695az5xy71"; - setupHaskellDepends = [ base Cabal ]; - libraryHaskellDepends = [ base bytestring network time ]; - librarySystemDepends = [ openssl ]; - testHaskellDepends = [ base bytestring ]; - description = "Partial OpenSSL binding for Haskell"; - license = lib.licenses.publicDomain; - }) {inherit (pkgs) openssl;}; - - "HsOpenSSL_0_11_7_6" = callPackage ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }: mkDerivation { pname = "HsOpenSSL"; @@ -11291,7 +11175,6 @@ self: { testHaskellDepends = [ base bytestring ]; description = "Partial OpenSSL binding for Haskell"; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) openssl;}; "HsOpenSSL-x509-system" = callPackage @@ -11405,8 +11288,8 @@ self: { pname = "HsYAML"; version = "0.2.1.1"; sha256 = "0a7nbvpl4p8kwbbjfn1dj6s3fif5k8zhbckdvyz1k74pj3yb8ns6"; - revision = "2"; - editedCabalFile = "0r2yh96nhmlfy2vj2c7i5703brv4lp9cw5v044j7s8487jvv70d6"; + revision = "3"; + editedCabalFile = "0dyvkrnzdpba4lwxvqyrsjgcmi0aza7nz19xjw638qdq1xdxrwcp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -11428,8 +11311,8 @@ self: { pname = "HsYAML-aeson"; version = "0.2.0.1"; sha256 = "139hqd07hkr8ykvrgmcshh9f3vp9dnrj6ks5nl8hgrpi990jsy5r"; - revision = "6"; - editedCabalFile = "1c7v808i9wafx0z74skim7h96z7hdl4v7clawg9s1idzzwhihjcr"; + revision = "7"; + editedCabalFile = "1zriyncrkfdz21adlqy2v1wydm01j3w3jxqa2ls1psjp2p1mmv6x"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -11536,6 +11419,7 @@ self: { benchmarkHaskellDepends = [ array base criterion Munkres random ]; description = "A Linear Sum Assignment Problem (LSAP) solver"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "Hydrogen" = callPackage @@ -11678,8 +11562,8 @@ self: { }: mkDerivation { pname = "IPv6Addr"; - version = "2.0.5"; - sha256 = "14zd98kbs3z6gmw9x897x1vslv5qphfhillhwxvnpkz87wsgzsc1"; + version = "2.0.5.1"; + sha256 = "1w0chaq6nf6xbvfgfwbjw4vm695nbpsr5hqcx927i2kvxr956dp7"; libraryHaskellDepends = [ aeson attoparsec base iproute network network-info random text ]; @@ -12206,22 +12090,6 @@ self: { }) {}; "JuicyPixels" = callPackage - ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl - , primitive, transformers, vector, zlib - }: - mkDerivation { - pname = "JuicyPixels"; - version = "3.3.7"; - sha256 = "1rrvapzcj0q8sigxq1zq2k4h88i1r2hyca4p7pkqa1b4pk6vhdny"; - libraryHaskellDepends = [ - base binary bytestring containers deepseq mtl primitive - transformers vector zlib - ]; - description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)"; - license = lib.licenses.bsd3; - }) {}; - - "JuicyPixels_3_3_8" = callPackage ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl , primitive, transformers, vector, zlib }: @@ -12235,7 +12103,6 @@ self: { ]; description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tga, tiff and radiance)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "JuicyPixels-blp" = callPackage @@ -12310,25 +12177,6 @@ self: { }) {}; "JuicyPixels-extra" = callPackage - ({ mkDerivation, base, criterion, hspec, hspec-discover - , JuicyPixels - }: - mkDerivation { - pname = "JuicyPixels-extra"; - version = "0.5.2"; - sha256 = "11y4735bbp99wvi4fkpvkda7cj4c6iqp437drs27flicx2ygc687"; - revision = "1"; - editedCabalFile = "1rmqhwbkdbwa2ng5zlpfwrfnqlcxrvgy3i5ymrjiw5jl9wp6j13c"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ base JuicyPixels ]; - testHaskellDepends = [ base hspec JuicyPixels ]; - testToolDepends = [ hspec-discover ]; - benchmarkHaskellDepends = [ base criterion JuicyPixels ]; - description = "Efficiently scale, crop, flip images with JuicyPixels"; - license = lib.licenses.bsd3; - }) {}; - - "JuicyPixels-extra_0_6_0" = callPackage ({ mkDerivation, base, criterion, hspec, hspec-discover , JuicyPixels }: @@ -12343,7 +12191,6 @@ self: { benchmarkHaskellDepends = [ base criterion JuicyPixels ]; description = "Efficiently scale, crop, flip images with JuicyPixels"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "JuicyPixels-repa" = callPackage @@ -12357,6 +12204,7 @@ self: { ]; description = "Convenience functions to obtain array representations of images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "JuicyPixels-scale-dct" = callPackage @@ -13357,8 +13205,8 @@ self: { }: mkDerivation { pname = "ListLike"; - version = "4.7.8"; - sha256 = "1l9pfjy7gh7xqnzflixp37d6lsppmlffzmmq75xn9r8ij3r2jycs"; + version = "4.7.8.1"; + sha256 = "10i1ynfhafnmiw0ka9w0v05y5dcdcifsh0kx5f8py1k5ax1ha4by"; libraryHaskellDepends = [ array base bytestring containers deepseq dlist fmlist text utf8-string vector @@ -14025,8 +13873,8 @@ self: { ({ mkDerivation, base, newtype-generics }: mkDerivation { pname = "MemoTrie"; - version = "0.6.10"; - sha256 = "0lxsarhyhhkp58wpbp7b08scmjxq7s46jfl9vhp2yfq973hz0kaq"; + version = "0.6.11"; + sha256 = "08141kdn9d2md1nz0xfz5868rn4ya7li93k7f2rwdhga6vqsp9pp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base newtype-generics ]; @@ -14154,30 +14002,6 @@ self: { }) {}; "MissingH" = callPackage - ({ mkDerivation, array, base, containers, directory, filepath - , hslogger, HUnit, mtl, network, network-bsd, old-locale, old-time - , parsec, process, regex-compat, time, unix - }: - mkDerivation { - pname = "MissingH"; - version = "1.5.0.1"; - sha256 = "0c92fdv32nq51kfdizi3lpxmnvscsgk6marfzaycd7k05aka8byb"; - revision = "2"; - editedCabalFile = "11d922r06p00gcgzhb29hhjkq8ajy1xbqdiwdpbmhp2ar7fw7g9l"; - libraryHaskellDepends = [ - array base containers directory filepath hslogger mtl network - network-bsd old-locale old-time parsec process regex-compat time - unix - ]; - testHaskellDepends = [ - base containers directory filepath HUnit old-time parsec - regex-compat time unix - ]; - description = "Large utility library"; - license = lib.licenses.bsd3; - }) {}; - - "MissingH_1_6_0_0" = callPackage ({ mkDerivation, array, base, containers, directory, filepath , hslogger, HUnit, mtl, network, network-bsd, old-locale, old-time , parsec, process, regex-compat, time, unix @@ -14197,7 +14021,6 @@ self: { ]; description = "Large utility library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "MissingK" = callPackage @@ -14413,23 +14236,6 @@ self: { }) {}; "MonadRandom" = callPackage - ({ mkDerivation, base, mtl, primitive, random, transformers - , transformers-compat - }: - mkDerivation { - pname = "MonadRandom"; - version = "0.5.3"; - sha256 = "17qaw1gg42p9v6f87dj5vih7l88lddbyd8880ananj8avanls617"; - revision = "3"; - editedCabalFile = "0317qhagxgn41ql1w7isnw4jqddnw394wglqahm3c569pbr3lmdv"; - libraryHaskellDepends = [ - base mtl primitive random transformers transformers-compat - ]; - description = "Random-number generation monad"; - license = lib.licenses.bsd3; - }) {}; - - "MonadRandom_0_6" = callPackage ({ mkDerivation, base, mtl, primitive, random, transformers , transformers-compat }: @@ -14444,7 +14250,6 @@ self: { ]; description = "Random-number generation monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "MonadRandomLazy" = callPackage @@ -14552,6 +14357,31 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "Mondrian" = callPackage + ({ mkDerivation, base, bytestring, colour, css-syntax, gl + , JuicyPixels, linear, mtl, scientific, sdl2, stylist-traits, text + , typograffiti, unordered-containers, vector + }: + mkDerivation { + pname = "Mondrian"; + version = "0.1.0.0"; + sha256 = "1sb1jnnbbwvf55phn8ls538y5qmvvnq0px7l4dxxxm9wnmg69z4z"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring colour css-syntax gl JuicyPixels linear mtl + scientific stylist-traits text typograffiti unordered-containers + vector + ]; + executableHaskellDepends = [ + base css-syntax gl JuicyPixels linear sdl2 stylist-traits text + ]; + testHaskellDepends = [ base ]; + description = "Renders backgrounds & borders"; + license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + }) {}; + "Monocle" = callPackage ({ mkDerivation, base, containers, haskell98, mtl }: mkDerivation { @@ -14684,6 +14514,8 @@ self: { libraryHaskellDepends = [ array base ]; description = "Munkres' assignment algorithm (hungarian method)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Munkres-simple" = callPackage @@ -14969,6 +14801,8 @@ self: { pname = "NaCl"; version = "0.0.5.0"; sha256 = "1q6wr6a3q0w594z8lrldmvzc1fs4krds8nbady8ymz2vll71q1kz"; + revision = "1"; + editedCabalFile = "00p3brf458lwfjlzmr43hv7c8bi28bq2z1nqzwf121ljnf5vhvpb"; libraryHaskellDepends = [ base bytestring libsodium memory safe-exceptions ]; @@ -14997,27 +14831,6 @@ self: { }) {}; "NanoID" = callPackage - ({ mkDerivation, aeson, base, bytestring, cereal, extra, mwc-random - , optparse-applicative, text - }: - mkDerivation { - pname = "NanoID"; - version = "3.2.1"; - sha256 = "13917k5s17aq7h4hab3i2b6y3z3c0wq6p9x7hlindks28390i93f"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base bytestring cereal extra mwc-random text - ]; - executableHaskellDepends = [ - base bytestring mwc-random optparse-applicative - ]; - description = "NanoID generator"; - license = lib.licenses.bsd3; - mainProgram = "nanoid"; - }) {}; - - "NanoID_3_3_0" = callPackage ({ mkDerivation, aeson, base, bytestring, cereal, extra, mwc-random , optparse-applicative, text }: @@ -15037,6 +14850,7 @@ self: { license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; mainProgram = "nanoid"; + broken = true; }) {}; "NanoProlog" = callPackage @@ -15620,7 +15434,9 @@ self: { executableHaskellDepends = [ base filepath ]; description = "ONC RPC (aka Sun RPC) and XDR library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; mainProgram = "hsrpcgen"; + broken = true; }) {}; "OSM" = callPackage @@ -15810,20 +15626,6 @@ self: { }) {}; "OneTuple" = callPackage - ({ mkDerivation, base, ghc-prim, hashable, template-haskell }: - mkDerivation { - pname = "OneTuple"; - version = "0.3.1"; - sha256 = "1vry21z449ph9k61l5zm7mfmdwkwszxqdlawlhvwrd1gsn13d1cq"; - revision = "3"; - editedCabalFile = "0g4siv8s6dlrdsivap2qy6ig08y5bjbs93jk192zmgkp8iscncpw"; - libraryHaskellDepends = [ base ghc-prim template-haskell ]; - testHaskellDepends = [ base hashable template-haskell ]; - description = "Singleton Tuple"; - license = lib.licenses.bsd3; - }) {}; - - "OneTuple_0_4_1_1" = callPackage ({ mkDerivation, base, foldable1-classes-compat, ghc-prim, hashable , template-haskell }: @@ -15837,7 +15639,6 @@ self: { ]; description = "Singleton Tuple"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "Only" = callPackage @@ -17803,6 +17604,7 @@ self: { description = "A puzzle game written in Haskell with a cat in lead role"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; mainProgram = "raincat"; }) {}; @@ -19146,38 +18948,6 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "ShellCheck_0_8_0" = callPackage - ({ mkDerivation, aeson, array, base, bytestring, containers - , deepseq, Diff, directory, filepath, mtl, parsec, process - , QuickCheck, regex-tdfa - }: - mkDerivation { - pname = "ShellCheck"; - version = "0.8.0"; - sha256 = "05jlapp4m997w36h2wszdxz9gvczdczaylypsbn14jqpb650w232"; - revision = "1"; - editedCabalFile = "1c942n7lz59b0acvppg25k01f87rj3icrza9pfp9mlpiwaq1y8qw"; - 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; - mainProgram = "shellcheck"; - maintainers = [ lib.maintainers.zowoq ]; - }) {}; - "ShellCheck" = callPackage ({ mkDerivation, aeson, array, base, bytestring, containers , deepseq, Diff, directory, fgl, filepath, mtl, parsec, process @@ -19816,6 +19586,8 @@ self: { libraryHaskellDepends = [ base matrix vector ]; description = "A lightweight Haskell implementation of Smith normal form over the integers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Smooth" = callPackage @@ -19994,7 +19766,9 @@ self: { ]; description = "Video game"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "spaceInvaders"; + broken = true; }) {}; "SpacePrivateers" = callPackage @@ -20043,6 +19817,8 @@ self: { ]; description = "Random text generation based on spintax"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Spock" = callPackage @@ -20647,7 +20423,9 @@ self: { ]; description = "Testing in monads and transformers without explicit specs"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "TLT-exe"; + broken = true; }) {}; "TORCS" = callPackage @@ -20991,6 +20769,8 @@ self: { ]; description = "Generates testcases from program-snippets"; license = lib.licenses.lgpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "Theora" = callPackage @@ -21913,13 +21693,15 @@ self: { }) {}; "VulkanMemoryAllocator" = callPackage - ({ mkDerivation, base, bytestring, transformers, vector, vulkan }: + ({ mkDerivation, base, bytestring, system-cxx-std-lib, transformers + , vector, vulkan + }: mkDerivation { pname = "VulkanMemoryAllocator"; version = "0.10.5"; sha256 = "1brqn6zx4ynljc424dpwrxj5fjmvl0mgp7wycnzpfxpfmwwqib4a"; libraryHaskellDepends = [ - base bytestring transformers vector vulkan + base bytestring system-cxx-std-lib transformers vector vulkan ]; description = "Bindings to the VulkanMemoryAllocator library"; license = lib.licenses.bsd3; @@ -22288,17 +22070,6 @@ self: { }) {}; "Win32" = callPackage - ({ mkDerivation }: - mkDerivation { - pname = "Win32"; - version = "2.12.0.1"; - sha256 = "1nivdwjp9x9i64xg8gf3xj8khm9dfq6n5m8kvvlhz7i7ypl4mv72"; - description = "A binding to Windows Win32 API"; - license = lib.licenses.bsd3; - platforms = lib.platforms.windows; - }) {}; - - "Win32_2_13_4_0" = callPackage ({ mkDerivation }: mkDerivation { pname = "Win32"; @@ -22307,7 +22078,6 @@ self: { description = "A binding to Windows Win32 API"; license = lib.licenses.bsd3; platforms = lib.platforms.windows; - hydraPlatforms = lib.platforms.none; }) {}; "Win32-console" = callPackage @@ -22980,21 +22750,6 @@ self: { }) {}; "Yampa" = callPackage - ({ mkDerivation, base, deepseq, random, simple-affine-space }: - mkDerivation { - pname = "Yampa"; - version = "0.13.7"; - sha256 = "0fz4v7q0q1npqxgjcc5ig9ynz1jya54a3vdl5p2mzymg91hwapf8"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base deepseq random simple-affine-space - ]; - description = "Elegant Functional Reactive Programming Language for Hybrid Systems"; - license = lib.licenses.bsd3; - }) {}; - - "Yampa_0_14_3" = callPackage ({ mkDerivation, base, deepseq, random, simple-affine-space }: mkDerivation { pname = "Yampa"; @@ -23007,7 +22762,6 @@ self: { ]; description = "Elegant Functional Reactive Programming Language for Hybrid Systems"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "Yampa-core" = callPackage @@ -23203,8 +22957,8 @@ self: { }: mkDerivation { pname = "Z-YAML"; - version = "0.3.4.0"; - sha256 = "1bv88kl5bn4x0mq0pciyihvml4jqsi76379wbqsgjpf285x2a92d"; + version = "0.3.5.0"; + sha256 = "0d2sfsc37fvndkk0lpq854h7r8qwdvji0vqr5a44nn0v5hyhs51q"; libraryHaskellDepends = [ base primitive scientific transformers unordered-containers Z-Data Z-IO @@ -23583,25 +23337,6 @@ self: { }) {}; "acc" = callPackage - ({ mkDerivation, base, deepseq, gauge, QuickCheck - , quickcheck-instances, rerebase, semigroupoids, tasty, tasty-hunit - , tasty-quickcheck - }: - mkDerivation { - pname = "acc"; - version = "0.2.0.1"; - sha256 = "03wk2pnh3scjf5102w882hg6hsczj9ihj8pb9g3928na2zk1jw1v"; - libraryHaskellDepends = [ base deepseq semigroupoids ]; - testHaskellDepends = [ - QuickCheck quickcheck-instances rerebase tasty tasty-hunit - tasty-quickcheck - ]; - benchmarkHaskellDepends = [ gauge rerebase ]; - description = "Sequence optimized for monoidal construction and folding"; - license = lib.licenses.mit; - }) {}; - - "acc_0_2_0_2" = callPackage ({ mkDerivation, base, criterion, deepseq, quickcheck-instances , rerebase, semigroupoids, tasty, tasty-quickcheck }: @@ -23616,7 +23351,6 @@ self: { benchmarkHaskellDepends = [ criterion rerebase ]; description = "Sequence optimized for monoidal construction and folding"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "accelerate" = callPackage @@ -24285,6 +24019,8 @@ self: { ]; description = "Attempto Controlled English parser and printer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "achille" = callPackage @@ -25041,10 +24777,8 @@ self: { ({ mkDerivation, base, transformers }: mkDerivation { pname = "acquire"; - version = "0.3.1"; - sha256 = "1spw70dw8x6d9dy5wg47fim4kpsvzgr25nmwpv8c4wd8g3gmnqmw"; - revision = "1"; - editedCabalFile = "0p78cr2qg5ciy0d98mf98ay0cbkl072j79is73j7vcmq1mwcli3c"; + version = "0.3.1.1"; + sha256 = "12bcywg52gyh5zhf2iljy1yb1g8l52v1sjbg8bffifgh0bmnzkws"; libraryHaskellDepends = [ base transformers ]; description = "Abstraction over management of resources"; license = lib.licenses.mit; @@ -25209,6 +24943,19 @@ self: { license = lib.licenses.bsd3; }) {}; + "ad-delcont_0_5_0_0" = callPackage + ({ mkDerivation, ad, base, hspec, transformers }: + mkDerivation { + pname = "ad-delcont"; + version = "0.5.0.0"; + sha256 = "19sy7hx6511w7ln9hmichbr6awdxkra1hacq87k07v63xz5il3rv"; + libraryHaskellDepends = [ base transformers ]; + testHaskellDepends = [ ad base hspec ]; + description = "Reverse-mode automatic differentiation with delimited continuations"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "adaptive-containers" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -25628,26 +25375,6 @@ self: { }) {}; "aern2-real" = callPackage - ({ mkDerivation, aern2-mp, base, collect-errors, hspec - , integer-logarithms, mixed-types-num, QuickCheck - }: - mkDerivation { - pname = "aern2-real"; - version = "0.2.11.0"; - sha256 = "094hs147jzlg3zqary2zbpi7n18vykj0f7cw89k125zrs2h0f0v2"; - libraryHaskellDepends = [ - aern2-mp base collect-errors hspec integer-logarithms - mixed-types-num QuickCheck - ]; - testHaskellDepends = [ - aern2-mp base collect-errors hspec integer-logarithms - mixed-types-num QuickCheck - ]; - description = "Real numbers as convergent sequences of intervals"; - license = lib.licenses.bsd3; - }) {}; - - "aern2-real_0_2_15" = callPackage ({ mkDerivation, aern2-mp, base, collect-errors, hspec , integer-logarithms, mixed-types-num, QuickCheck }: @@ -25665,7 +25392,6 @@ self: { ]; description = "Real numbers as convergent sequences of intervals"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "aeson_1_5_6_0" = callPackage @@ -25704,43 +25430,6 @@ self: { }) {}; "aeson" = callPackage - ({ mkDerivation, attoparsec, base, base-compat - , base-compat-batteries, base-orphans, base16-bytestring - , bytestring, containers, data-fix, deepseq, Diff, directory, dlist - , filepath, generic-deriving, ghc-prim, hashable - , indexed-traversable, integer-logarithms, OneTuple, primitive - , QuickCheck, quickcheck-instances, scientific, semialign, strict - , tagged, tasty, tasty-golden, tasty-hunit, tasty-quickcheck - , template-haskell, text, text-short, th-abstraction, these, time - , time-compat, unordered-containers, uuid-types, vector, witherable - }: - mkDerivation { - pname = "aeson"; - version = "2.0.3.0"; - sha256 = "09dk0j33n262dm75vff3y3i9fm6lh06dyqswwv7a6kvnhhmhlxhr"; - revision = "1"; - editedCabalFile = "1zrgn63jzrpk3n3vd44zkzgw7kb5qxlvhx4nk6g3sswwrsz5j32i"; - libraryHaskellDepends = [ - attoparsec base base-compat-batteries bytestring containers - data-fix deepseq dlist ghc-prim hashable indexed-traversable - OneTuple primitive QuickCheck scientific semialign strict tagged - template-haskell text text-short th-abstraction these time - time-compat unordered-containers uuid-types vector witherable - ]; - testHaskellDepends = [ - attoparsec base base-compat base-orphans base16-bytestring - bytestring containers data-fix Diff directory dlist filepath - generic-deriving ghc-prim hashable indexed-traversable - integer-logarithms OneTuple primitive QuickCheck - quickcheck-instances scientific strict tagged tasty tasty-golden - tasty-hunit tasty-quickcheck template-haskell text text-short these - time time-compat unordered-containers uuid-types vector - ]; - description = "Fast JSON parsing and encoding"; - license = lib.licenses.bsd3; - }) {}; - - "aeson_2_1_2_1" = callPackage ({ mkDerivation, attoparsec, base, base-compat , base-compat-batteries, base-orphans, base16-bytestring , bytestring, containers, data-fix, deepseq, Diff, directory, dlist @@ -25777,6 +25466,44 @@ self: { ]; description = "Fast JSON parsing and encoding"; license = lib.licenses.bsd3; + }) {}; + + "aeson_2_2_0_0" = callPackage + ({ mkDerivation, base, base-compat, base-orphans, base16-bytestring + , bytestring, containers, data-fix, deepseq, Diff, directory, dlist + , exceptions, filepath, generic-deriving, generically, ghc-prim + , hashable, indexed-traversable, integer-conversion + , integer-logarithms, network-uri, nothunks, OneTuple, primitive + , QuickCheck, quickcheck-instances, scientific, semialign, strict + , tagged, tasty, tasty-golden, tasty-hunit, tasty-quickcheck + , template-haskell, text, text-iso8601, text-short, th-abstraction + , these, time, time-compat, unordered-containers, uuid-types + , vector, witherable + }: + mkDerivation { + pname = "aeson"; + version = "2.2.0.0"; + sha256 = "0z1f65iv0sigiqmm4vwbj3bzmn0ka0m56nkalhv2h5r9jc0y4rfx"; + libraryHaskellDepends = [ + base bytestring containers data-fix deepseq dlist exceptions + generically ghc-prim hashable indexed-traversable + integer-conversion network-uri OneTuple primitive QuickCheck + scientific semialign strict tagged template-haskell text + text-iso8601 text-short th-abstraction these time time-compat + unordered-containers uuid-types vector witherable + ]; + testHaskellDepends = [ + base base-compat base-orphans base16-bytestring bytestring + containers data-fix deepseq Diff directory dlist filepath + generic-deriving generically ghc-prim hashable indexed-traversable + integer-logarithms network-uri nothunks OneTuple primitive + QuickCheck quickcheck-instances scientific strict tagged tasty + tasty-golden tasty-hunit tasty-quickcheck template-haskell text + text-short these time time-compat unordered-containers uuid-types + vector + ]; + description = "Fast JSON parsing and encoding"; + license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; }) {}; @@ -25903,6 +25630,8 @@ self: { testHaskellDepends = [ aeson aeson-qq base hspec text ]; description = "Parse Aeson data with commitment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-compat" = callPackage @@ -25931,6 +25660,8 @@ self: { ]; description = "Compatibility layer for aeson"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-decode" = callPackage @@ -25989,6 +25720,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "JSON encoding/decoding for dependent-sum"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-deriving" = callPackage @@ -26084,6 +25817,31 @@ self: { license = lib.licenses.bsd3; }) {}; + "aeson-extra_0_5_1_3" = callPackage + ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base + , base-compat-batteries, bytestring, containers, deepseq + , quickcheck-instances, recursion-schemes, scientific, semialign + , tasty, tasty-hunit, tasty-quickcheck, template-haskell, text + , these, unordered-containers, vector + }: + mkDerivation { + pname = "aeson-extra"; + version = "0.5.1.3"; + sha256 = "0w843dr9rj7mmgqsa93dxslsjakh1vsq601bfd89pjgx8ypd8bbh"; + libraryHaskellDepends = [ + aeson attoparsec attoparsec-aeson base base-compat-batteries + bytestring deepseq recursion-schemes scientific semialign + template-haskell text these unordered-containers vector + ]; + testHaskellDepends = [ + aeson base base-compat-batteries containers quickcheck-instances + tasty tasty-hunit tasty-quickcheck unordered-containers vector + ]; + description = "Extra goodies for aeson"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "aeson-filthy" = callPackage ({ mkDerivation, aeson, base, bytestring, doctest, text, time , unordered-containers @@ -26286,8 +26044,8 @@ self: { }: mkDerivation { pname = "aeson-match-qq"; - version = "1.6.1"; - sha256 = "1djcws5i9w0ky98iwlriqdm9iby3s076ykm1yxcdy04qpgp1whf7"; + version = "1.7.0"; + sha256 = "11cmqk6igrapi9ms211gbmfwkyczjrzpg900fxqypn18lj1k4y60"; libraryHaskellDepends = [ aeson attoparsec base bytestring case-insensitive containers either haskell-src-meta pretty scientific template-haskell text @@ -26338,18 +26096,16 @@ self: { }) {}; "aeson-optics" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, optics-core - , optics-extra, scientific, text, text-short, vector + ({ mkDerivation, aeson, base, bytestring, optics-core, optics-extra + , scientific, text, text-short, vector }: mkDerivation { pname = "aeson-optics"; - version = "1.2.0.1"; - sha256 = "0b7frw4fm5hn611i8ldbnkq1h47vjw4fn6f85sj38fw2cn4n826j"; - revision = "1"; - editedCabalFile = "18da6lkjlxrsg1py5nqjhgbv7ffxalsjx28an5np3bdvgzcf1klg"; + version = "1.2.1"; + sha256 = "0sbx55ns7jjwwkz49587vnkx4jirbh7xflaf0jwxxf0lq91216ja"; libraryHaskellDepends = [ - aeson attoparsec base bytestring optics-core optics-extra - scientific text text-short vector + aeson base bytestring optics-core optics-extra scientific text + text-short vector ]; description = "Law-abiding optics for aeson"; license = lib.licenses.mit; @@ -26441,6 +26197,30 @@ self: { mainProgram = "aeson-pretty"; }) {}; + "aeson-pretty_0_8_10" = callPackage + ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base + , base-compat, bytestring, cmdargs, scientific, text + , unordered-containers, vector + }: + mkDerivation { + pname = "aeson-pretty"; + version = "0.8.10"; + sha256 = "1rbsz9f6kzqq5cbq0xhyj599alb4ssg26w57xff19jxdg36z489a"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base base-compat bytestring scientific text + unordered-containers vector + ]; + executableHaskellDepends = [ + aeson attoparsec attoparsec-aeson base bytestring cmdargs + ]; + description = "JSON pretty-printing library and command-line tool"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "aeson-pretty"; + }) {}; + "aeson-qq" = callPackage ({ mkDerivation, aeson, attoparsec, base, base-compat, ghc-prim , haskell-src-meta, hspec, hspec-discover, parsec, scientific @@ -26583,6 +26363,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Conveniently wrap a single value in a record when encoding to and from JSON"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "aeson-smart" = callPackage @@ -26670,29 +26452,6 @@ self: { }) {}; "aeson-typescript" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, directory - , filepath, hspec, mtl, process, string-interpolate - , template-haskell, temporary, text, th-abstraction, transformers - , unordered-containers - }: - mkDerivation { - pname = "aeson-typescript"; - version = "0.4.2.0"; - sha256 = "00lv7mfxxnhmbxh9s1qwfnffmpy6095fh3zms68bzdkjik2hk830"; - libraryHaskellDepends = [ - aeson base containers mtl string-interpolate template-haskell text - th-abstraction transformers unordered-containers - ]; - testHaskellDepends = [ - aeson base bytestring containers directory filepath hspec mtl - process string-interpolate template-haskell temporary text - th-abstraction transformers unordered-containers - ]; - description = "Generate TypeScript definition files from your ADTs"; - license = lib.licenses.bsd3; - }) {}; - - "aeson-typescript_0_6_0_0" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, directory , filepath, hspec, mtl, process, string-interpolate , template-haskell, temporary, text, th-abstraction, transformers @@ -26713,7 +26472,6 @@ self: { ]; description = "Generate TypeScript definition files from your ADTs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "aeson-utils" = callPackage @@ -26768,6 +26526,24 @@ self: { ]; description = "Wrappers to derive-via Aeson ToJSON/FromJSON typeclasses"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + + "aeson-warning-parser" = callPackage + ({ mkDerivation, aeson, base, containers, generic-deriving, rio + , rio-prettyprint, text, transformers, unordered-containers + }: + mkDerivation { + pname = "aeson-warning-parser"; + version = "0.1.0"; + sha256 = "19n5pnvkingw086i9adhakhj42fmp7nrphf4g6gq4y1xwa1afiry"; + libraryHaskellDepends = [ + aeson base containers generic-deriving rio rio-prettyprint text + transformers unordered-containers + ]; + description = "Library providing JSON parser that warns about unexpected fields in objects"; + license = lib.licenses.bsd3; }) {}; "aeson-with" = callPackage @@ -27083,28 +26859,6 @@ self: { }) {}; "agda2lagda" = callPackage - ({ mkDerivation, base, directory, filepath, goldplate - , optparse-applicative, process - }: - mkDerivation { - pname = "agda2lagda"; - version = "0.2021.6.1"; - sha256 = "1108xzl4fv86qpasg1wbc26bypd06s41kmgzybrggc76pv15hbis"; - revision = "1"; - editedCabalFile = "0qba16r072www9544g30ahmlk8k3kiq8q18g3wn7b7sgz2jmp8mc"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - base directory filepath optparse-applicative - ]; - testHaskellDepends = [ base process ]; - testToolDepends = [ goldplate ]; - description = "Translate .agda files into .lagda.tex files."; - license = lib.licenses.publicDomain; - mainProgram = "agda2lagda"; - }) {}; - - "agda2lagda_0_2023_6_9" = callPackage ({ mkDerivation, base, directory, filepath, goldplate , optparse-applicative, process }: @@ -27121,7 +26875,6 @@ self: { testToolDepends = [ goldplate ]; description = "Translate .agda files into .lagda.tex files."; license = lib.licenses.publicDomain; - hydraPlatforms = lib.platforms.none; mainProgram = "agda2lagda"; }) {}; @@ -27639,6 +27392,8 @@ self: { libraryHaskellDepends = [ base blaze-html text ]; description = "Alert messages for web applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "alex" = callPackage @@ -27646,8 +27401,8 @@ self: { }: mkDerivation { pname = "alex"; - version = "3.2.7.4"; - sha256 = "0vr2jmh7qba9c5lrd969p0qqdc9mi22cw5axsyikm200x80zl4wa"; + version = "3.3.0.0"; + sha256 = "0qws6axn8a9iijhy6x8j3hjvm80sgw6ndxqhp9yc71vbxa2qw3w1"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -27659,13 +27414,13 @@ self: { mainProgram = "alex"; }) {}; - "alex_3_3_0_0" = callPackage + "alex_3_4_0_0" = callPackage ({ mkDerivation, array, base, containers, directory, happy, process }: mkDerivation { pname = "alex"; - version = "3.3.0.0"; - sha256 = "0qws6axn8a9iijhy6x8j3hjvm80sgw6ndxqhp9yc71vbxa2qw3w1"; + version = "3.4.0.0"; + sha256 = "13p3mcmjcz0sgpr5rsbw8fw492b972zh671d6ylhxi4r2gid873s"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -27948,7 +27703,7 @@ self: { broken = true; }) {}; - "algebraic-graphs" = callPackage + "algebraic-graphs_0_6_1" = callPackage ({ mkDerivation, array, base, containers, deepseq, extra , inspection-testing, QuickCheck, transformers }: @@ -27967,9 +27722,10 @@ self: { ]; description = "A library for algebraic graph construction and transformation"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; - "algebraic-graphs_0_7" = callPackage + "algebraic-graphs" = callPackage ({ mkDerivation, array, base, containers, deepseq, extra , inspection-testing, QuickCheck, transformers }: @@ -27988,7 +27744,6 @@ self: { ]; description = "A library for algebraic graph construction and transformation"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "algebraic-graphs-io" = callPackage @@ -28207,6 +27962,8 @@ self: { libraryHaskellDepends = [ base containers transformers vector ]; description = "Sequence alignment with an affine gap penalty model"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "align-audio" = callPackage @@ -28589,6 +28346,8 @@ self: { pname = "alsa-seq"; version = "0.6.0.9"; sha256 = "1kb5p95wrkp8rri9557mhmk09ib82mr34z7xy8kkr1fhrf1xnylf"; + revision = "1"; + editedCabalFile = "1xh10102dk7dxfbfzpbnakjv9cf5gq6nrn7x264hf3bwv5c7nrls"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -28841,8 +28600,8 @@ self: { pname = "amazonka"; version = "1.6.1"; sha256 = "104ifvmwdc1w3y42qcbq57v579zcnmlfv3f0bsazbcqdxnvr9dzd"; - revision = "2"; - editedCabalFile = "171rp3cbgy58lps437c1jfpmi4xsp0z4pral7jh3mybn73l672zm"; + revision = "3"; + editedCabalFile = "1fkmnk2ikx6j6vpda9wx1pc3yl16d2j7gz3wgfh6hj0z856rm4gf"; libraryHaskellDepends = [ amazonka-core base bytestring conduit conduit-extra directory exceptions http-client http-conduit http-types ini mmorph @@ -31510,6 +31269,35 @@ self: { mainProgram = "amqp-builder"; }) {}; + "amqp_0_22_2" = callPackage + ({ mkDerivation, base, binary, bytestring, clock, containers + , crypton-connection, data-binary-ieee754, hspec + , hspec-expectations, monad-control, network, network-uri, split + , stm, text, vector, xml + }: + mkDerivation { + pname = "amqp"; + version = "0.22.2"; + sha256 = "0b1adqrdqkchgk2z80s3h3993808fwgpkn3kw06dz7s99xm53zxv"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary bytestring clock containers crypton-connection + data-binary-ieee754 monad-control network network-uri split stm + text vector + ]; + executableHaskellDepends = [ base containers xml ]; + testHaskellDepends = [ + base binary bytestring clock containers crypton-connection + data-binary-ieee754 hspec hspec-expectations network network-uri + split stm text vector + ]; + description = "Client library for AMQP servers (currently only RabbitMQ)"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "amqp-builder"; + }) {}; + "amqp-conduit" = callPackage ({ mkDerivation, amqp, base, bytestring, conduit, exceptions, hspec , HUnit, lifted-base, monad-control, mtl, resourcet, text @@ -31570,6 +31358,29 @@ self: { license = lib.licenses.gpl3Only; }) {}; + "amqp-utils_0_6_4_0" = callPackage + ({ mkDerivation, amqp, base, bytestring, containers + , crypton-connection, crypton-x509-system, data-default-class + , directory, filepath, filepath-bytestring, hinotify, magic + , network, process, rawfilepath, text, time, tls, unix, utf8-string + }: + mkDerivation { + pname = "amqp-utils"; + version = "0.6.4.0"; + sha256 = "0jbj9zk2mfmgk0gnfcvg7qrfmizgijcj0y4rfh440bs10mw3fjd5"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + amqp base bytestring containers crypton-connection + crypton-x509-system data-default-class directory filepath + filepath-bytestring hinotify magic network process rawfilepath text + time tls unix utf8-string + ]; + description = "AMQP toolset for the command line"; + license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + }) {}; + "amqp-worker" = callPackage ({ mkDerivation, aeson, amqp, base, bytestring, data-default , exceptions, monad-control, monad-loops, mtl, resource-pool @@ -32191,14 +32002,14 @@ self: { }) {}; "ansi-terminal" = callPackage - ({ mkDerivation, base, colour }: + ({ mkDerivation, ansi-terminal-types, base, colour }: mkDerivation { pname = "ansi-terminal"; - version = "0.11.4"; - sha256 = "098f8bdxqmgxaz8y87s6b6bshsq950zq0b75rmbihp2k1a7y963q"; + version = "0.11.5"; + sha256 = "1jwpq3l7ipzjpd6b8gc2df2k5hsh3b9w555ny20q6mgbapfcwjjv"; isLibrary = true; isExecutable = true; - libraryHaskellDepends = [ base colour ]; + libraryHaskellDepends = [ ansi-terminal-types base colour ]; description = "Simple ANSI terminal support, with Windows compatibility"; license = lib.licenses.bsd3; }) {}; @@ -32218,33 +32029,6 @@ self: { }) {}; "ansi-terminal-game" = callPackage - ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal - , clock, colour, containers, exceptions, hspec, hspec-discover - , linebreak, mintty, mtl, QuickCheck, random, split, terminal-size - , timers-tick, unidecode - }: - mkDerivation { - pname = "ansi-terminal-game"; - version = "1.8.1.0"; - sha256 = "0wyx6g9fydbnz9xwjniymwfgn3fgn6vql9spmzl3c1hlpbv5ikfq"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - ansi-terminal array base bytestring cereal clock colour containers - exceptions linebreak mintty mtl QuickCheck random split - terminal-size timers-tick unidecode - ]; - testHaskellDepends = [ - ansi-terminal array base bytestring cereal clock colour containers - exceptions hspec linebreak mintty mtl QuickCheck random split - terminal-size timers-tick unidecode - ]; - testToolDepends = [ hspec-discover ]; - description = "sdl-like functions for terminal applications, based on ansi-terminal"; - license = lib.licenses.gpl3Only; - }) {}; - - "ansi-terminal-game_1_9_1_3" = callPackage ({ mkDerivation, ansi-terminal, array, base, bytestring, cereal , clock, colour, containers, exceptions, hspec, hspec-discover , linebreak, mintty, mtl, QuickCheck, random, split, terminal-size @@ -32254,6 +32038,8 @@ self: { pname = "ansi-terminal-game"; version = "1.9.1.3"; sha256 = "0ln6cx98g7nv6yv600m7p721pscln1c10wkmmykwlfvsrrvnvk7w"; + revision = "1"; + editedCabalFile = "116hl7fm358hqx55w7r1svbwj7gv3m3brxmzqs5qaahqcixndsqx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -32269,7 +32055,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "cross-platform library for terminal games"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "ansi-terminal-types" = callPackage @@ -33010,6 +32795,7 @@ self: { ]; description = "Simple gloss renderer for apecs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "apecs-physics" = callPackage @@ -33028,6 +32814,8 @@ self: { ]; description = "2D physics for apecs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "apecs-physics-gloss" = callPackage @@ -33039,6 +32827,7 @@ self: { libraryHaskellDepends = [ apecs apecs-physics base gloss ]; description = "Gloss rendering for apecs-physics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "apecs-stm" = callPackage @@ -33789,6 +33578,8 @@ self: { ]; testToolDepends = [ sydtest-discover ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "appendmap" = callPackage @@ -33941,40 +33732,6 @@ self: { mainProgram = "refactor"; }) {}; - "apply-refact" = callPackage - ({ mkDerivation, base, containers, directory, extra, filemanip - , filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths - , optparse-applicative, process, refact, silently, syb, tasty - , tasty-expected-failure, tasty-golden, transformers, uniplate - , unix-compat - }: - mkDerivation { - pname = "apply-refact"; - version = "0.10.0.0"; - sha256 = "129bf8n66kpwh5420rxprngg43bqr2agyd8q8d7l49k2rxsjl1fb"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base containers directory extra filemanip ghc ghc-boot-th - ghc-exactprint ghc-paths process refact syb transformers uniplate - unix-compat - ]; - executableHaskellDepends = [ - base containers directory extra filemanip filepath ghc ghc-boot-th - ghc-exactprint ghc-paths optparse-applicative process refact syb - transformers uniplate unix-compat - ]; - testHaskellDepends = [ - base containers directory extra filemanip filepath ghc ghc-boot-th - ghc-exactprint ghc-paths optparse-applicative process refact - silently syb tasty tasty-expected-failure tasty-golden transformers - uniplate unix-compat - ]; - description = "Perform refactorings specified by the refact library"; - license = lib.licenses.bsd3; - mainProgram = "refactor"; - }) {}; - "apply-refact_0_11_0_0" = callPackage ({ mkDerivation, base, containers, directory, extra, filemanip , filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths @@ -34010,7 +33767,7 @@ self: { mainProgram = "refactor"; }) {}; - "apply-refact_0_13_0_0" = callPackage + "apply-refact" = callPackage ({ mkDerivation, base, containers, directory, extra, filemanip , filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths , optparse-applicative, process, refact, silently, syb, tasty @@ -34040,7 +33797,6 @@ self: { ]; description = "Perform refactorings specified by the refact library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "refactor"; }) {}; @@ -34592,6 +34348,7 @@ self: { libraryToolDepends = [ cpphs ]; description = "Common interface using libarchive"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "archive-sig" = callPackage @@ -34830,7 +34587,9 @@ self: { ]; description = "Parse and render JSON"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "argo"; + broken = true; }) {}; "argon" = callPackage @@ -35221,12 +34980,12 @@ self: { broken = true; }) {inherit (pkgs) arpack;}; - "array_0_5_5_0" = callPackage + "array_0_5_6_0" = callPackage ({ mkDerivation, base }: mkDerivation { pname = "array"; - version = "0.5.5.0"; - sha256 = "06zmbd6zlim22zfxmdzzw947nzx9g2d6yx30min6spsk54r8vcqq"; + version = "0.5.6.0"; + sha256 = "0bhiw4zwnlapy4fznck7kna5f59dv33pk34x6r0liw0n81s22pm8"; libraryHaskellDepends = [ base ]; description = "Mutable and immutable arrays"; license = lib.licenses.bsd3; @@ -35630,34 +35389,14 @@ self: { }) {}; "ascii" = callPackage - ({ mkDerivation, ascii-case, ascii-char, ascii-group, ascii-numbers - , ascii-predicates, ascii-superset, ascii-th, base, bytestring - , hedgehog, text - }: - mkDerivation { - pname = "ascii"; - version = "1.2.4.0"; - sha256 = "1rsv9ah0jvf66w3k4smh67wpbm03xl4pdyj8svmdy49hbpihimwi"; - revision = "2"; - editedCabalFile = "00pw1px9ggp6aq9pvimxj9q746b74cgc0pz4rn22q40mdqjadhwl"; - libraryHaskellDepends = [ - ascii-case ascii-char ascii-group ascii-numbers ascii-predicates - ascii-superset ascii-th base bytestring text - ]; - testHaskellDepends = [ base hedgehog text ]; - description = "The ASCII character set and encoding"; - license = lib.licenses.asl20; - }) {}; - - "ascii_1_7_0_0" = callPackage ({ mkDerivation, ascii-case, ascii-caseless, ascii-char , ascii-group, ascii-numbers, ascii-predicates, ascii-superset , ascii-th, base, bytestring, hspec, text }: mkDerivation { pname = "ascii"; - version = "1.7.0.0"; - sha256 = "0rwkj0ncsan0r1v70afqwj2mdhdg9qyawp2nm01056iwj88kgg9p"; + version = "1.7.0.1"; + sha256 = "1kcn65i784kqczp4lni43kmza7jc8ccvp999zm6gsgyf0gpxk8m3"; libraryHaskellDepends = [ ascii-case ascii-caseless ascii-char ascii-group ascii-numbers ascii-predicates ascii-superset ascii-th base bytestring text @@ -35691,8 +35430,8 @@ self: { ({ mkDerivation, ascii-char, base, hashable, hspec }: mkDerivation { pname = "ascii-case"; - version = "1.0.1.2"; - sha256 = "17gqpc65ffy4ipf0bhrs5nyqcmn6fxpx859m03wzm5m2y7ki67nd"; + version = "1.0.1.3"; + sha256 = "068c8ifd4y98k3vjs5hirhfg7mq14zjzc3nw5a6bfd09a6rb2k8w"; libraryHaskellDepends = [ ascii-char base hashable ]; testHaskellDepends = [ ascii-char base hspec ]; description = "ASCII letter case"; @@ -35703,8 +35442,8 @@ self: { ({ mkDerivation, ascii-case, ascii-char, base, hashable, hspec }: mkDerivation { pname = "ascii-caseless"; - version = "0.0.0.0"; - sha256 = "00v05dzs47d638fbnkhb2kv3as5jkzrq33w8skh45srbjabc5w42"; + version = "0.0.0.1"; + sha256 = "0b8b2333qidz6nri92gz1086q3jjyczdlsm8w842ly3dlr9barcq"; libraryHaskellDepends = [ ascii-case ascii-char base hashable ]; testHaskellDepends = [ ascii-case ascii-char base hspec ]; description = "ASCII character without an upper/lower case distinction"; @@ -35714,18 +35453,6 @@ self: { }) {}; "ascii-char" = callPackage - ({ mkDerivation, base, hashable, hspec }: - mkDerivation { - pname = "ascii-char"; - version = "1.0.0.17"; - sha256 = "1562gkfvrcjygs9qpyswsk25d4m2pxblmmbb0hw8jsaml2jwsyss"; - libraryHaskellDepends = [ base hashable ]; - testHaskellDepends = [ base hspec ]; - description = "A Char type representing an ASCII character"; - license = lib.licenses.asl20; - }) {}; - - "ascii-char_1_0_1_0" = callPackage ({ mkDerivation, base, hashable, hspec }: mkDerivation { pname = "ascii-char"; @@ -35737,7 +35464,6 @@ self: { testHaskellDepends = [ base hspec ]; description = "A Char type representing an ASCII character"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "ascii-cows" = callPackage @@ -35773,8 +35499,8 @@ self: { ({ mkDerivation, ascii-char, base, hashable, hedgehog }: mkDerivation { pname = "ascii-group"; - version = "1.0.0.15"; - sha256 = "006b4idi63hz8x54a5fmx5isypdvif8q4ijf274dr93n0c9wh1di"; + version = "1.0.0.16"; + sha256 = "11hh56b7zl7866n600s0hmwwvrrvldjrkz9zscds9gcvvz6xmhnq"; libraryHaskellDepends = [ ascii-char base hashable ]; testHaskellDepends = [ ascii-char base hedgehog ]; description = "ASCII character groups"; @@ -35803,29 +35529,8 @@ self: { }: mkDerivation { pname = "ascii-numbers"; - version = "1.1.0.2"; - sha256 = "0dqqnqrn3hvmjgakm6vzbidlik4p483wcslcwr60qbxa1v5lmznv"; - revision = "4"; - editedCabalFile = "1jam0pzzb678k5bfr6prdzg8v68md2rg39k7sqr4csh1lzkq86im"; - libraryHaskellDepends = [ - ascii-case ascii-char ascii-superset base bytestring hashable text - ]; - testHaskellDepends = [ - ascii-case ascii-char ascii-superset base bytestring hashable - hedgehog invert text - ]; - description = "ASCII representations of numbers"; - license = lib.licenses.asl20; - }) {}; - - "ascii-numbers_1_2_0_0" = callPackage - ({ mkDerivation, ascii-case, ascii-char, ascii-superset, base - , bytestring, hashable, hedgehog, invert, text - }: - mkDerivation { - pname = "ascii-numbers"; - version = "1.2.0.0"; - sha256 = "0542g7whn8qhamgmpx32i875j16ksvjy42l5n7mkq717g86ngz2r"; + version = "1.2.0.1"; + sha256 = "1q6l680w2lssa6m2sj07crcp2ni1z06d62fvm5h1cpnslm03kkgy"; libraryHaskellDepends = [ ascii-case ascii-char ascii-superset base bytestring hashable text ]; @@ -35842,8 +35547,8 @@ self: { ({ mkDerivation, ascii-char, base, hedgehog }: mkDerivation { pname = "ascii-predicates"; - version = "1.0.1.2"; - sha256 = "0awk97iib6rzrpsh7322f09sj6rkmhkn1hrgsw0zxq0w0bfp7kyj"; + version = "1.0.1.3"; + sha256 = "1gcy00wncxxg6ri1aqscczrj388kajrxc1xiiyfgzyvpx82dfkmf"; libraryHaskellDepends = [ ascii-char base ]; testHaskellDepends = [ ascii-char base hedgehog ]; description = "Various categorizations of ASCII characters"; @@ -35895,29 +35600,13 @@ self: { }) {}; "ascii-superset" = callPackage - ({ mkDerivation, ascii-char, base, bytestring, hashable, hedgehog - , text - }: - mkDerivation { - pname = "ascii-superset"; - version = "1.0.1.15"; - sha256 = "0jq2kfc6mmpavljrv89xqwn0iskf3z9l3m3hjcm3bw03wlyv6clp"; - libraryHaskellDepends = [ - ascii-char base bytestring hashable text - ]; - testHaskellDepends = [ ascii-char base hedgehog text ]; - description = "Representing ASCII with refined supersets"; - license = lib.licenses.asl20; - }) {}; - - "ascii-superset_1_3_0_0" = callPackage ({ mkDerivation, ascii-case, ascii-caseless, ascii-char, base , bytestring, hashable, hspec, text }: mkDerivation { pname = "ascii-superset"; - version = "1.3.0.0"; - sha256 = "0csfjkg5aqx2cs9n27rs4zbfrlzgf7c3ca8vfh8f0vpy4qy94f33"; + version = "1.3.0.1"; + sha256 = "0kcfbfys62kj9jk72kqfb6ahhv35gjg9d3j7ss5pk2hmns1gyhfl"; libraryHaskellDepends = [ ascii-case ascii-caseless ascii-char base bytestring hashable text ]; @@ -35947,35 +35636,13 @@ self: { }) {}; "ascii-th" = callPackage - ({ mkDerivation, ascii-char, ascii-superset, base, bytestring - , hspec, template-haskell, text - }: - mkDerivation { - pname = "ascii-th"; - version = "1.0.0.14"; - sha256 = "0wm0n7wr7bypdqs1cpgkcbmcwgz84lm7la2xkqflwc2kn0wr839h"; - revision = "2"; - editedCabalFile = "0a74410lmbd11j6bfh5x1rk3gyp7sybl7lqfxkkz5qws413ijli6"; - libraryHaskellDepends = [ - ascii-char ascii-superset base template-haskell - ]; - testHaskellDepends = [ - ascii-char ascii-superset base bytestring hspec text - ]; - description = "Template Haskell support for ASCII"; - license = lib.licenses.asl20; - }) {}; - - "ascii-th_1_2_0_0" = callPackage ({ mkDerivation, ascii-case, ascii-caseless, ascii-char , ascii-superset, base, bytestring, hspec, template-haskell, text }: mkDerivation { pname = "ascii-th"; - version = "1.2.0.0"; - sha256 = "07v6795rfwb8h4x31kc7vdmwg9z23jf4418dcv612c27dqhx4hbg"; - revision = "1"; - editedCabalFile = "1r6z6brkfahs9zifjhr7bpqblkiajcjknkgx2i57jrn5s3b97phk"; + version = "1.2.0.1"; + sha256 = "0gj7agf0lda6qdlrm9920lk4qv2ajqab5403q00adqwwpd7xmf89"; libraryHaskellDepends = [ ascii-case ascii-caseless ascii-char ascii-superset base template-haskell @@ -36065,7 +35732,9 @@ self: { ]; description = "Pretty rendering of Ascii diagram into svg or png"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "asciidiagram"; + broken = true; }) {}; "asic" = callPackage @@ -36470,19 +36139,6 @@ self: { }) {inherit (pkgs) assimp;}; "assoc" = callPackage - ({ mkDerivation, base, bifunctors, tagged }: - mkDerivation { - pname = "assoc"; - version = "1.0.2"; - sha256 = "0kqlizznjy94fm8zr1ng633yxbinjff7cnsiaqs7m33ix338v66q"; - revision = "4"; - editedCabalFile = "108q0in0bmyavhaabc75wa70945z6kb05kla1aj07fdn7j9x1v4x"; - libraryHaskellDepends = [ base bifunctors tagged ]; - description = "swap and assoc: Symmetric and Semigroupy Bifunctors"; - license = lib.licenses.bsd3; - }) {}; - - "assoc_1_1" = callPackage ({ mkDerivation, base, tagged }: mkDerivation { pname = "assoc"; @@ -36491,7 +36147,6 @@ self: { libraryHaskellDepends = [ base tagged ]; description = "swap and assoc: Symmetric and Semigroupy Bifunctors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "assoc-list" = callPackage @@ -36506,6 +36161,8 @@ self: { testHaskellDepends = [ base contravariant hedgehog ]; description = "Association lists (lists of tuples)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "assoc-listlike" = callPackage @@ -36520,6 +36177,8 @@ self: { testHaskellDepends = [ base contravariant hedgehog ListLike ]; description = "Association lists (list-like collections of tuples)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "assumpta" = callPackage @@ -36837,8 +36496,8 @@ self: { }: mkDerivation { pname = "async-pool"; - version = "0.9.1"; - sha256 = "11nig4p5m916ffnbhkawglm7r2kl5b8090xv9cyr849l7q7mrcm8"; + version = "0.9.2"; + sha256 = "10qnnj850w89p7g42gn4l9m1bjsdh4pchkm85zj94v3y0f037vbj"; libraryHaskellDepends = [ async base containers fgl monad-control stm transformers transformers-base @@ -37177,8 +36836,8 @@ self: { }: mkDerivation { pname = "atomic-counter"; - version = "0.1.2"; - sha256 = "0z6arr3g439v392shvp13dhqyydxnbbyw9dsxyjyr078hn7pp2ky"; + version = "0.1.2.1"; + sha256 = "053p72hjzrq29kg4x4s5a063sw1k37yrcw0qabkhg9rbk46206qy"; libraryHaskellDepends = [ async base QuickCheck ]; testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ]; benchmarkHaskellDepends = [ @@ -37213,6 +36872,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-modify-general" = callPackage @@ -37407,6 +37068,7 @@ self: { license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; mainProgram = "atsfmt"; + broken = true; }) {}; "ats-pkg" = callPackage @@ -37640,8 +37302,8 @@ self: { pname = "attoparsec"; version = "0.14.4"; sha256 = "0v4yjz4qi8bwhbyavqxlhsfb1iv07v10gxi64khmsmi4hvjpycrz"; - revision = "3"; - editedCabalFile = "1ciz49yg6zcaf5dvh5wp3kv92jxa23pblggfldbmy5q54dr5nish"; + revision = "4"; + editedCabalFile = "07sqs9rnxyjgrz22nxsx9xwj5hkljnyw8bqcbb75kbqi6c9ky6ba"; libraryHaskellDepends = [ array base bytestring containers deepseq ghc-prim scientific text transformers @@ -37660,6 +37322,24 @@ self: { license = lib.licenses.bsd3; }) {}; + "attoparsec-aeson" = callPackage + ({ mkDerivation, aeson, attoparsec, base, bytestring + , integer-conversion, primitive, scientific, text, vector + }: + mkDerivation { + pname = "attoparsec-aeson"; + version = "2.2.0.0"; + sha256 = "1r228cpyd27658csc5pabbwjwf1q5q93a3f1fkymjh4ib4rzw27s"; + libraryHaskellDepends = [ + aeson attoparsec base bytestring integer-conversion primitive + scientific text vector + ]; + description = "Parsing of aeson's Value with attoparsec"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "attoparsec-arff" = callPackage ({ mkDerivation, attoparsec, base, bytestring }: mkDerivation { @@ -37786,6 +37466,32 @@ self: { license = lib.licenses.bsd3; }) {}; + "attoparsec-framer_0_1_0_1" = callPackage + ({ mkDerivation, attoparsec, attoparsec-binary, base, bytestring + , exceptions, hspec, network, network-run, QuickCheck, text + }: + mkDerivation { + pname = "attoparsec-framer"; + version = "0.1.0.1"; + sha256 = "1mj67jbdmc6svjrhhq5q0vcqp64p2bllb0py8qq0fin5bdnk4445"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec base bytestring exceptions text + ]; + executableHaskellDepends = [ + attoparsec attoparsec-binary base bytestring exceptions network + network-run QuickCheck text + ]; + testHaskellDepends = [ + attoparsec attoparsec-binary base bytestring exceptions hspec + QuickCheck text + ]; + description = "Use Attoparsec to parse framed protocol byte streams"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "attoparsec-ip" = callPackage ({ mkDerivation, attoparsec, base, ip, QuickCheck, tasty , tasty-quickcheck, text, vector @@ -37803,21 +37509,6 @@ self: { }) {}; "attoparsec-iso8601" = callPackage - ({ mkDerivation, attoparsec, base, base-compat-batteries, text - , time, time-compat - }: - mkDerivation { - pname = "attoparsec-iso8601"; - version = "1.0.2.1"; - sha256 = "1zmj6v63xjj20ja50ffbi222yg513cnnqyxl76ybb4x98z9jld0k"; - libraryHaskellDepends = [ - attoparsec base base-compat-batteries text time time-compat - ]; - description = "Parsing of ISO 8601 dates, originally from aeson"; - license = lib.licenses.bsd3; - }) {}; - - "attoparsec-iso8601_1_1_0_0" = callPackage ({ mkDerivation, attoparsec, base, base-compat-batteries, text , time, time-compat }: @@ -37832,7 +37523,6 @@ self: { ]; description = "Parsing of ISO 8601 dates, originally from aeson"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "attoparsec-iteratee" = callPackage @@ -38028,8 +37718,8 @@ self: { pname = "audacity"; version = "0.0.2.1"; sha256 = "04r36gy8z0d2fz1l5px6yajp7izf3zpda9vci6q0wc273pxc8ck6"; - revision = "1"; - editedCabalFile = "0f43s469wgrp6vkiqz1ibnvcv37zjsng2pdzkhhpg9v4syi30r3b"; + revision = "2"; + editedCabalFile = "0b4avhc577n7r43lw2zg360ndx8cqp39ghz63xpzxdc9dlsqyii0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -38408,6 +38098,7 @@ self: { ]; description = "Autodocodec interpreters for Servant Multipart"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "autodocodec-swagger2" = callPackage @@ -38446,21 +38137,6 @@ self: { }) {}; "autoexporter" = callPackage - ({ mkDerivation, base, Cabal, directory, filepath }: - mkDerivation { - pname = "autoexporter"; - version = "2.0.0.2"; - sha256 = "1058lfjxlcbnd2p7lfjvhbzsgl0wss24c6frw7qzl2sg2kd5bppi"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base Cabal directory filepath ]; - executableHaskellDepends = [ base Cabal directory filepath ]; - description = "Automatically re-export modules"; - license = lib.licenses.mit; - mainProgram = "autoexporter"; - }) {}; - - "autoexporter_2_0_0_8" = callPackage ({ mkDerivation, base, Cabal, directory, filepath }: mkDerivation { pname = "autoexporter"; @@ -38472,7 +38148,6 @@ self: { executableHaskellDepends = [ base Cabal directory filepath ]; description = "Automatically re-export modules"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "autoexporter"; }) {}; @@ -39045,8 +38720,8 @@ self: { }: mkDerivation { pname = "aws"; - version = "0.24"; - sha256 = "0phcpmq15fn62pq2ngr6lyylqaz3cq3qdp828rcbzvsrarscy519"; + version = "0.24.1"; + sha256 = "0ni6yyjzpyzvixd7b2yzqimarjbbhqfv8vxsn2y8yppvdb2am73i"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -39097,8 +38772,8 @@ self: { pname = "aws-cloudfront-signed-cookies"; version = "0.2.0.12"; sha256 = "1gdam3h8ir1lz8phhj03ckiv0f371xl79adi4kz2yqk2ayvcixhv"; - revision = "1"; - editedCabalFile = "0a9zvqjp6lvpn3xhlxxd73fpvgxx6vy5j0nkigqgc9wxsrmm1vk3"; + revision = "2"; + editedCabalFile = "0jrf9yplij4b0mzs09645xmvsp0cl8darn4zdmm00by2mfkk377y"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -40306,10 +39981,8 @@ self: { }: mkDerivation { pname = "backprop"; - version = "0.2.6.4"; - sha256 = "0wc71r6l5qgkspl5v76f1d75xwir9jp5kzdl83rq5sviggd458v9"; - revision = "1"; - editedCabalFile = "03cdn7mbbx72lqj9754b326kd2mkn1b9vq11z1ksxck8z5vbkrs6"; + version = "0.2.6.5"; + sha256 = "0rc6dsf0zasl9vah8kv61qk2z7s644lzsrmkd7fwxwj1480kb482"; libraryHaskellDepends = [ base containers deepseq microlens primitive reflection transformers vector vinyl @@ -40466,8 +40139,10 @@ self: { }: mkDerivation { pname = "balkon"; - version = "1.1.0.0"; - sha256 = "0836mr88x8qqphv0mp9brbcggjpyz4id3z0n7rbrazg4gy343pyy"; + version = "1.3.0.0"; + sha256 = "0gyr25wp9b435csz6bbjjd157p16y91r2q17p10y5y42wz8hcsfw"; + revision = "1"; + editedCabalFile = "05w7g2wmkcqps2hasp4ih3h1yaahb1i5gw569s7mpycmgs65j875"; libraryHaskellDepends = [ base harfbuzz-pure text text-icu unicode-data-scripts ]; @@ -40668,8 +40343,8 @@ self: { pname = "ban-instance"; version = "0.1.0.1"; sha256 = "0504qsjbqbrdf9avfrhs290baszc9dickx7wknbyxwrzpzzbpggk"; - revision = "2"; - editedCabalFile = "1piiw6fkfbkdbiz4sky34anghhhzjsklgxgxn1x76fsh5nyj1dkn"; + revision = "3"; + editedCabalFile = "0lhzv5hvqahgqqdjmjfdd3qi2m5q48nf389d3xd96465dfmk1q39"; libraryHaskellDepends = [ base template-haskell ]; testHaskellDepends = [ base ]; description = "For when a type should never be an instance of a class"; @@ -40762,6 +40437,8 @@ self: { testHaskellDepends = [ barbies base ]; description = "Create strippable HKD via TH"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "barbly" = callPackage @@ -40919,8 +40596,8 @@ self: { ({ mkDerivation, base, ghc-prim, unix }: mkDerivation { pname = "base-compat"; - version = "0.12.2"; - sha256 = "1gah466nd6hkj716gwljfh0g270iaqy2rq2a1vw3di2s7a4dqam6"; + version = "0.12.3"; + sha256 = "13dcrwihqn57js1ylj9vbw2snx90kfwikanvs1bj77zm22grj9nv"; libraryHaskellDepends = [ base ghc-prim unix ]; description = "A compatibility layer for base"; license = lib.licenses.mit; @@ -40944,8 +40621,8 @@ self: { }: mkDerivation { pname = "base-compat-batteries"; - version = "0.12.2"; - sha256 = "16gbqng8556wqcvrmj3dmqxh9sxp7z6ixgv0j5sy017r0wp0ksgd"; + version = "0.12.3"; + sha256 = "1bsz3bi1mnp60p90n5av76knscgssqvphc9f2jy1nhyr6ap7jxi0"; libraryHaskellDepends = [ base base-compat ghc-prim ]; testHaskellDepends = [ base hspec QuickCheck ]; testToolDepends = [ hspec-discover ]; @@ -41058,20 +40735,6 @@ self: { }) {}; "base-orphans" = callPackage - ({ mkDerivation, base, ghc-prim, hspec, hspec-discover, QuickCheck - }: - mkDerivation { - pname = "base-orphans"; - version = "0.8.8.2"; - sha256 = "14jhh848q3451hqi4knslc7nnvw9dn77vawnhp4qs4l4703fgjk1"; - libraryHaskellDepends = [ base ghc-prim ]; - testHaskellDepends = [ base hspec QuickCheck ]; - testToolDepends = [ hspec-discover ]; - description = "Backwards-compatible orphan instances for base"; - license = lib.licenses.mit; - }) {}; - - "base-orphans_0_9_0" = callPackage ({ mkDerivation, base, ghc-prim, hspec, hspec-discover, QuickCheck }: mkDerivation { @@ -41083,7 +40746,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Backwards-compatible orphan instances for base"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "base-prelude" = callPackage @@ -41134,6 +40796,31 @@ self: { license = lib.licenses.bsd3; }) {}; + "base16_1_0" = callPackage + ({ mkDerivation, base, base16-bytestring, bytestring, criterion + , deepseq, primitive, QuickCheck, random-bytestring, tasty + , tasty-hunit, tasty-quickcheck, text, text-short + }: + mkDerivation { + pname = "base16"; + version = "1.0"; + sha256 = "1plwc4yrkvd5j6y09fjvyzhr05mzhzwz6z41fyb60y0bj5j66dl6"; + libraryHaskellDepends = [ + base bytestring deepseq primitive text text-short + ]; + testHaskellDepends = [ + base base16-bytestring bytestring QuickCheck random-bytestring + tasty tasty-hunit tasty-quickcheck text text-short + ]; + benchmarkHaskellDepends = [ + base base16-bytestring bytestring criterion deepseq + random-bytestring text + ]; + description = "Fast RFC 4648-compliant Base16 encoding"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "base16-bytestring_0_1_1_7" = callPackage ({ mkDerivation, base, bytestring, ghc-prim }: mkDerivation { @@ -41185,29 +40872,6 @@ self: { }) {}; "base32" = callPackage - ({ mkDerivation, base, bytestring, criterion, deepseq, memory - , QuickCheck, random-bytestring, tasty, tasty-hunit - , tasty-quickcheck, text, text-short - }: - mkDerivation { - pname = "base32"; - version = "0.2.2.0"; - sha256 = "1g4yb3v1rgggl4ks4wznidssycs23zjl6fz1iiachf730hz79w31"; - libraryHaskellDepends = [ - base bytestring deepseq text text-short - ]; - testHaskellDepends = [ - base bytestring memory QuickCheck random-bytestring tasty - tasty-hunit tasty-quickcheck text text-short - ]; - benchmarkHaskellDepends = [ - base bytestring criterion deepseq memory random-bytestring text - ]; - description = "Fast RFC 4648-compliant Base32 encoding"; - license = lib.licenses.bsd3; - }) {}; - - "base32_0_3_1_0" = callPackage ({ mkDerivation, base, bytestring, criterion, deepseq, memory , QuickCheck, random-bytestring, tasty, tasty-hunit , tasty-quickcheck, text, text-short @@ -41228,7 +40892,6 @@ self: { ]; description = "Fast RFC 4648-compliant Base32 encoding"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "base32-bytestring" = callPackage @@ -41421,6 +41084,8 @@ self: { ]; description = "Base64 encoding of byte sequences"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "base64-bytestring" = callPackage @@ -41432,6 +41097,8 @@ self: { pname = "base64-bytestring"; version = "1.2.1.0"; sha256 = "1ja9vkgnpkzaw8gz6sm5jmgha6wg3m1j281m0nv1w9yyxlqfvy7v"; + revision = "1"; + editedCabalFile = "00wqskhc31agyxvm7546367qb33v5i3j31sibcw6vihli77mqc25"; libraryHaskellDepends = [ base bytestring ]; testHaskellDepends = [ base bytestring HUnit QuickCheck test-framework @@ -41451,8 +41118,8 @@ self: { pname = "base64-bytestring-type"; version = "1.0.1"; sha256 = "03kq4rjj6by02rf3hg815jfdqpdk0xygm5f46r2pn8mb99yd01zn"; - revision = "17"; - editedCabalFile = "1wbwmwab30g41d9m1xb0vqlfnla6h2f6if53vv99dasd03jqd32l"; + revision = "18"; + editedCabalFile = "0ykjgy3c7f6rmx9mj99y21lxsb81pd999pl98x0kvw0fai762hbp"; libraryHaskellDepends = [ aeson base base-compat base64-bytestring binary bytestring cereal deepseq hashable http-api-data QuickCheck serialise text @@ -41546,6 +41213,8 @@ self: { libraryHaskellDepends = [ base ]; description = "alternative prelude"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "basement_0_0_14" = callPackage @@ -41584,6 +41253,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Foundation scrap box of array & string"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "basen" = callPackage @@ -42132,6 +41803,7 @@ self: { ]; description = "Language tags as specified by BCP 47"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bcp47-orphans" = callPackage @@ -42153,6 +41825,7 @@ self: { ]; description = "BCP47 orphan instances"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bcrypt" = callPackage @@ -42372,42 +42045,20 @@ self: { }: mkDerivation { pname = "beam-core"; - version = "0.9.2.1"; - sha256 = "0js10ai2dqdv6fm99ni6ckiq1rbq1wm82s73h81hln0qf1xnk3ra"; + version = "0.10.1.0"; + sha256 = "0h1kr653wd00m5pypj4ia8d1ni6m2qrzqqqh19hnd8wz1n0pfd1h"; libraryHaskellDepends = [ aeson base bytestring containers dlist free ghc-prim hashable microlens mtl network-uri scientific tagged text time vector vector-sized ]; testHaskellDepends = [ - base bytestring tasty tasty-hunit text time + base bytestring microlens tasty tasty-hunit text time ]; description = "Type-safe, feature-complete SQL query and manipulation interface for Haskell"; license = lib.licenses.mit; }) {}; - "beam-core_0_10_0_0" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, dlist, free - , ghc-prim, hashable, microlens, mtl, network-uri, scientific - , tagged, tasty, tasty-hunit, text, time, vector, vector-sized - }: - mkDerivation { - pname = "beam-core"; - version = "0.10.0.0"; - sha256 = "0567j05c3ihr5j3n3pl39x84xp4p6y2haxybwc22acbami1hqrkw"; - libraryHaskellDepends = [ - aeson base bytestring containers dlist free ghc-prim hashable - microlens mtl network-uri scientific tagged text time vector - vector-sized - ]; - testHaskellDepends = [ - base bytestring tasty tasty-hunit text time - ]; - description = "Type-safe, feature-complete SQL query and manipulation interface for Haskell"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "beam-migrate" = callPackage ({ mkDerivation, aeson, base, beam-core, bytestring, containers , deepseq, dependent-map, dependent-sum, free, ghc-prim, hashable @@ -42416,8 +42067,8 @@ self: { }: mkDerivation { pname = "beam-migrate"; - version = "0.5.1.2"; - sha256 = "1h1nb5y6lzc5zclkz925kr446kc05sdj94hbvpf41lypx0b133xv"; + version = "0.5.2.1"; + sha256 = "16gl39cpj7gvb82i41h18606n6k40hi8lfyyw1x0dq73xs2ldfyc"; libraryHaskellDepends = [ aeson base beam-core bytestring containers deepseq dependent-map dependent-sum free ghc-prim hashable haskell-src-exts microlens mtl @@ -42428,27 +42079,6 @@ self: { license = lib.licenses.mit; }) {}; - "beam-migrate_0_5_2_0" = callPackage - ({ mkDerivation, aeson, base, beam-core, bytestring, containers - , deepseq, dependent-map, dependent-sum, free, ghc-prim, hashable - , haskell-src-exts, microlens, mtl, parallel, pqueue, pretty - , scientific, text, time, unordered-containers, uuid-types, vector - }: - mkDerivation { - pname = "beam-migrate"; - version = "0.5.2.0"; - sha256 = "036awq66h8r8mn46kvzlc0si6vq6ajg69kv1xq0865v7arrlr296"; - libraryHaskellDepends = [ - aeson base beam-core bytestring containers deepseq dependent-map - dependent-sum free ghc-prim hashable haskell-src-exts microlens mtl - parallel pqueue pretty scientific text time unordered-containers - uuid-types vector - ]; - description = "SQL DDL support and migrations support library for Beam"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "beam-mysql" = callPackage ({ mkDerivation, aeson, attoparsec, base, beam-core, bytestring , case-insensitive, free, hashable, mtl, mysql, network-uri @@ -42495,8 +42125,8 @@ self: { }: mkDerivation { pname = "beam-postgres"; - version = "0.5.2.1"; - sha256 = "028aqd7r49avmwlf97612f98a5maw01l0d5vlbg0nj7kqi03ghj4"; + version = "0.5.3.1"; + sha256 = "19gagw9r2wfy398calkcnilsgl89sjpy8vj9bdswg390mw15m41n"; libraryHaskellDepends = [ aeson attoparsec base beam-core beam-migrate bytestring case-insensitive conduit free hashable haskell-src-exts lifted-base @@ -42512,34 +42142,6 @@ self: { license = lib.licenses.mit; }) {}; - "beam-postgres_0_5_3_0" = callPackage - ({ mkDerivation, aeson, attoparsec, base, beam-core, beam-migrate - , bytestring, case-insensitive, conduit, free, hashable - , haskell-src-exts, hedgehog, lifted-base, monad-control, mtl - , network-uri, postgresql-libpq, postgresql-simple, scientific - , tagged, tasty, tasty-hunit, text, time, tmp-postgres - , transformers-base, unordered-containers, uuid, uuid-types, vector - }: - mkDerivation { - pname = "beam-postgres"; - version = "0.5.3.0"; - sha256 = "0y5pm0s83f2ijz0mslp98c07ywh25nx3g870hp8s89isjviwhdss"; - libraryHaskellDepends = [ - aeson attoparsec base beam-core beam-migrate bytestring - case-insensitive conduit free hashable haskell-src-exts lifted-base - monad-control mtl network-uri postgresql-libpq postgresql-simple - scientific tagged text time transformers-base unordered-containers - uuid-types vector - ]; - testHaskellDepends = [ - aeson base beam-core beam-migrate bytestring hedgehog - postgresql-simple tasty tasty-hunit text tmp-postgres uuid vector - ]; - description = "Connection layer between beam and postgres"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "beam-sqlite" = callPackage ({ mkDerivation, aeson, attoparsec, base, beam-core, beam-migrate , bytestring, dlist, free, hashable, monad-control, mtl @@ -42549,8 +42151,8 @@ self: { }: mkDerivation { pname = "beam-sqlite"; - version = "0.5.1.2"; - sha256 = "0d5s6r54aamkr91ji3z05cn7vjmbl0xaysnx3dmalx75r5jhmhzq"; + version = "0.5.3.0"; + sha256 = "050nqjx6916j9c499i5zskankpg3bbh9f4m8lrnmf0mj4hsl96m4"; libraryHaskellDepends = [ aeson attoparsec base beam-core beam-migrate bytestring dlist free hashable monad-control mtl network-uri scientific sqlite-simple @@ -42564,31 +42166,6 @@ self: { license = lib.licenses.mit; }) {}; - "beam-sqlite_0_5_2_0" = callPackage - ({ mkDerivation, aeson, attoparsec, base, beam-core, beam-migrate - , bytestring, dlist, free, hashable, monad-control, mtl - , network-uri, scientific, sqlite-simple, tasty - , tasty-expected-failure, tasty-hunit, text, time - , transformers-base, unix - }: - mkDerivation { - pname = "beam-sqlite"; - version = "0.5.2.0"; - sha256 = "1cjf9jci0ykkvqry1yygfmjli73si6zgskgpym2n28r93g0c3znd"; - libraryHaskellDepends = [ - aeson attoparsec base beam-core beam-migrate bytestring dlist free - hashable monad-control mtl network-uri scientific sqlite-simple - text time transformers-base unix - ]; - testHaskellDepends = [ - base beam-core beam-migrate sqlite-simple tasty - tasty-expected-failure tasty-hunit text time - ]; - description = "Beam driver for SQLite"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "beam-th" = callPackage ({ mkDerivation, base, beam, doctest, doctest-discover, microlens , mtl, tasty, tasty-hunit, template-haskell, text, th-expand-syns @@ -42643,8 +42220,8 @@ self: { }: mkDerivation { pname = "bearriver"; - version = "0.14.2"; - sha256 = "0qgdn1f5wjvbhllcvf7s2g934hr4g2g655qq15dxwl84zz83lswg"; + version = "0.14.3"; + sha256 = "1qndif1gl9qdg2mhp2w419g4p7nz3khjlhhycm66dzb47rf0scaq"; libraryHaskellDepends = [ base deepseq dunai MonadRandom mtl simple-affine-space transformers ]; @@ -42861,6 +42438,8 @@ self: { testHaskellDepends = [ base split text ]; description = "Plot and compare benchmarks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bench-show" = callPackage @@ -42884,7 +42463,9 @@ self: { testHaskellDepends = [ base split text ]; description = "Show, plot and compare benchmark results"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "bench-show"; + broken = true; }) {}; "benchmark-function" = callPackage @@ -43167,7 +42748,9 @@ self: { ]; description = "A horizontal version of tetris for braille users"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "betris"; + broken = true; }) {}; "between" = callPackage @@ -43240,6 +42823,7 @@ self: { ]; description = "Implementation of the BGAPI serial protocol"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "bglibtest"; }) {}; @@ -43324,6 +42908,8 @@ self: { pname = "bibtex"; version = "0.1.0.6"; sha256 = "012zxvrlkl5vdjl1nmabhyi160xak0c8s3gn5ffxz2rqi6akn2h9"; + revision = "1"; + editedCabalFile = "028jl40ri1p1gn76m09ay6hhhd9827y7g54qwplcszxjykxgnvih"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base latex parsec utility-ht ]; @@ -43332,9 +42918,24 @@ self: { maintainers = [ lib.maintainers.thielema ]; }) {}; + "bibtex_0_1_0_7" = callPackage + ({ mkDerivation, base, latex, parsec, utility-ht }: + mkDerivation { + pname = "bibtex"; + version = "0.1.0.7"; + sha256 = "13brddmc8ifyncg1cc0mcl6db94lfz6vmrpjrjap7jrs060r0j9i"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base latex parsec utility-ht ]; + description = "Parse, format and processing BibTeX files"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.thielema ]; + }) {}; + "bidi-icu" = callPackage ({ mkDerivation, base, containers, data-default, ghc-prim, hspec - , icu-uc, inline-c, primitive, tasty, tasty-hspec, template-haskell + , icu, inline-c, primitive, tasty, tasty-hspec, template-haskell , text, transformers, vector }: mkDerivation { @@ -43345,7 +42946,7 @@ self: { base containers data-default ghc-prim inline-c primitive template-haskell text transformers vector ]; - libraryPkgconfigDepends = [ icu-uc ]; + libraryPkgconfigDepends = [ icu ]; testHaskellDepends = [ base data-default ghc-prim hspec primitive tasty tasty-hspec text vector @@ -43354,7 +42955,7 @@ self: { license = "(BSD-2-Clause OR Apache-2.0)"; hydraPlatforms = lib.platforms.none; broken = true; - }) {icu-uc = null;}; + }) {inherit (pkgs) icu;}; "bidirectional" = callPackage ({ mkDerivation, base, hedgehog, mtl, profunctors }: @@ -43695,23 +43296,6 @@ self: { }) {}; "bin" = callPackage - ({ mkDerivation, base, boring, dec, deepseq, fin, hashable - , QuickCheck, some - }: - mkDerivation { - pname = "bin"; - version = "0.1.2"; - sha256 = "0idm2ix4wv1ppr3fjvd8xdlbkhk6lq4rvfs9dv615lmds4gbzm72"; - revision = "1"; - editedCabalFile = "052i9qfb037p71fhzl38ly51jkk9q6klb1cb07a0cv2ja5nzrjgn"; - libraryHaskellDepends = [ - base boring dec deepseq fin hashable QuickCheck some - ]; - description = "Bin: binary natural numbers"; - license = lib.licenses.gpl2Plus; - }) {}; - - "bin_0_1_3" = callPackage ({ mkDerivation, base, boring, dec, deepseq, fin, hashable , QuickCheck, some }: @@ -43724,7 +43308,6 @@ self: { ]; description = "Bin: binary natural numbers"; license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; }) {}; "binance-exports" = callPackage @@ -43735,10 +43318,8 @@ self: { }: mkDerivation { pname = "binance-exports"; - version = "0.1.1.0"; - sha256 = "18gaky4kyyx6v3jxay0ax8scbqnljrfxk6papbri9hm0ylh2vh8l"; - revision = "1"; - editedCabalFile = "0v5ss5mn2r3ir7lbwbiszw9l4khgmvw4dfavdfg29mhv39hr1y6v"; + version = "0.1.2.0"; + sha256 = "1gp7cwkz1p1g1zybfhc924pi7qpvwy9cr6k5bwn71iff877d4bii"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -43959,27 +43540,26 @@ self: { "binary-instances" = callPackage ({ mkDerivation, aeson, base, binary, binary-orphans, bytestring - , case-insensitive, data-array-byte, hashable, primitive - , QuickCheck, quickcheck-instances, scientific, tagged, tasty - , tasty-quickcheck, text, text-binary, time-compat - , unordered-containers, vector, vector-binary-instances + , case-insensitive, hashable, primitive, QuickCheck + , quickcheck-instances, scientific, tagged, tasty, tasty-quickcheck + , text, text-binary, time-compat, unordered-containers, vector + , vector-binary-instances }: mkDerivation { pname = "binary-instances"; version = "1.0.4"; sha256 = "0pv4idgzl2wkm15ih594gbw6wihwrdspa91j5ajgwr4ikx6f3v3h"; - revision = "1"; - editedCabalFile = "0811ji5682fdk6di5fk3vg95074ji187gxg6r9qzfglcv6kx8b2n"; + revision = "2"; + editedCabalFile = "04y9j42c3avfhf35jzh52w0zrp0m4j8cvbn3zqjjybyvhw3jgihf"; libraryHaskellDepends = [ aeson base binary binary-orphans case-insensitive hashable primitive scientific tagged text text-binary time-compat unordered-containers vector vector-binary-instances ]; testHaskellDepends = [ - aeson base binary bytestring case-insensitive data-array-byte - hashable primitive QuickCheck quickcheck-instances scientific - tagged tasty tasty-quickcheck text time-compat unordered-containers - vector + aeson base binary bytestring case-insensitive hashable primitive + QuickCheck quickcheck-instances scientific tagged tasty + tasty-quickcheck text time-compat unordered-containers vector ]; description = "Orphan instances for binary"; license = lib.licenses.bsd3; @@ -44034,8 +43614,8 @@ self: { }) {}; "binary-orphans" = callPackage - ({ mkDerivation, base, binary, data-array-byte, OneTuple - , QuickCheck, quickcheck-instances, tagged, tasty, tasty-quickcheck + ({ mkDerivation, base, binary, OneTuple, QuickCheck + , quickcheck-instances, tagged, tasty, tasty-quickcheck , transformers }: mkDerivation { @@ -44044,12 +43624,10 @@ self: { sha256 = "1lphlb7nar3d9db87wl0sh6srx03dad2ssxqak8bn9bdr2dphnsz"; revision = "2"; editedCabalFile = "1q9fbn41fi4wfk8mrm9izy5jna86gmy7gxhz94crqfhp5f89v58l"; - libraryHaskellDepends = [ - base binary data-array-byte transformers - ]; + libraryHaskellDepends = [ base binary transformers ]; testHaskellDepends = [ - base binary data-array-byte OneTuple QuickCheck - quickcheck-instances tagged tasty tasty-quickcheck + base binary OneTuple QuickCheck quickcheck-instances tagged tasty + tasty-quickcheck ]; description = "Compatibility package for binary; provides instances"; license = lib.licenses.bsd3; @@ -45284,7 +44862,9 @@ self: { testToolDepends = [ hspec-discover ]; description = "Encode precise binary representations directly in types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.raehik ]; + broken = true; }) {}; "bins" = callPackage @@ -45677,6 +45257,7 @@ self: { ]; description = "A small tool that clears cookies (and more)"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "bisc"; }) {}; @@ -46253,6 +45834,8 @@ self: { testToolDepends = [ sydtest-discover ]; description = "Generic and easy to use haskell bitfields"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bitly-cli" = callPackage @@ -46695,6 +46278,8 @@ self: { ]; description = "A lousy Prelude replacement by a lousy dude"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bizzlelude-js" = callPackage @@ -46852,6 +46437,8 @@ self: { pname = "blake2"; version = "0.3.0"; sha256 = "0y937kr3dp87likwrl4wpaw80jhf383k89zn8li1yj3zp1vb6niv"; + revision = "1"; + editedCabalFile = "11ivz5b9mfmlcqavdnkvmn2zr6ymik8k1xrl1p945bjl4iiyh43b"; libraryHaskellDepends = [ base bytestring ]; testHaskellDepends = [ base base16-bytestring bytestring hlint QuickCheck tasty @@ -46862,6 +46449,25 @@ self: { license = lib.licenses.publicDomain; }) {}; + "blake2_0_3_0_1" = callPackage + ({ mkDerivation, base, base16-bytestring, bytestring, criterion + , hlint, QuickCheck, tasty, tasty-quickcheck + }: + mkDerivation { + pname = "blake2"; + version = "0.3.0.1"; + sha256 = "17y8mychiiawc60kzzy7964fxarwh3yldrs1xmhwmnmai7z813j3"; + libraryHaskellDepends = [ base bytestring ]; + testHaskellDepends = [ + base base16-bytestring bytestring hlint QuickCheck tasty + tasty-quickcheck + ]; + benchmarkHaskellDepends = [ base bytestring criterion ]; + description = "A library providing BLAKE2"; + license = lib.licenses.unlicense; + hydraPlatforms = lib.platforms.none; + }) {}; + "blake3" = callPackage ({ mkDerivation, base, memory, tasty, tasty-hunit }: mkDerivation { @@ -46918,8 +46524,8 @@ self: { pname = "blank-canvas"; version = "0.7.3"; sha256 = "1g10959ly5nv2xfhax4pamzxnxkqbniahplc5za8k5r4nq1vjrm2"; - revision = "12"; - editedCabalFile = "0jngs4gbqkraxqkziyb9jw4mf3dcj62nwh0gnf8dbpb2dsp3qnyn"; + revision = "14"; + editedCabalFile = "0gh51aadihnssbqs146l10vajbgkj92cb0wfi1kjrlyknljy39rg"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson base base-compat-batteries base64-bytestring bytestring @@ -47177,8 +46783,8 @@ self: { pname = "blaze-html"; version = "0.9.1.2"; sha256 = "0k1r1hddjgqighazcazxrx6xfhvy2gm8il8l82ainv3cai13yl30"; - revision = "2"; - editedCabalFile = "1hjxvz62wlg0x7svc51zascgc96f5ly9xkkiyllgb4aqcvx9zf3l"; + revision = "3"; + editedCabalFile = "1ra30mpah5k275cb4h9bin80z0nhlkdr7imq7yapl8g399wl11av"; libraryHaskellDepends = [ base blaze-builder blaze-markup bytestring text ]; @@ -47280,8 +46886,8 @@ self: { pname = "blaze-markup"; version = "0.8.2.8"; sha256 = "0jd30wg5yz0a97b36zwqg4hv8faifza1n2gys3l1p3fwf9l3zz23"; - revision = "4"; - editedCabalFile = "1vlyk6nw2i9bbrvzdq42cd2583lfc8i9rcgmqcvdz5rkp47hbzm8"; + revision = "5"; + editedCabalFile = "17ibcxcv51a1xc1cvvwzfvih3v42f4z4j6ipk944im2lgqvjcwfl"; libraryHaskellDepends = [ base blaze-builder bytestring text ]; testHaskellDepends = [ base blaze-builder bytestring containers HUnit QuickCheck tasty @@ -47575,6 +47181,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "blockfrost.io basic client"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.sorki ]; }) {}; @@ -47597,6 +47204,7 @@ self: { ]; description = "blockfrost.io common client definitions / instances"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "blockfrost-pretty" = callPackage @@ -48002,30 +47610,6 @@ self: { }) {}; "bm" = callPackage - ({ mkDerivation, aeson, ansi-wl-pprint, base, directory, dlist - , filepath, network-uri, optparse-applicative, scientific, tasty - , tasty-hunit, text, transformers, typed-process, vector, yaml - }: - mkDerivation { - pname = "bm"; - version = "0.1.1.0"; - sha256 = "0w8zqf01c4rzqsbh6bsjxqqh8j2mlh5i3iiba4m529kd3m6sxjp5"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base dlist network-uri scientific text transformers vector - ]; - executableHaskellDepends = [ - ansi-wl-pprint base directory filepath optparse-applicative - typed-process yaml - ]; - testHaskellDepends = [ base tasty tasty-hunit vector ]; - description = "open bookmarks and queries from the command line"; - license = lib.licenses.mit; - mainProgram = "bm"; - }) {}; - - "bm_0_2_0_0" = callPackage ({ mkDerivation, aeson, ansi-wl-pprint, base, directory, dlist , filepath, network-uri, optparse-applicative, scientific, tasty , tasty-hunit, text, transformers, typed-process, vector, yaml @@ -48034,6 +47618,8 @@ self: { pname = "bm"; version = "0.2.0.0"; sha256 = "17dnv1vdsh43nc8b0p92d01nz1zvxd9bfcghlz0w6c8wc5yflg31"; + revision = "1"; + editedCabalFile = "1fz82dk7hmpnwf0s2z1xcs9l2fm4gcqz35m9v15f4lmyd967l8bv"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -48046,7 +47632,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit vector ]; description = "open bookmarks and queries from the command line"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "bm"; }) {}; @@ -48482,6 +48067,8 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "A module for bookkeeping by double entry"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bookkeeping-jp" = callPackage @@ -48498,6 +48085,7 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "Helper functions for Japanese bookkeeping"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "bool-extras" = callPackage @@ -49069,6 +48657,8 @@ self: { testHaskellDepends = [ base hspec ]; description = "A lightweight implementation of 'bound'"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bounded-array" = callPackage @@ -49082,6 +48672,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 @@ -49197,6 +48789,25 @@ self: { broken = true; }) {}; + "box_0_9_2_0" = callPackage + ({ mkDerivation, async, base, bytestring, containers, contravariant + , dlist, exceptions, kan-extensions, mtl, profunctors + , semigroupoids, stm, text, time + }: + mkDerivation { + pname = "box"; + version = "0.9.2.0"; + sha256 = "1gwxbhi6w4h7p1ccd7s8ay78dabg3zj129wl0bhsmn0i6axb0yik"; + libraryHaskellDepends = [ + async base bytestring containers contravariant dlist exceptions + kan-extensions mtl profunctors semigroupoids stm text time + ]; + description = "A profunctor effect system"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "box-csv" = callPackage ({ mkDerivation, attoparsec, base, box, text, time }: mkDerivation { @@ -49239,6 +48850,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "A hack to use GHC.Prim primitives in GHCi"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "boxes" = callPackage @@ -49393,10 +49006,8 @@ self: { }: mkDerivation { pname = "brassica"; - version = "0.0.3"; - sha256 = "1anqswy00v2kg3l5n9m5cydpbhar7jqlj5ixki8k99ids0w1fws9"; - revision = "1"; - editedCabalFile = "0avv063fz3l71j241fvlvf26gv78n02fb6w61vd31aial073bwdc"; + version = "0.1.0"; + sha256 = "1hknckbcx5k2iiwv076kkmw9d86v9g8yvz3cp6sxny7yik88h0n0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -49533,32 +49144,6 @@ self: { }) {}; "brick" = callPackage - ({ mkDerivation, base, bimap, bytestring, config-ini, containers - , contravariant, data-clist, deepseq, directory, exceptions - , filepath, microlens, microlens-mtl, microlens-th, mtl, QuickCheck - , stm, template-haskell, text, text-zipper, unix, vector, vty - , word-wrap - }: - mkDerivation { - pname = "brick"; - version = "1.4"; - sha256 = "12gwwqq38x0k6hjcn72dpcdwi0lrvyy8gxmp884h22l73xa4vda6"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bimap bytestring config-ini containers contravariant - data-clist deepseq directory exceptions filepath microlens - microlens-mtl microlens-th mtl stm template-haskell text - text-zipper unix vector vty word-wrap - ]; - testHaskellDepends = [ - base containers microlens QuickCheck vector vty - ]; - description = "A declarative terminal user interface library"; - license = lib.licenses.bsd3; - }) {}; - - "brick_1_9" = callPackage ({ mkDerivation, base, bimap, bytestring, config-ini, containers , data-clist, deepseq, directory, exceptions, filepath, microlens , microlens-mtl, microlens-th, mtl, QuickCheck, stm @@ -49580,7 +49165,6 @@ self: { ]; description = "A declarative terminal user interface library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "brick-dropdownmenu" = callPackage @@ -49672,7 +49256,9 @@ self: { testHaskellDepends = [ base ]; description = "Panes library for Brick providing composition and isolation for TUI apps"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; mainProgram = "mywork-example"; + broken = true; }) {}; "brick-skylighting_0_3" = callPackage @@ -50136,8 +49722,8 @@ self: { pname = "brotli"; version = "0.0.0.1"; sha256 = "0fp8vhqzl6i1vvb4fw4zya6cgkzmj0yaaw94jdf2kggm3gn8zwfc"; - revision = "1"; - editedCabalFile = "1mp8fcczfaxk2rfmaakxyrc0w9cwglj1dv9fifl3spvp6g8zcr1n"; + revision = "2"; + editedCabalFile = "1qil5gibl2bgjf1jj54nvj9h5rrajkqwdazgl38z56v3dgsqdvaz"; libraryHaskellDepends = [ base bytestring transformers ]; libraryPkgconfigDepends = [ brotli ]; testHaskellDepends = [ @@ -50178,8 +49764,8 @@ self: { pname = "brotli-streams"; version = "0.0.0.0"; sha256 = "14jc1nhm50razsl99d95amdf4njf75dnzx8vqkihgrgp7qisyz3z"; - revision = "6"; - editedCabalFile = "01w72wyvfyf8d5wb88ds1m8mrk7xik8y4kzj1025jxh45li2w4dr"; + revision = "7"; + editedCabalFile = "142p3ni8ns9nrq58aavnggpspn8phszpgxwzmalyh34692cr8kd4"; libraryHaskellDepends = [ base brotli bytestring io-streams ]; testHaskellDepends = [ base bytestring HUnit io-streams QuickCheck test-framework @@ -50449,8 +50035,8 @@ self: { ({ mkDerivation, base, bytestring, time, unix }: mkDerivation { pname = "btrfs"; - version = "0.2.0.0"; - sha256 = "1h56yb4a3i1c452splxj06c8harrcws2pg86rx7jz6b804ncrzr2"; + version = "0.2.1.0"; + sha256 = "16w62f52l8szncbn484z3rp163ih8gjysw9n9vbxp5r4169jh7pq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base bytestring time unix ]; @@ -50720,8 +50306,8 @@ self: { }: mkDerivation { pname = "bugsnag-hs"; - version = "0.2.0.9"; - sha256 = "0af7xgjcgv5wly2hq0n82paa4qi35xv726y3f44zcvipjh8c4zvq"; + version = "0.2.0.11"; + sha256 = "0xdl77nm1lzj4lyxd6s86v8whxls3a9rsgck4b188sgcv6bvcad6"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson base bytestring http-client text time unordered-containers @@ -51362,17 +50948,17 @@ self: { }) {}; "bv-little" = callPackage - ({ mkDerivation, base, criterion, deepseq, hashable, integer-gmp - , keys, mono-traversable, mono-traversable-keys, primitive - , QuickCheck, smallcheck, tasty, tasty-hunit, tasty-quickcheck - , tasty-smallcheck, text-show + ({ mkDerivation, base, binary, criterion, deepseq, hashable + , integer-gmp, keys, mono-traversable, mono-traversable-keys + , primitive, QuickCheck, smallcheck, tasty, tasty-hunit + , tasty-quickcheck, tasty-smallcheck, text-show }: mkDerivation { pname = "bv-little"; - version = "1.1.1"; - sha256 = "034riqlgkccyl5lvc593v3dyszvqy2vqikk80qm6lw30pkmbcdnr"; + version = "1.3.1"; + sha256 = "1ffsmfldgmyln6h6xmfs2cvb57l8yrz9243aywpa5wziaarqc5sm"; libraryHaskellDepends = [ - base deepseq hashable integer-gmp keys mono-traversable + base binary deepseq hashable integer-gmp keys mono-traversable mono-traversable-keys primitive QuickCheck text-show ]; testHaskellDepends = [ @@ -51382,8 +50968,10 @@ self: { ]; benchmarkHaskellDepends = [ base criterion deepseq hashable mono-traversable QuickCheck - smallcheck + smallcheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck + text-show ]; + doHaddock = false; description = "Efficient little-endian bit vector library"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -51547,6 +51135,8 @@ self: { pname = "bytebuild"; version = "0.3.13.0"; sha256 = "0qfxsff6823k4fm3vy50fw00f7p85lnc35kkazfn9h8prw2ac3k9"; + revision = "1"; + editedCabalFile = "07w11wgvv1k4w4dsy54s9yq9wi5i1pic8hps067jc8yism1mfqn8"; libraryHaskellDepends = [ base byteslice bytestring haskell-src-meta integer-logarithms natural-arithmetic primitive primitive-offset primitive-unlifted @@ -51565,6 +51155,37 @@ self: { license = lib.licenses.bsd3; }) {}; + "bytebuild_0_3_14_0" = callPackage + ({ mkDerivation, base, byteslice, bytestring, gauge + , haskell-src-meta, integer-logarithms, natural-arithmetic + , primitive, primitive-offset, primitive-unlifted, QuickCheck + , quickcheck-classes, quickcheck-instances, run-st, tasty + , tasty-hunit, tasty-quickcheck, template-haskell, text, text-short + , vector, wide-word, zigzag + }: + mkDerivation { + pname = "bytebuild"; + version = "0.3.14.0"; + sha256 = "0ql3fyd0l4gm3wbziky8r3bgd97kazpqbmiqwhrxvznf201zkhfy"; + libraryHaskellDepends = [ + base byteslice bytestring haskell-src-meta integer-logarithms + natural-arithmetic primitive primitive-offset run-st + template-haskell text text-short wide-word zigzag + ]; + testHaskellDepends = [ + base byteslice bytestring natural-arithmetic primitive + primitive-unlifted QuickCheck quickcheck-classes + quickcheck-instances tasty tasty-hunit tasty-quickcheck text + text-short vector wide-word + ]; + benchmarkHaskellDepends = [ + base byteslice gauge natural-arithmetic primitive text-short + ]; + description = "Build byte arrays"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "bytedump" = callPackage ({ mkDerivation, base, bytestring }: mkDerivation { @@ -51605,6 +51226,34 @@ self: { ]; description = "Universal hashing of bytes"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + + "bytehash_0_1_1_0" = callPackage + ({ mkDerivation, base, byte-order, byteslice, bytesmith, bytestring + , entropy, gauge, hedgehog, primitive, primitive-unlifted, split + , tasty, tasty-hedgehog, tasty-hunit, transformers + , unordered-containers + }: + mkDerivation { + pname = "bytehash"; + version = "0.1.1.0"; + sha256 = "08apq1pv5v42q8k3l1xkgba7c4g61ckbwcpz02d93lzv3qhhbxm1"; + libraryHaskellDepends = [ + base byte-order byteslice bytestring entropy primitive + primitive-unlifted transformers + ]; + testHaskellDepends = [ + base byteslice entropy hedgehog primitive tasty tasty-hedgehog + tasty-hunit + ]; + benchmarkHaskellDepends = [ + base byteslice bytesmith bytestring entropy gauge primitive + primitive-unlifted split unordered-containers + ]; + description = "Universal hashing of bytes"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "bytelog" = callPackage @@ -51621,6 +51270,7 @@ self: { description = "Fast logging"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; }) {}; "byteorder" = callPackage @@ -51666,6 +51316,7 @@ self: { description = "Patch byte-representable data in a bytestream"; license = lib.licenses.mit; platforms = lib.platforms.x86; + hydraPlatforms = lib.platforms.none; mainProgram = "bytepatch"; maintainers = [ lib.maintainers.raehik ]; }) {}; @@ -51679,8 +51330,8 @@ self: { pname = "bytes"; version = "0.17.2"; sha256 = "06kqqk19qjhrwdqi6pyd1lwqfnj2sw3b3s49lc5vr2fmv8gg8mdw"; - revision = "1"; - editedCabalFile = "0frs6ag93kmg2fw3vd686czx8g7h9qmdn1ip6wdk96d94ap0fz9i"; + revision = "2"; + editedCabalFile = "18lgnmvrvg4fgwj6mwds9p708x5vfhsw5v6b1rmdd2x3i0g7z2yf"; libraryHaskellDepends = [ base binary binary-orphans bytestring cereal containers hashable mtl scientific text time transformers transformers-compat @@ -51704,30 +51355,6 @@ self: { }) {}; "byteslice" = callPackage - ({ mkDerivation, base, bytestring, gauge, primitive, primitive-addr - , primitive-unlifted, quickcheck-classes, run-st, tasty - , tasty-hunit, tasty-quickcheck, transformers, tuples, vector - }: - mkDerivation { - pname = "byteslice"; - version = "0.2.7.0"; - sha256 = "1mzqlyh0mswk64irz0sr8fk0v9y9ksb1k1j3g51l9vhhnz0cavhj"; - revision = "1"; - editedCabalFile = "1g5670xillqbfpnsxppfjkvaaff4rjlk6116pc5s1pds0zsnbyy8"; - libraryHaskellDepends = [ - base bytestring primitive primitive-addr primitive-unlifted run-st - tuples vector - ]; - testHaskellDepends = [ - base bytestring primitive quickcheck-classes tasty tasty-hunit - tasty-quickcheck transformers - ]; - benchmarkHaskellDepends = [ base gauge primitive ]; - description = "Slicing managed and unmanaged memory"; - license = lib.licenses.bsd3; - }) {}; - - "byteslice_0_2_10_0" = callPackage ({ mkDerivation, base, bytestring, gauge, primitive, primitive-addr , primitive-unlifted, quickcheck-classes, run-st, tasty , tasty-hunit, tasty-quickcheck, text, text-short, transformers @@ -51737,6 +51364,8 @@ self: { pname = "byteslice"; version = "0.2.10.0"; sha256 = "12jwivxnq67g7if9ndq7yb3m46kldz2m6ywiyyyjs7p1kidm8hc4"; + revision = "2"; + editedCabalFile = "1k5ssfnwfj6qrp4mllxc3masbk51yvqdlmym1pidzmws4d00scch"; libraryHaskellDepends = [ base bytestring primitive primitive-addr primitive-unlifted run-st text text-short tuples vector @@ -51748,7 +51377,6 @@ self: { benchmarkHaskellDepends = [ base gauge primitive ]; description = "Slicing managed and unmanaged memory"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "bytesmith" = callPackage @@ -51777,14 +51405,14 @@ self: { license = lib.licenses.bsd3; }) {}; - "bytestring_0_11_4_0" = callPackage + "bytestring_0_12_0_0" = callPackage ({ mkDerivation, base, deepseq, ghc-prim, QuickCheck, random, tasty , tasty-bench, tasty-quickcheck, template-haskell, transformers }: mkDerivation { pname = "bytestring"; - version = "0.11.4.0"; - sha256 = "1lvnjnrsnwbyn5day55fkhzrwggjrabz1rvaq833lsawcbvsw6j9"; + version = "0.12.0.0"; + sha256 = "0lzyz5bjb8f9m64bs5w196vvmhaydwq9ygfrsl4xx1lmi8lq99b5"; libraryHaskellDepends = [ base deepseq ghc-prim template-haskell ]; testHaskellDepends = [ base deepseq ghc-prim QuickCheck tasty tasty-quickcheck @@ -51895,6 +51523,8 @@ self: { ]; description = "Type-classes to convert values to and from ByteString"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "bytestring-csv" = callPackage @@ -52568,6 +52198,20 @@ self: { license = lib.licenses.mit; }) {inherit (pkgs) libxml2;}; + "c14n_0_1_0_3" = callPackage + ({ mkDerivation, base, bytestring, libxml2 }: + mkDerivation { + pname = "c14n"; + version = "0.1.0.3"; + sha256 = "1az81fzblbp2c811grz4l318p99w1xd1kn0cirf9hfgbgdbrfkx8"; + libraryHaskellDepends = [ base bytestring ]; + librarySystemDepends = [ libxml2 ]; + libraryPkgconfigDepends = [ libxml2 ]; + description = "Bindings to the c14n implementation in libxml"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {inherit (pkgs) libxml2;}; + "c2ats" = callPackage ({ mkDerivation, base, containers, HUnit, language-c, pretty , regex-posix, test-framework, test-framework-hunit @@ -52684,6 +52328,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Manipulate patterns in cellular automata, create and parse RLE files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ca-province-codes" = callPackage @@ -52743,17 +52389,6 @@ self: { }) {youProbablyWantCapitalCabal = null;}; "cabal-appimage" = callPackage - ({ mkDerivation, base, Cabal, filepath }: - mkDerivation { - pname = "cabal-appimage"; - version = "0.3.0.5"; - sha256 = "1kc038ig8a3pl71fa8415ycwhm3amy9q30cfr17vlbhjh2lcfz2y"; - libraryHaskellDepends = [ base Cabal filepath ]; - description = "Cabal support for creating AppImage applications"; - license = lib.licenses.agpl3Only; - }) {}; - - "cabal-appimage_0_4_0_1" = callPackage ({ mkDerivation, base, Cabal, filepath }: mkDerivation { pname = "cabal-appimage"; @@ -52762,7 +52397,6 @@ self: { libraryHaskellDepends = [ base Cabal filepath ]; description = "Cabal support for creating AppImage applications"; license = lib.licenses.agpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "cabal-audit" = callPackage @@ -53002,7 +52636,9 @@ self: { executableHaskellDepends = [ base Cabal debian lens mtl pretty ]; description = "Create a Debianization for a Cabal package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "cabal-debian"; + broken = true; }) {}; "cabal-dependency-licenses" = callPackage @@ -53162,6 +52798,8 @@ self: { pname = "cabal-flatpak"; version = "0.1.0.4"; sha256 = "0whdqki7jm7b2km9b8rc8gdi2ciw2ajkxsay3lspky519xzhmy59"; + revision = "1"; + editedCabalFile = "0p7n2ylb2vlyg4vl4qdksiqasq76mc66pxl6vka9m20hdvfkr76v"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -53172,6 +52810,7 @@ self: { ]; description = "Generate a FlatPak manifest from a Cabal package description"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "cabal-flatpak"; maintainers = [ lib.maintainers.thielema ]; }) {}; @@ -53314,7 +52953,9 @@ self: { testToolDepends = [ hoogle tasty-discover ]; description = "generate hoogle database for cabal project and dependencies"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "cabal-hoogle"; + broken = true; }) {}; "cabal-info" = callPackage @@ -53489,6 +53130,28 @@ self: { }) {}; "cabal-install-solver" = callPackage + ({ mkDerivation, array, base, bytestring, Cabal, Cabal-syntax + , containers, edit-distance, filepath, mtl, pretty, tasty + , tasty-hunit, tasty-quickcheck, transformers + }: + mkDerivation { + pname = "cabal-install-solver"; + version = "3.8.1.0"; + sha256 = "1rzzi3jx5ivxy43vdg460fsbn1p2v5br1havcara65vmqgv6j8yz"; + revision = "1"; + editedCabalFile = "1g487j20pj03pc10yaha18v73wh3ackxjgfpfqaj7xznqcbm5xwm"; + libraryHaskellDepends = [ + array base bytestring Cabal Cabal-syntax containers edit-distance + filepath mtl pretty transformers + ]; + testHaskellDepends = [ + base Cabal Cabal-syntax tasty tasty-hunit tasty-quickcheck + ]; + description = "The command-line interface for Cabal and Hackage"; + license = lib.licenses.bsd3; + }) {}; + + "cabal-install-solver_3_10_1_0" = callPackage ({ mkDerivation, array, base, bytestring, Cabal, Cabal-syntax , containers, edit-distance, filepath, mtl, pretty, tasty , tasty-hunit, tasty-quickcheck, transformers @@ -53508,6 +53171,7 @@ self: { ]; description = "The command-line interface for Cabal and Hackage"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cabal-lenses" = callPackage @@ -53623,8 +53287,8 @@ self: { ({ mkDerivation, base, Cabal, lens, process }: mkDerivation { pname = "cabal-pkg-config-version-hook"; - version = "0.1.0.0"; - sha256 = "0v4fajrcbwdj05srma9g3fw96z91j9b5c5cws59sh54a7jb5nlm6"; + version = "0.1.0.1"; + sha256 = "1r02b2gbj9ph85pkz6l0hs7r85zvvbawnh27hnxmdl2j9z29kzqi"; libraryHaskellDepends = [ base Cabal lens process ]; description = "Make Cabal aware of pkg-config package versions"; license = lib.licenses.bsd3; @@ -53632,34 +53296,6 @@ self: { }) {}; "cabal-plan" = callPackage - ({ mkDerivation, aeson, ansi-terminal, async, base, base-compat - , base16-bytestring, bytestring, containers, directory, filepath - , mtl, optics-core, optparse-applicative, parsec, process - , semialign, singleton-bool, text, these, topograph, transformers - , vector - }: - mkDerivation { - pname = "cabal-plan"; - version = "0.7.2.3"; - sha256 = "0zrk1hai7j0kk7l3nv1ca6srzz36dv1rmvzw7zby945nam7030k2"; - configureFlags = [ "-fexe" ]; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base base16-bytestring bytestring containers directory - filepath text - ]; - executableHaskellDepends = [ - ansi-terminal async base base-compat bytestring containers - directory mtl optics-core optparse-applicative parsec process - semialign singleton-bool text these topograph transformers vector - ]; - description = "Library and utility for processing cabal's plan.json file"; - license = lib.licenses.gpl2Plus; - mainProgram = "cabal-plan"; - }) {}; - - "cabal-plan_0_7_3_0" = callPackage ({ mkDerivation, aeson, ansi-terminal, async, base, base-compat , base16-bytestring, bytestring, containers, directory, filepath , mtl, optics-core, optparse-applicative, parsec, process @@ -53670,6 +53306,8 @@ self: { pname = "cabal-plan"; version = "0.7.3.0"; sha256 = "0rjyf5dh13kqwjr520i4w1g7y37nv4rn7vbpkgcjf5qi9f2m9p6c"; + revision = "2"; + editedCabalFile = "13y7ypl763wirrd2i5az9dcgw69vnrd7nb7xd6v3bcrxwj9snams"; configureFlags = [ "-fexe" ]; isLibrary = true; isExecutable = true; @@ -53686,6 +53324,7 @@ self: { license = lib.licenses.gpl2Plus; hydraPlatforms = lib.platforms.none; mainProgram = "cabal-plan"; + broken = true; }) {}; "cabal-plan-bounds" = callPackage @@ -53743,30 +53382,6 @@ self: { }) {}; "cabal-rpm" = callPackage - ({ mkDerivation, base, bytestring, Cabal, directory, extra - , filepath, http-client, http-client-tls, http-conduit - , optparse-applicative, process, simple-cabal, simple-cmd - , simple-cmd-args, time, unix - }: - mkDerivation { - pname = "cabal-rpm"; - version = "2.0.11.1"; - sha256 = "07a2jnzldyva1smbxxdknimzydj2rhr7whhgh5q4nwkifkiliadv"; - revision = "1"; - editedCabalFile = "1dq6c9f0nm7a8nknc2haq79zkpkh1dgrkn2bixzsd16kmjjsl83m"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - base bytestring Cabal directory extra filepath http-client - http-client-tls http-conduit optparse-applicative process - simple-cabal simple-cmd simple-cmd-args time unix - ]; - description = "RPM packaging tool for Haskell Cabal-based packages"; - license = lib.licenses.gpl3Only; - mainProgram = "cabal-rpm"; - }) {}; - - "cabal-rpm_2_1_1" = callPackage ({ mkDerivation, base, bytestring, Cabal, directory, extra , filepath, http-client, http-client-tls, http-conduit , optparse-applicative, process, simple-cabal, simple-cmd @@ -53787,7 +53402,6 @@ self: { ]; description = "RPM packaging tool for Haskell Cabal-based packages"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "cabal-rpm"; }) {}; @@ -54135,29 +53749,6 @@ self: { }) {}; "cabal2spec" = callPackage - ({ mkDerivation, base, Cabal, filepath, optparse-applicative, tasty - , tasty-golden, time - }: - mkDerivation { - pname = "cabal2spec"; - version = "2.6.3"; - sha256 = "1mxqllc6mbxbyr5iz6qs0sxmvzrn5jf9wbs6zqnlygg23ml043kr"; - revision = "1"; - editedCabalFile = "0njnhrm2mm2nrn5y95fqw3s5r1md64f6d1k1zql9ppl102qgrbfp"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base Cabal filepath time ]; - executableHaskellDepends = [ - base Cabal filepath optparse-applicative - ]; - testHaskellDepends = [ base Cabal filepath tasty tasty-golden ]; - description = "Convert Cabal files into rpm spec files"; - license = lib.licenses.gpl3Only; - mainProgram = "cabal2spec"; - maintainers = [ lib.maintainers.peti ]; - }) {}; - - "cabal2spec_2_7_0" = callPackage ({ mkDerivation, base, Cabal, filepath, optparse-applicative, tasty , tasty-golden, time }: @@ -54174,7 +53765,6 @@ self: { testHaskellDepends = [ base Cabal filepath tasty tasty-golden ]; description = "Convert Cabal files into rpm spec files"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "cabal2spec"; maintainers = [ lib.maintainers.peti ]; }) {}; @@ -54402,6 +53992,8 @@ self: { pname = "cached-io"; version = "1.2.0.0"; sha256 = "066ccn6vgrf5s8blqk2wdmm5lkk8rjf4p43ng1i5nhd16z71kc1a"; + revision = "1"; + editedCabalFile = "0yqw087ml8cy9dsn9fl2r6lqrch6cbxy2wxkpsg5kiv4gvacb5zp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base exceptions stm time transformers ]; @@ -54531,11 +54123,12 @@ self: { }) {inherit (pkgs) nix;}; "cachix" = callPackage - ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring - , cachix-api, concurrent-extra, conduit, conduit-concurrent-map - , conduit-extra, conduit-zstd, containers, cookie, cryptonite - , deepseq, dhall, directory, ed25519, either, extra, filepath - , fsnotify, hercules-ci-cnix-store, here, hnix-store-core, hspec + ({ mkDerivation, aeson, ascii-progress, async, base + , base64-bytestring, bytestring, cachix-api, concurrent-extra + , conduit, conduit-concurrent-map, conduit-extra, conduit-zstd + , containers, cookie, cryptonite, deepseq, dhall, directory + , ed25519, either, extra, filepath, fsnotify + , hercules-ci-cnix-store, here, hnix-store-core, hspec , hspec-discover, http-client, http-client-tls, http-conduit , http-types, inline-c-cpp, katip, lukko, lzma-conduit, megaparsec , memory, mmorph, netrc, network-uri, nix, optparse-applicative @@ -54548,23 +54141,24 @@ self: { }: mkDerivation { pname = "cachix"; - version = "1.5"; - sha256 = "1ync5hbyr4yyiv6513f57am8n8985sn3pd860cs4jp9rvc6w7am9"; + version = "1.6"; + sha256 = "0p47zrm7v474bzrxj24dfcf9y22bs6yvdjravzc9n79skidd3bv6"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson async base base64-bytestring bytestring cachix-api - concurrent-extra conduit conduit-concurrent-map conduit-extra - conduit-zstd containers cookie cryptonite deepseq dhall directory - ed25519 either extra filepath fsnotify hercules-ci-cnix-store here - hnix-store-core http-client http-client-tls http-conduit http-types - inline-c-cpp katip lukko lzma-conduit megaparsec memory mmorph - netrc network-uri optparse-applicative pretty-terminal - prettyprinter process protolude resourcet retry safe-exceptions - servant servant-auth servant-auth-client servant-client - servant-client-core servant-conduit stm stm-chans stm-conduit - systemd temporary text time unix unordered-containers - uri-bytestring uuid vector versions websockets wuss + aeson ascii-progress async base base64-bytestring bytestring + cachix-api concurrent-extra conduit conduit-concurrent-map + conduit-extra conduit-zstd containers cookie cryptonite deepseq + dhall directory ed25519 either extra filepath fsnotify + hercules-ci-cnix-store here hnix-store-core http-client + http-client-tls http-conduit http-types inline-c-cpp katip lukko + lzma-conduit megaparsec memory mmorph netrc network-uri + optparse-applicative pretty-terminal prettyprinter process + protolude resourcet retry safe-exceptions servant servant-auth + servant-auth-client servant-client servant-client-core + servant-conduit stm stm-chans stm-conduit systemd temporary text + time unix unordered-containers uri-bytestring uuid vector versions + websockets wuss ]; libraryPkgconfigDepends = [ nix ]; executableHaskellDepends = [ @@ -54593,8 +54187,8 @@ self: { }: mkDerivation { pname = "cachix-api"; - version = "1.5"; - sha256 = "14gy5lhd7q72ypx8fngvqxjgpy58v7wl7gkivwq851lzyn3fxfdq"; + version = "1.6"; + sha256 = "0yca7xrxhxlgx3y0w4k2mwrzgg72wz6iq5bppxaa4f70538ckp57"; libraryHaskellDepends = [ aeson async base base16-bytestring bytestring conduit cookie cryptonite deepseq deriving-aeson exceptions http-api-data @@ -54906,31 +54500,33 @@ self: { "calamity" = callPackage ({ mkDerivation, aeson, aeson-optics, async, base, bytestring - , calamity-commands, colour, concurrent-extra, connection - , containers, data-default-class, data-flags, deepseq, deque, df1 - , di-core, di-polysemy, exceptions, focus, hashable, http-api-data - , http-client, http-date, http-types, megaparsec, mime-types, mtl - , optics, polysemy, polysemy-plugin, random, reflection, req - , safe-exceptions, scientific, stm, stm-chans, stm-containers, text - , text-show, time, tls, typerep-map, unagi-chan, unboxing-vector - , unordered-containers, vector, websockets, x509-system + , calamity-commands, colour, concurrent-extra, containers + , crypton-connection, crypton-x509-system, data-default-class + , data-flags, deepseq, deque, df1, di-core, di-polysemy, exceptions + , focus, hashable, http-api-data, http-client, http-date + , http-types, megaparsec, mime-types, mtl, optics, polysemy + , polysemy-plugin, random, reflection, req, safe-exceptions + , scientific, stm, stm-chans, stm-containers, text, text-show, time + , tls, typerep-map, unagi-chan, unboxing-vector + , unordered-containers, vector, websockets }: mkDerivation { pname = "calamity"; - version = "0.8.0.0"; - sha256 = "0gr9r9q5l1c1sn5j6dg9mxcp8pjh6cvz1l9ncvi4xvia6irxlyya"; + version = "0.10.0.0"; + sha256 = "1g4wf788xhqqsyg69ish0za5jzfvjmy86npaj59pbpf37y6k4zkh"; libraryHaskellDepends = [ aeson aeson-optics async base bytestring calamity-commands colour - concurrent-extra connection containers data-default-class - data-flags deepseq deque df1 di-core di-polysemy exceptions focus - hashable http-api-data http-client http-date http-types megaparsec - mime-types mtl optics polysemy polysemy-plugin random reflection - req safe-exceptions scientific stm stm-chans stm-containers text - text-show time tls typerep-map unagi-chan unboxing-vector - unordered-containers vector websockets x509-system + concurrent-extra containers crypton-connection crypton-x509-system + data-default-class data-flags deepseq deque df1 di-core di-polysemy + exceptions focus hashable http-api-data http-client http-date + http-types megaparsec mime-types mtl optics polysemy + polysemy-plugin random reflection req safe-exceptions scientific + stm stm-chans stm-containers text text-show time tls typerep-map + unagi-chan unboxing-vector unordered-containers vector websockets ]; description = "A library for writing discord bots in haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "calamity-commands" = callPackage @@ -55099,6 +54695,8 @@ self: { pname = "call-alloy"; version = "0.4.0.3"; sha256 = "0aabh7a43cyprwywv8622q860ys2i7mlasigbxaklyj558xma59f"; + revision = "1"; + editedCabalFile = "1fq8qi0y39naha72widlqyz9smcd82v6q5wmvymmgvgw5yj93yw6"; enableSeparateDataOutput = true; libraryHaskellDepends = [ async base bytestring containers directory extra filepath mtl @@ -55142,6 +54740,8 @@ self: { pname = "call-plantuml"; version = "0.0.1.2"; sha256 = "1n4b079nj637djar5a7jdmqjr1mk2b4x2r0iipzrf2iwhvcw3mfk"; + revision = "1"; + editedCabalFile = "1ry3v6kdb76kbvcariwly91b9fjw4660m8piqak3xkgv743ybvgb"; enableSeparateDataOutput = true; libraryHaskellDepends = [ async base bytestring filepath process ]; testHaskellDepends = [ @@ -55172,8 +54772,8 @@ self: { }: mkDerivation { pname = "calligraphy"; - version = "0.1.4"; - sha256 = "02rx9paly04213m314wb85kahf8s6yp1d16ykhsm7v6ia79jh13j"; + version = "0.1.6"; + sha256 = "1bsg18vq2cpzhj0lp5pcy73pa93wahaan0nrjgyyqd48szqppn33"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -55623,8 +55223,8 @@ self: { }: mkDerivation { pname = "capnp"; - version = "0.17.0.0"; - sha256 = "0qs914mnka65qlji1jirgyrnr4qb08qb7mkacm9h09713dz91acw"; + version = "0.18.0.0"; + sha256 = "0n21rqsb0j7xjqamzj1igv6m18hxrsxn1y89r4pj2qhpsvza0b12"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -55953,8 +55553,8 @@ self: { pname = "carray"; version = "0.1.6.8"; sha256 = "04qny61gcjblqjrz761wp4bdkxk6zbm31xn6h426iybw9kanf6cg"; - revision = "1"; - editedCabalFile = "04c4xizl2hjrk5fqwxpv1f0rdrrdl4z5vw6kl7cgc22pywkc2hgj"; + revision = "2"; + editedCabalFile = "1gw70a253siym1g40nqskmmr1y8lnbnhz1aqsg5jhlmfavqscwcz"; libraryHaskellDepends = [ array base binary bytestring ix-shapable QuickCheck syb ]; @@ -56318,7 +55918,9 @@ self: { ]; description = "A simplified, faster way to do case-insensitive matching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "readme-example"; + broken = true; }) {}; "cased" = callPackage @@ -56397,8 +55999,8 @@ self: { }: mkDerivation { pname = "casr-logbook"; - version = "0.6.9"; - sha256 = "0ga60asv7i5jdmvbv25s9h7b23p4f4aasmksh6swbxz5fzky7g7g"; + version = "0.6.12"; + sha256 = "1s4v5a22apd7sw8c7ri8sazi1gqjg7p6b8y9j1g8avx5zc1m58f7"; libraryHaskellDepends = [ base containers digit lens lucid text time ]; @@ -56611,8 +56213,8 @@ self: { pname = "cassava"; version = "0.5.3.0"; sha256 = "1gp954w05bj83z4i6isq2qxi1flqwppsgxxrp1f75mrs8cglbj5l"; - revision = "1"; - editedCabalFile = "1lavd2c7w2p2x4i7h35r8kgcgrrlhcql70zk5vgqv5ll04pp0niy"; + revision = "2"; + editedCabalFile = "16aydwrszzf28s1dwf6bkfi815rbmpzq0z4zid5w91davg8annyv"; configureFlags = [ "-f-bytestring--lt-0_10_4" ]; libraryHaskellDepends = [ array attoparsec base bytestring containers deepseq hashable Only @@ -56633,8 +56235,8 @@ self: { }: mkDerivation { pname = "cassava-conduit"; - version = "0.6.2"; - sha256 = "0b4wxh4r3l25kk0ss4b95f0gh9151gi788xzlmb13iqvan03azh4"; + version = "0.6.5"; + sha256 = "0qhyqv0p42p1pkmfrv8sl2mcmmqahrg15yp40ymawp0j997z54v3"; libraryHaskellDepends = [ array base bifunctors bytestring cassava conduit containers mtl text @@ -56746,6 +56348,8 @@ self: { ]; description = "io-streams interface for the cassava CSV library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cassette" = callPackage @@ -57222,7 +56826,9 @@ self: { ]; description = "A tool for manipulating CBOR"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "cbor-tool"; + broken = true; }) {}; "cborg" = callPackage @@ -58023,28 +57629,32 @@ self: { }) {}; "cgrep" = callPackage - ({ mkDerivation, aeson, ansi-terminal, array, async, base - , bytestring, cmdargs, containers, directory, dlist, either - , exceptions, extra, filepath, ghc-prim, mtl, process, regex-base - , regex-pcre, regex-posix, safe, split, stm, stringsearch - , transformers, unicode-show, unix-compat, unordered-containers - , utf8-string, yaml + ({ mkDerivation, aeson, ansi-terminal, array, async, base, bitarray + , bitwise, bytestring, bytestring-strict-builder, cmdargs + , containers, deepseq, directory, dlist, either, exceptions, extra + , filepath, ghc-prim, mmap, monad-loops, mono-traversable, mtl + , posix-paths, process, rawfilepath, regex-base, regex-pcre + , regex-posix, safe, split, stm, stringsearch, text, transformers + , unagi-chan, unicode-show, unix-compat, unordered-containers + , utf8-string, vector, yaml }: mkDerivation { pname = "cgrep"; - version = "6.6.32"; - sha256 = "0d1d81bkqd2wvcls5l1msli42cvcdrp0xy7i3s0yb10kfgd1y0qw"; + version = "8.1.0"; + sha256 = "1apm74iv3z0p5va7fzdcki7w12mph2i30wn8lzi2l8jgnymygjvq"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ - aeson ansi-terminal array async base bytestring cmdargs containers - directory dlist either exceptions extra filepath ghc-prim mtl - process regex-base regex-pcre regex-posix safe split stm - stringsearch transformers unicode-show unix-compat - unordered-containers utf8-string yaml + aeson ansi-terminal array async base bitarray bitwise bytestring + bytestring-strict-builder cmdargs containers deepseq directory + dlist either exceptions extra filepath ghc-prim mmap monad-loops + mono-traversable mtl posix-paths process rawfilepath regex-base + regex-pcre regex-posix safe split stm stringsearch text + transformers unagi-chan unicode-show unix-compat + unordered-containers utf8-string vector yaml ]; description = "Command line tool"; - license = lib.licenses.gpl2Only; + license = lib.licenses.gpl2Plus; mainProgram = "cgrep"; }) {}; @@ -58281,7 +57891,9 @@ self: { ]; description = "Changelog manager for Git projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "changelogged"; + broken = true; }) {}; "chapelure" = callPackage @@ -58449,26 +58061,6 @@ self: { }) {}; "chart-svg" = callPackage - ({ mkDerivation, adjunctions, attoparsec, base, Color, containers - , cubicbezier, foldl, formatn, lucid, mtl, neat-interpolation - , numhask, numhask-array, numhask-space, optics-core, random - , scientific, tagsoup, text, time, transformers - }: - mkDerivation { - pname = "chart-svg"; - version = "0.3.3"; - sha256 = "1zfdjk502wi71app9k73igz38ykrgh75qxm9v9906md2wizfdv63"; - libraryHaskellDepends = [ - adjunctions attoparsec base Color containers cubicbezier foldl - formatn lucid mtl neat-interpolation numhask numhask-array - numhask-space optics-core random scientific tagsoup text time - transformers - ]; - description = "Charting library targetting SVGs"; - license = lib.licenses.bsd3; - }) {}; - - "chart-svg_0_4_0" = callPackage ({ mkDerivation, adjunctions, attoparsec, base, bytestring, Color , containers, cubicbezier, flatparse, foldl, formatn, mtl, numhask , numhask-array, numhask-space, optics-core, random @@ -58610,6 +58202,7 @@ self: { ]; description = "Polykinded Prelude Kernel"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "chatter" = callPackage @@ -58740,7 +58333,9 @@ self: { executableHaskellDepends = [ base blaze-html bytestring text ]; description = "Experimental markdown processor"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "cheapskate"; + broken = true; }) {}; "cheapskate-highlight" = callPackage @@ -58758,6 +58353,7 @@ self: { ]; description = "Code highlighting for cheapskate"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cheapskate-lucid" = callPackage @@ -58771,6 +58367,7 @@ self: { libraryHaskellDepends = [ base blaze-html cheapskate lucid ]; description = "Use cheapskate with Lucid"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cheapskate-terminal" = callPackage @@ -58929,8 +58526,8 @@ self: { }: mkDerivation { pname = "chell"; - version = "0.5.0.1"; - sha256 = "10zpnalrz4riyqbk2bwsdml4b23x3mrn0cg4hmssffsa50yq93gs"; + version = "0.5.0.2"; + sha256 = "1iy1x5pn5y08zsl5f79vfxjm0asi2vy9hrags7jj9s8fh1dh7fxv"; libraryHaskellDepends = [ ansi-terminal base bytestring options patience random template-haskell text transformers @@ -58943,10 +58540,10 @@ self: { ({ mkDerivation, base, chell, HUnit }: mkDerivation { pname = "chell-hunit"; - version = "0.3.0.1"; - sha256 = "01dv6lv4bj1m0sk7v90w5jnlyvir2v969sw8hrif2h3hy9f3pc9v"; + version = "0.3.0.2"; + sha256 = "1ms7dysxl4asw3inm2a91838djgbjxd66gpvlp08573s90hyns9d"; libraryHaskellDepends = [ base chell HUnit ]; - description = "HUnit support for the Chell testing library"; + description = "HUnit support for Chell"; license = lib.licenses.mit; }) {}; @@ -58954,10 +58551,10 @@ self: { ({ mkDerivation, base, chell, QuickCheck, random }: mkDerivation { pname = "chell-quickcheck"; - version = "0.2.5.3"; - sha256 = "1bm2gva5g9y71z2kbnl4dinplvlbisnjqhlcvgf6a9ir7y4r5c0x"; + version = "0.2.5.4"; + sha256 = "046cs6f65s9nrsac6782gw4n61dpgjgz7iv7p8ag6civywj32m4i"; libraryHaskellDepends = [ base chell QuickCheck random ]; - description = "QuickCheck support for the Chell testing library"; + description = "QuickCheck support for Chell"; license = lib.licenses.mit; }) {}; @@ -59753,6 +59350,8 @@ self: { ]; description = "Channel/Arrow based streaming computation library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cicero-api" = callPackage @@ -59777,7 +59376,9 @@ self: { ]; description = "API bindings to IOHK's Cicero job scheduler"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; mainProgram = "cicero-cli"; + broken = true; }) {}; "cielo" = callPackage @@ -59842,6 +59443,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Simple C-like programming language"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cinvoke" = callPackage @@ -60648,8 +60251,8 @@ self: { }: mkDerivation { pname = "clash-ghc"; - version = "1.6.4"; - sha256 = "1m2pjq59glqlz4pprs899q5w117ffprwlvn83szq41rnmxbjfiaq"; + version = "1.6.5"; + sha256 = "0ixnnv4nyir5sjrygdnsvz59yx214bz35cx2lfvx63aws07nm1gl"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -60683,8 +60286,8 @@ self: { }: mkDerivation { pname = "clash-lib"; - version = "1.6.4"; - sha256 = "1hgz8x68hnpizn4jmpb0vw40qigrdf9p25i7zhc97i851riqvqss"; + version = "1.6.5"; + sha256 = "0n7r9448qzvy9l4ggqgk31ac3pbxnbjdmgc5pzx72alijdjpvgh1"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -60723,8 +60326,8 @@ self: { }: mkDerivation { pname = "clash-lib-hedgehog"; - version = "1.6.4"; - sha256 = "0srff7bkx134a3k8wwis4ap2dk2qrjbmbm915xs70y9nc64sd81b"; + version = "1.6.5"; + sha256 = "1hbdqv4zzhhb7dnmn5zcc0c6gh72xkyj5j4r7pcz2scidgvwdw5q"; libraryHaskellDepends = [ base clash-lib containers data-binary-ieee754 fakedata ghc-typelits-knownnat ghc-typelits-natnormalise hedgehog @@ -60765,10 +60368,8 @@ self: { }: mkDerivation { pname = "clash-prelude"; - version = "1.6.4"; - sha256 = "12ic8jcgz3jr4zrgrx06dzd6whlypyyxilrgbja27dcdv02fs6yr"; - revision = "1"; - editedCabalFile = "09ra3gbhghrqlzaanjlvm0qpj05v3ilps62lblzy44n7sxmc5db7"; + version = "1.6.5"; + sha256 = "1iqyrcclzh5pfkckfh81h4kbmagwp7d69f9wdv6vv09p1gki6dx9"; libraryHaskellDepends = [ array arrows base binary bytestring constraints containers data-binary-ieee754 data-default-class deepseq extra ghc-bignum @@ -60789,6 +60390,8 @@ self: { ]; description = "Clash: a functional hardware description language - Prelude library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "clash-prelude-hedgehog" = callPackage @@ -60797,8 +60400,8 @@ self: { }: mkDerivation { pname = "clash-prelude-hedgehog"; - version = "1.6.4"; - sha256 = "0snwl3n5dksc96wq77pa8s58d0z8sxqkrlkzirvqx6w2s1mhz9in"; + version = "1.6.5"; + sha256 = "0z7clyw3s05w9f2yrbwym7q386qql8z48zf9mqhzl6hpy62x3as1"; libraryHaskellDepends = [ base clash-prelude ghc-typelits-knownnat ghc-typelits-natnormalise hedgehog text @@ -61144,6 +60747,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 @@ -61166,6 +60770,7 @@ self: { ]; description = "a command-line interface for adminstrating some aspects of clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "clckwrks-cli"; }) {}; @@ -61289,6 +60894,7 @@ self: { ]; description = "media plugin for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-page" = callPackage @@ -61314,6 +60920,7 @@ self: { libraryToolDepends = [ hsx2hs ]; description = "support for CMS/Blogging in clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-plugin-redirect" = callPackage @@ -61338,6 +60945,7 @@ self: { ]; description = "support redirects for CMS/Blogging in clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-theme-bootstrap" = callPackage @@ -61355,6 +60963,7 @@ self: { ]; description = "simple bootstrap based template for clckwrks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clckwrks-theme-clckwrks" = callPackage @@ -61457,6 +61066,8 @@ self: { ]; description = "Fast and concise extensible effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "cleff-plugin" = callPackage @@ -61474,6 +61085,7 @@ self: { ]; description = "Automatic disambiguation for extensible effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "clerk" = callPackage @@ -61522,7 +61134,7 @@ self: { "cleveland" = callPackage ({ mkDerivation, aeson, base-noprelude, constraints, containers , criterion, cryptonite, data-default, dependent-map, directory - , exceptions, file-embed, filepath, fmt, hedgehog, hex-text + , exceptions, file-embed, filepath, hedgehog, hex-text , hspec-expectations, HUnit, lens, lorentz, MonadRandom, morley , morley-client, morley-prelude, mtl, o-clock, optparse-applicative , servant-client, servant-client-core, singletons, singletons-base @@ -61532,21 +61144,21 @@ self: { }: mkDerivation { pname = "cleveland"; - version = "0.3.1"; - sha256 = "1prqvn2nci9wblr52zvc9f3ypbwvmf18kbrkzzqcqyid786k53pb"; + version = "0.3.2"; + sha256 = "0j9qgc1vjqqf7w17pr3984ziq1f8qc26qq4s6xrb46sdaqixjyk8"; libraryHaskellDepends = [ aeson base-noprelude constraints containers criterion cryptonite - data-default dependent-map directory exceptions file-embed fmt - hedgehog hex-text HUnit lens lorentz MonadRandom morley - morley-client morley-prelude mtl o-clock optparse-applicative - servant-client-core singletons singletons-base some statistics - tagged tasty tasty-ant-xml tasty-hedgehog tasty-hunit-compat - template-haskell temporary text time with-utf8 + data-default dependent-map directory exceptions file-embed hedgehog + hex-text HUnit lens lorentz MonadRandom morley morley-client + morley-prelude mtl o-clock optparse-applicative servant-client-core + singletons singletons-base some statistics tagged tasty + tasty-ant-xml tasty-hedgehog tasty-hunit-compat template-haskell + temporary text time with-utf8 ]; testHaskellDepends = [ - base-noprelude filepath fmt hedgehog hspec-expectations lens - lorentz morley morley-client morley-prelude o-clock servant-client - tasty tasty-hedgehog tasty-hunit-compat text time + base-noprelude filepath hedgehog hspec-expectations lens lorentz + morley morley-client morley-prelude o-clock servant-client tasty + tasty-hedgehog tasty-hunit-compat text time ]; testToolDepends = [ tasty-discover ]; description = "Testing framework for Morley"; @@ -61658,6 +61270,8 @@ 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 @@ -61790,6 +61404,34 @@ self: { mainProgram = "clientsession-generate"; }) {}; + "clientsession_0_9_2_0" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, cereal + , containers, crypto-api, cryptonite, directory, entropy, hspec + , HUnit, QuickCheck, setenv, skein, tagged, transformers + }: + mkDerivation { + pname = "clientsession"; + version = "0.9.2.0"; + sha256 = "00z577s6z0h3pfd809xwqhm8gbb49a1pm6rramf9n0j7i9pxyqc3"; + revision = "1"; + editedCabalFile = "0j41f5wn7i8crz43na1kqn6kl23lj4pg9gj519f17kr8jc1fdpbx"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base64-bytestring bytestring cereal crypto-api cryptonite + directory entropy setenv skein tagged + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ + base bytestring cereal containers hspec HUnit QuickCheck + transformers + ]; + description = "Securely store session data in a client-side cookie"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + mainProgram = "clientsession-generate"; + }) {}; + "clif" = callPackage ({ mkDerivation, base, containers, QuickCheck, tasty , tasty-quickcheck, tasty-th, time @@ -61885,6 +61527,7 @@ self: { ]; description = "Building blocks for a GHCi-like REPL with colon-commands"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "climb-demo"; }) {}; @@ -62027,7 +61670,9 @@ self: { ]; description = "Clone and benchmark Haskell cabal projects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "cloben"; + broken = true; }) {}; "clock" = callPackage @@ -62043,6 +61688,20 @@ self: { license = lib.licenses.bsd3; }) {}; + "clock_0_8_4" = callPackage + ({ mkDerivation, base, criterion, tasty, tasty-quickcheck }: + mkDerivation { + pname = "clock"; + version = "0.8.4"; + sha256 = "0bnzcx3qmcyvaywzgah9z9cqwbiwib8xbynm9hrmx2kqzs58ksba"; + libraryHaskellDepends = [ base ]; + testHaskellDepends = [ base tasty tasty-quickcheck ]; + benchmarkHaskellDepends = [ base criterion ]; + description = "High-resolution clock functions: monotonic, realtime, cputime"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "clock-extras" = callPackage ({ mkDerivation, base, clock, hspec }: mkDerivation { @@ -62143,6 +61802,8 @@ self: { libraryHaskellDepends = [ base template-haskell ]; description = "Closed type class declarations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "closed-intervals" = callPackage @@ -62160,6 +61821,8 @@ self: { ]; description = "Closed intervals of totally ordered types"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "closure" = callPackage @@ -62252,8 +61915,8 @@ self: { }: mkDerivation { pname = "cloudi"; - version = "2.0.5"; - sha256 = "0ry89sh969p0zhgchnciidacbkjkzs25mfnv07fm740lzzvh5isb"; + version = "2.0.6"; + sha256 = "07231ywvygmkdlyy64lp3ad7m4m4mfymf9swl4j57pgwyg7dp8z5"; libraryHaskellDepends = [ array base binary bytestring containers network time unix zlib ]; @@ -62337,6 +62000,8 @@ self: { testHaskellDepends = [ base ]; description = "Hosting the Common Language Runtime"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) glib; inherit (pkgs) mono;}; "clr-inline" = callPackage @@ -62567,18 +62232,13 @@ self: { }) {}; "cmark" = callPackage - ({ mkDerivation, base, blaze-html, bytestring, cheapskate - , criterion, discount, HUnit, markdown, sundown, text - }: + ({ mkDerivation, base, bytestring, HUnit, text }: mkDerivation { pname = "cmark"; - version = "0.6"; - sha256 = "1p41z6z8dqxk62287lvhhg4ayy9laai9ljh4azsnzb029v6mbv0d"; + version = "0.6.1"; + sha256 = "0ajwb2azv57q4240f76h9xqivkfi16vhi4g2sr4nasr4rmkns789"; libraryHaskellDepends = [ base bytestring text ]; testHaskellDepends = [ base HUnit text ]; - benchmarkHaskellDepends = [ - base blaze-html cheapskate criterion discount markdown sundown text - ]; description = "Fast, accurate CommonMark (Markdown) parser and renderer"; license = lib.licenses.bsd3; }) {}; @@ -63020,6 +62680,7 @@ self: { testHaskellDepends = [ base co-log-core doctest Glob hedgehog ]; description = "Composable Contravariant Comonadic Logging Library"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "co-log-concurrent" = callPackage @@ -63074,6 +62735,8 @@ self: { pname = "co-log-polysemy"; version = "0.0.1.3"; sha256 = "1c6pyfynzd95vxywl7c110nh8z0rzhvfh9hzbq1nn4ik5whqjnbp"; + revision = "1"; + editedCabalFile = "1h35a10zh6xjqjrvj38r9kn49zzvf9lvqrpfgd6vnnsjvyi3jzsx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base co-log-core polysemy ]; @@ -63104,6 +62767,7 @@ self: { ]; description = "A Polysemy logging effect for high quality (unstructured) logs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "example"; }) {}; @@ -63801,6 +63465,7 @@ self: { ]; description = "Equivariant CSM classes of coincident root loci"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "coinor-clp" = callPackage @@ -64274,8 +63939,8 @@ self: { }: mkDerivation { pname = "colour-space"; - version = "0.2.0.0"; - sha256 = "1ca62s0xdhc14jr123bzxpwqjaf8y8nakrm7a52srryr0d3mz7hg"; + version = "0.2.1.0"; + sha256 = "0yqxfwg4y02ys24rcqfsnxf9xqn1v6qnxrvmhpxx34amlaasipvx"; libraryHaskellDepends = [ base call-stack colour constrained-categories JuicyPixels lens linear linearmap-category manifolds manifolds-core QuickCheck @@ -64490,6 +64155,8 @@ self: { ]; description = "Generate and manipulate various combinatorial objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "combinat-compat" = callPackage @@ -64674,8 +64341,8 @@ self: { }: mkDerivation { pname = "comfort-blas"; - version = "0.0"; - sha256 = "0abaza4n7v2lq4pbpxw6208i7aazxg1x59a2yr28dky7ishlq4px"; + version = "0.0.0.1"; + sha256 = "19wfmn6fxl31kd0f4r5gcrpp50k9j735pnbzdw4p16p9p71cqb5k"; libraryHaskellDepends = [ base blas-ffi comfort-array containers deepseq guarded-allocation netlib-ffi transformers utility-ht @@ -64902,8 +64569,8 @@ self: { }: mkDerivation { pname = "commonmark"; - version = "0.2.2"; - sha256 = "0kmjc9xgzy33kxz842mw5rdywip3lmk7v3ambrs87nakawgl42xp"; + version = "0.2.3"; + sha256 = "01fr1227qlajzxbzai7msxgigqfmcc1ydhyr70asdn3wij8dwnkl"; libraryHaskellDepends = [ base bytestring containers parsec text transformers unicode-data unicode-transforms @@ -64967,8 +64634,8 @@ self: { }: mkDerivation { pname = "commonmark-extensions"; - version = "0.2.3.4"; - sha256 = "0pk6ckpb01pr9i2xyx2bm1sbkzbxy5vfy8l67pca1y0i0glyz150"; + version = "0.2.3.5"; + sha256 = "03mpbc66k3h6mm3k46bsn7pkp46ik930prgy6qvqqinzjvwlg207"; libraryHaskellDepends = [ base commonmark containers emojis filepath network-uri parsec text transformers @@ -65402,6 +65069,17 @@ self: { license = lib.licenses.bsd3; }) {}; + "companion" = callPackage + ({ mkDerivation, base, rio }: + mkDerivation { + pname = "companion"; + version = "0.1.0"; + sha256 = "1p8lvjclchvf6igm2f3vqwj2shkyd0yd8ngd3aaj3q5ik7i55h0a"; + libraryHaskellDepends = [ base rio ]; + description = "A Haskell library to provide companion threads"; + license = lib.licenses.bsd3; + }) {}; + "compare-type" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -65551,6 +65229,7 @@ self: { ]; description = "Parse a Pandoc to a composite value"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "compdoc-dhall-decoder" = callPackage @@ -65569,6 +65248,7 @@ self: { ]; description = "Allows you to write FromDhall instances for Compdoc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "compendium-client" = callPackage @@ -65810,6 +65490,7 @@ self: { ]; description = "JSON for Vinyl records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "composite-aeson-cofree-list" = callPackage @@ -65825,6 +65506,7 @@ self: { ]; description = "Print a Cofree [] as a JSON value"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composite-aeson-path" = callPackage @@ -65870,6 +65552,7 @@ self: { ]; description = "MonadThrow behaviour for composite-aeson"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composite-aeson-writeonly" = callPackage @@ -65884,6 +65567,7 @@ self: { ]; description = "WriteOnly indicators for composite-aeson"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composite-base" = callPackage @@ -65907,6 +65591,8 @@ self: { ]; description = "Shared utilities for composite-* packages"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "composite-binary" = callPackage @@ -65918,6 +65604,7 @@ self: { libraryHaskellDepends = [ base binary composite-base ]; description = "Orphan binary instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "composite-cassava" = callPackage @@ -65955,6 +65642,7 @@ self: { ]; description = "Dhall instances for composite records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composite-ekg" = callPackage @@ -65969,6 +65657,7 @@ self: { ]; description = "EKG Metrics for Vinyl records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "composite-hashable" = callPackage @@ -65980,6 +65669,7 @@ self: { libraryHaskellDepends = [ base composite-base hashable ]; description = "Orphan hashable instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "composite-ix" = callPackage @@ -65998,6 +65688,7 @@ self: { ]; description = "Indexing utilities for composite records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "composite-lens-extra" = callPackage @@ -66009,6 +65700,7 @@ self: { libraryHaskellDepends = [ base composite-base lens vinyl ]; description = "Extra lens functions for composite"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composite-opaleye" = callPackage @@ -66031,6 +65723,7 @@ self: { ]; description = "Opaleye SQL for Vinyl records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "composite-swagger" = callPackage @@ -66052,6 +65745,7 @@ self: { ]; description = "Swagger for Vinyl records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "composite-tuple" = callPackage @@ -66065,6 +65759,7 @@ self: { libraryHaskellDepends = [ base composite-base ]; description = "Tuple functions for composite records"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composite-xml" = callPackage @@ -66084,6 +65779,7 @@ self: { ]; description = "RecXML Type"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composite-xstep" = callPackage @@ -66095,6 +65791,7 @@ self: { libraryHaskellDepends = [ base composite-base vinyl ]; description = "ReaderT transformer pattern for higher kinded composite data"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "composition" = callPackage @@ -66876,8 +66573,8 @@ self: { pname = "concurrent-supply"; version = "0.1.8"; sha256 = "07zjczcgxwpi8imp0w86vrb78w067b322q5d7zlqla91sbf2gy6c"; - revision = "1"; - editedCabalFile = "1yzrr68k81w3jmrarx3y6z7ymzaaxwab509pp6kkd2fjia3g8wwk"; + revision = "2"; + editedCabalFile = "0ij8vz3vz2675mwapyzwhywnkkx8p67qq6vqs0c0hrj1659midl0"; libraryHaskellDepends = [ base ghc-prim hashable ]; testHaskellDepends = [ base containers ]; description = "A fast concurrent unique identifier supply with a pure API"; @@ -67611,6 +67308,8 @@ self: { ]; description = "Configuration management library"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "conferer-aeson" = callPackage @@ -67621,8 +67320,8 @@ self: { pname = "conferer-aeson"; version = "1.1.0.2"; sha256 = "07rdal3smq1s14zmsn7g26vc6sqj21rsa2a1vcbrwrfgh9x36jkn"; - revision = "2"; - editedCabalFile = "000fs57llk3f1x0rgdkxzbqzwzh5fx3mirpx0scmnj936byapp4c"; + revision = "3"; + editedCabalFile = "162knmji5970ccdfbh3vz930ljwl4mahpbdj5si5rj2v3aays9ms"; libraryHaskellDepends = [ aeson base bytestring conferer directory text unordered-containers vector @@ -67633,6 +67332,7 @@ self: { ]; description = "conferer's source for reading json files"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "conferer-dhall" = callPackage @@ -67669,6 +67369,7 @@ self: { testHaskellDepends = [ base conferer hedis hspec text ]; description = "conferer's FromConfig instances for hedis settings"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "conferer-hspec" = callPackage @@ -67843,6 +67544,7 @@ self: { ]; description = "conferer's FromConfig instances for warp settings"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "conferer-yaml" = callPackage @@ -67857,6 +67559,7 @@ self: { testHaskellDepends = [ base conferer conferer-aeson hspec yaml ]; description = "Configuration for reading yaml files"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "confetti" = callPackage @@ -67922,10 +67625,8 @@ self: { }: mkDerivation { pname = "config-ini"; - version = "0.2.5.0"; - sha256 = "07vgpydzd44ayhq9c3q1335vphw384z8baf0wd0mnarr48yfaz3g"; - revision = "1"; - editedCabalFile = "1allnxx4dsani79nwq1iyzn6cvqz5cjif7g72kb8r0khfzrqxp5l"; + version = "0.2.6.0"; + sha256 = "0pvsvl3svh7y3pi7kw4fsnl6p92sxl4sa0px26c135klvwsq2a1a"; libraryHaskellDepends = [ base containers megaparsec text transformers unordered-containers ]; @@ -68015,8 +67716,8 @@ self: { pname = "config-value"; version = "0.8.3"; sha256 = "0pkcwxg91wali7986k03d7q940hb078hlsxfknqhkp2spr3d1f3w"; - revision = "2"; - editedCabalFile = "1phsi1a7j307kk2qw6a1l8kps2jicmxv1dc3j8yl9yy0v9q2v6j4"; + revision = "3"; + editedCabalFile = "1qiqaad3zpgvwpcb5p1q9aaska82bfm75qrsfdcdlwc70r7w57gj"; libraryHaskellDepends = [ array base containers pretty text ]; libraryToolDepends = [ alex happy ]; testHaskellDepends = [ base text ]; @@ -68116,6 +67817,40 @@ self: { mainProgram = "example"; }) {}; + "configuration-tools_0_7_0" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base-unicode-symbols + , bytestring, Cabal, case-insensitive, deepseq, directory, dlist + , filepath, mtl, network-uri, optparse-applicative, prettyprinter + , process, profunctors, semigroupoids, semigroups, text + , transformers, unordered-containers, vector, yaml + }: + mkDerivation { + pname = "configuration-tools"; + version = "0.7.0"; + sha256 = "05fbs9ddflys2fdhjzfkg7zblk7a2wi8ghxy003xw3azi9hnryxw"; + isLibrary = true; + isExecutable = true; + setupHaskellDepends = [ + base bytestring Cabal directory filepath process + ]; + libraryHaskellDepends = [ + aeson attoparsec base base-unicode-symbols bytestring Cabal + case-insensitive deepseq directory dlist filepath mtl network-uri + optparse-applicative prettyprinter process profunctors + semigroupoids semigroups text transformers unordered-containers + vector yaml + ]; + executableHaskellDepends = [ base base-unicode-symbols Cabal mtl ]; + testHaskellDepends = [ + base base-unicode-symbols bytestring Cabal mtl text transformers + unordered-containers yaml + ]; + description = "Tools for specifying and parsing configurations"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + mainProgram = "example"; + }) {}; + "configurator" = callPackage ({ mkDerivation, attoparsec, base, bytestring, directory, filepath , hashable, HUnit, test-framework, test-framework-hunit, text @@ -68197,6 +67932,8 @@ self: { ]; description = "Reduced parser for configurator-ng config files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "confsolve" = callPackage @@ -68353,6 +68090,8 @@ self: { ]; description = "Connection pool built on top of resource-pool and streaming-commons"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "connection-string" = callPackage @@ -68462,6 +68201,8 @@ self: { libraryHaskellDepends = [ base bytestring primitive ptrdiff ]; description = "Read-only mutable primitives"; license = "(BSD-2-Clause OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "const-math-ghc-plugin" = callPackage @@ -68751,23 +68492,6 @@ self: { }) {}; "constraints-extras" = callPackage - ({ mkDerivation, aeson, base, constraints, template-haskell }: - mkDerivation { - pname = "constraints-extras"; - version = "0.3.2.1"; - sha256 = "0w2wwqsgxqkn8byivrgcsi6fh1kxbivqarmdnpxyh1a1cg373xfp"; - revision = "1"; - editedCabalFile = "1smha6ljia9bfgdy1h0lkgi9464rwa9lnw7rqfi1c23pzyiw13lh"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base constraints template-haskell ]; - executableHaskellDepends = [ aeson base constraints ]; - description = "Utility package for constraints"; - license = lib.licenses.bsd3; - mainProgram = "readme"; - }) {}; - - "constraints-extras_0_4_0_0" = callPackage ({ mkDerivation, aeson, base, constraints, template-haskell }: mkDerivation { pname = "constraints-extras"; @@ -68781,7 +68505,6 @@ self: { executableHaskellDepends = [ aeson base constraints ]; description = "Utility package for constraints"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "readme"; }) {}; @@ -68820,6 +68543,8 @@ self: { testToolDepends = [ markdown-unlit ]; description = "Haskell version of the Construct library for easy specification of file formats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "constructible" = callPackage @@ -69219,6 +68944,30 @@ self: { license = lib.licenses.bsd3; }) {}; + "contiguous_0_6_4_0" = callPackage + ({ mkDerivation, base, deepseq, primitive, primitive-unlifted + , QuickCheck, quickcheck-classes, quickcheck-instances, random + , random-shuffle, run-st, vector, weigh + }: + mkDerivation { + pname = "contiguous"; + version = "0.6.4.0"; + sha256 = "06s0rx95h2hczs0bp9sqxjmsp84gfzsi6acf088f9p97hw4cvqz9"; + libraryHaskellDepends = [ + base deepseq primitive primitive-unlifted run-st + ]; + testHaskellDepends = [ + base primitive QuickCheck quickcheck-classes quickcheck-instances + vector + ]; + benchmarkHaskellDepends = [ + base primitive random random-shuffle weigh + ]; + description = "Unified interface for primitive arrays"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "contiguous-checked" = callPackage ({ mkDerivation, base, contiguous, primitive }: mkDerivation { @@ -69893,6 +69642,24 @@ self: { license = lib.licenses.mit; }) {}; + "cookie-tray" = callPackage + ({ mkDerivation, base, binary, bytestring, containers, cookie + , hspec, time + }: + mkDerivation { + pname = "cookie-tray"; + version = "0.0.0.0"; + sha256 = "1nzwa8icf84yds9yhnfnb8ys5iib748vciqg0b5cql76wg93pix6"; + libraryHaskellDepends = [ + base binary bytestring containers cookie time + ]; + testHaskellDepends = [ + base binary bytestring containers cookie hspec time + ]; + description = "For serving cookies"; + license = lib.licenses.asl20; + }) {}; + "cookies" = callPackage ({ mkDerivation, base, bytestring, chronos, hashable, text, time }: mkDerivation { @@ -69926,8 +69693,8 @@ self: { }: mkDerivation { pname = "copilot"; - version = "3.15"; - sha256 = "16rdddbrn4k35cx6cpglk2khyhvd1xz758i4q8xfraai5jj077ji"; + version = "3.16"; + sha256 = "119b8bqk3x14wmd9xzk9y3zv6walm982n0bjzc0f64fkjaqgqhsr"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -69941,19 +69708,27 @@ self: { }) {}; "copilot-c99" = callPackage - ({ mkDerivation, base, copilot-core, directory, filepath - , language-c99, language-c99-simple, mtl, pretty + ({ mkDerivation, base, copilot-core, directory, filepath, HUnit + , language-c99, language-c99-simple, mtl, pretty, process + , QuickCheck, random, test-framework, test-framework-hunit + , test-framework-quickcheck2, unix }: mkDerivation { pname = "copilot-c99"; - version = "3.15"; - sha256 = "1iwmyck9k2cb5fgv8f01vqfhabkb6awx1992zyhlczbzx1drwmzw"; + version = "3.16"; + sha256 = "00rh4x9jc5dzrp5k2nhl0203kbyfpdrkn8sqc9fyzfnpw4hvxgjk"; libraryHaskellDepends = [ base copilot-core directory filepath language-c99 language-c99-simple mtl pretty ]; + testHaskellDepends = [ + base copilot-core directory HUnit pretty process QuickCheck random + test-framework test-framework-hunit test-framework-quickcheck2 unix + ]; description = "A compiler for Copilot targeting C99"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "copilot-cbmc" = callPackage @@ -69979,8 +69754,8 @@ self: { }: mkDerivation { pname = "copilot-core"; - version = "3.15"; - sha256 = "0dggd839dwpm71m4kgpns935xygssn59xqizqw5rn3jn2n339lmm"; + version = "3.16"; + sha256 = "0zw2xxf1c9ri0npcxjhb3iws01vnlhbkqjpsyvixvz564lzpiksm"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base HUnit QuickCheck test-framework test-framework-hunit @@ -70014,8 +69789,8 @@ self: { }: mkDerivation { pname = "copilot-interpreter"; - version = "3.15"; - sha256 = "0f0lb59ga3h7mxdxpq68gvl6b5b4nqb3s51in4yahv1qglyncd9j"; + version = "3.16"; + sha256 = "1l512bnkdhldg3qy02pp84c83zd08jc7nfvqqnbsl9a446qwlmic"; libraryHaskellDepends = [ base copilot-core pretty ]; testHaskellDepends = [ base copilot-core copilot-prettyprinter pretty QuickCheck @@ -70033,8 +69808,8 @@ self: { }: mkDerivation { pname = "copilot-language"; - version = "3.15"; - sha256 = "0gq3gasinif4dv8nv10k6309s8674njhfbzffvpzbl8habrapqrq"; + version = "3.16"; + sha256 = "0a0r6pkkpbmjwfqlwgr0f652g8h5764q2vx1crw1j0ilk4j09c0v"; libraryHaskellDepends = [ array base containers copilot-core copilot-interpreter copilot-theorem data-reify mtl @@ -70052,8 +69827,8 @@ self: { ({ mkDerivation, base, containers, copilot-language, mtl, parsec }: mkDerivation { pname = "copilot-libraries"; - version = "3.15"; - sha256 = "124fxgc25y45wbg2ksjhx3rvw7ahpfq18dd81fl1a0491g3hw399"; + version = "3.16"; + sha256 = "14cmc623di13kz223mg07baxi2gwm2pwih7w9kvy2g7j4rbaip5l"; libraryHaskellDepends = [ base containers copilot-language mtl parsec ]; @@ -70066,8 +69841,8 @@ self: { ({ mkDerivation, base, copilot-core, pretty }: mkDerivation { pname = "copilot-prettyprinter"; - version = "3.15"; - sha256 = "1zmza697k6b87279lk3zdn640nfjmr8ma56rln2i4n8yqsrpnriw"; + version = "3.16"; + sha256 = "175vs3wc9igzf6fggb5b9lbvx9za80xng9k7clq28404rn6qn0mw"; libraryHaskellDepends = [ base copilot-core pretty ]; description = "A prettyprinter of Copilot Specifications"; license = lib.licenses.bsd3; @@ -70097,8 +69872,8 @@ self: { }: mkDerivation { pname = "copilot-theorem"; - version = "3.15"; - sha256 = "0pgdphqsv5ksxhhvy1ya30l55slfaz4fffy0y9hkii76s0vdymfv"; + version = "3.16"; + sha256 = "07vb547irkxgxpwzqajkwqacbxmi8az1vnp4fch0hpdhfsmwj4cm"; libraryHaskellDepends = [ base bimap bv-sized containers copilot-core copilot-prettyprinter data-default directory libBF mtl panic parameterized-utils parsec @@ -70269,8 +70044,8 @@ self: { }: mkDerivation { pname = "core-program"; - version = "0.6.8.0"; - sha256 = "1r65a5bbz0clh6by0p56ynwv6c1xia01pap8fmsbcglgzifwxk9w"; + version = "0.6.9.4"; + sha256 = "0pi3jp58rvff714zzazi5qkc7p708wk9xyd22i0vyjwiznnmpnyn"; libraryHaskellDepends = [ base bytestring core-data core-text directory exceptions filepath fsnotify githash hashable hourglass mtl prettyprinter process @@ -70289,8 +70064,8 @@ self: { }: mkDerivation { pname = "core-telemetry"; - version = "0.2.9.3"; - sha256 = "05q5rfsljmpf6v1v7r4gh8niqda6i6jrc2xgh54d7pfwmbqfzcm6"; + version = "0.2.9.4"; + sha256 = "1piawlfvwbcs2v67rzwi21sg12s53dwsszwj6lax8s6fqlrgkb40"; libraryHaskellDepends = [ base bytestring core-data core-program core-text exceptions http-streams io-streams mtl network-info random safe-exceptions @@ -70668,8 +70443,10 @@ self: { }: mkDerivation { pname = "country"; - version = "0.2.3"; - sha256 = "12d1nymfj13jgh5jhznrg8sgxvxyb2y3lvbl6p4mpa3qqhggyr3g"; + version = "0.2.3.1"; + sha256 = "0c601fa2m6f5b9g7i1azh9aqhnsiqcrpqmngwnhrxf8gm4jh5yi5"; + revision = "1"; + editedCabalFile = "1l8ik38d92xrhfd9a6an4i5zcmvqpxicggdihy6hcj1yl1997qsc"; libraryHaskellDepends = [ aeson attoparsec base bytebuild bytehash byteslice bytestring contiguous deepseq entropy hashable primitive primitive-unlifted @@ -70684,9 +70461,10 @@ self: { ]; description = "Country data type and functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; - "country_0_2_3_1" = callPackage + "country_0_2_4_0" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytebuild, bytehash , byteslice, bytestring, compact, contiguous, deepseq, entropy , gauge, hashable, primitive, primitive-unlifted, QuickCheck @@ -70695,10 +70473,8 @@ self: { }: mkDerivation { pname = "country"; - version = "0.2.3.1"; - sha256 = "0c601fa2m6f5b9g7i1azh9aqhnsiqcrpqmngwnhrxf8gm4jh5yi5"; - revision = "1"; - editedCabalFile = "1l8ik38d92xrhfd9a6an4i5zcmvqpxicggdihy6hcj1yl1997qsc"; + version = "0.2.4.0"; + sha256 = "0z6r06f9y5w79sj5r3ifdm9pfz07dqkn39ywdxzpxajnlzsmkka7"; libraryHaskellDepends = [ aeson attoparsec base bytebuild bytehash byteslice bytestring contiguous deepseq entropy hashable primitive primitive-unlifted @@ -70730,6 +70506,8 @@ 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 @@ -70966,6 +70744,8 @@ self: { pname = "cprng-aes"; version = "0.6.1"; sha256 = "1wr15kbmk1g3l8a75n0iwbzqg24ixv78slwzwb2q6rlcvq0jlnb4"; + revision = "1"; + editedCabalFile = "06i4sg7rk60rybw5c5w8fsvmzvcarx2s0cjy1xmyq0771vq52j4n"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base byteable bytestring cipher-aes crypto-random @@ -71371,25 +71151,6 @@ self: { }) {}; "crackNum" = callPackage - ({ mkDerivation, base, directory, filepath, libBF, process, sbv - , tasty, tasty-golden - }: - mkDerivation { - pname = "crackNum"; - version = "3.2"; - sha256 = "1q9isxg65s9bsafqlcwpl82xypra4cxf935wxi5npbxi6dw5w13i"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - base directory filepath libBF process sbv tasty tasty-golden - ]; - description = "Crack various integer and floating-point data formats"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - mainProgram = "crackNum"; - }) {}; - - "crackNum_3_4" = callPackage ({ mkDerivation, base, directory, filepath, libBF, process, sbv , tasty, tasty-golden }: @@ -71670,6 +71431,8 @@ self: { ]; description = "Framework for artificial life experiments"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "credential-store" = callPackage @@ -71872,31 +71635,27 @@ self: { }) {}; "criterion" = callPackage - ({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat - , base-compat-batteries, binary, binary-orphans, bytestring - , cassava, code-page, containers, criterion-measurement, deepseq - , directory, exceptions, filepath, Glob, HUnit, js-chart - , microstache, mtl, mwc-random, optparse-applicative, parsec - , QuickCheck, statistics, tasty, tasty-hunit, tasty-quickcheck - , text, time, transformers, transformers-compat, vector - , vector-algorithms + ({ mkDerivation, aeson, base, base-compat, base-compat-batteries + , binary, binary-orphans, bytestring, cassava, code-page + , containers, criterion-measurement, deepseq, directory, exceptions + , filepath, Glob, HUnit, js-chart, microstache, mtl, mwc-random + , optparse-applicative, parsec, QuickCheck, statistics, tasty + , tasty-hunit, tasty-quickcheck, text, time, transformers + , transformers-compat, vector, vector-algorithms }: mkDerivation { pname = "criterion"; - version = "1.5.13.0"; - sha256 = "19vrlldgw2kz5426j0iwsvvhxkbnrnan859vr6ryqh13nrg59a72"; - revision = "2"; - editedCabalFile = "09s70kqkp1j78idaqrpnz8v870vy6xyclnpz9g4x70cr4r67lqkd"; + version = "1.6.1.0"; + sha256 = "136qrgx0gpjrh5dy3arp0gwk6hnhg4i7pz406xwl1p5cj3acii3r"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; libraryHaskellDepends = [ - aeson ansi-wl-pprint base base-compat-batteries binary - binary-orphans bytestring cassava code-page containers - criterion-measurement deepseq directory exceptions filepath Glob - js-chart microstache mtl mwc-random optparse-applicative parsec - statistics text time transformers transformers-compat vector - vector-algorithms + aeson base base-compat-batteries binary binary-orphans bytestring + cassava code-page containers criterion-measurement deepseq + directory exceptions filepath Glob js-chart microstache mtl + mwc-random optparse-applicative parsec statistics text time + transformers transformers-compat vector vector-algorithms ]; executableHaskellDepends = [ base base-compat-batteries optparse-applicative @@ -71925,6 +71684,8 @@ self: { pname = "criterion"; version = "1.6.2.0"; sha256 = "1yiish22n4x9zh1gl6bf1rnbcimgad87dgkxk663hzc78683q2dm"; + revision = "1"; + editedCabalFile = "164w1p7vnijlmf1cyn5x2i667g3dqf57pf7wwii05av7733wbdns"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -71996,21 +71757,6 @@ self: { }) {}; "criterion-measurement" = callPackage - ({ mkDerivation, aeson, base, base-compat, binary, containers - , deepseq, vector - }: - mkDerivation { - pname = "criterion-measurement"; - version = "0.1.4.0"; - sha256 = "01wrb38z16zjm85p5v1pj1qz4gijj0dl80pgzy5ggmzmfz8ibjrm"; - libraryHaskellDepends = [ - aeson base base-compat binary containers deepseq vector - ]; - description = "Criterion measurement functionality and associated types"; - license = lib.licenses.bsd3; - }) {}; - - "criterion-measurement_0_2_1_0" = callPackage ({ mkDerivation, aeson, base, base-compat, binary, containers , deepseq, ghc-prim, vector }: @@ -72023,7 +71769,6 @@ self: { ]; description = "Criterion measurement functionality and associated types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "criterion-plus" = callPackage @@ -72135,6 +71880,7 @@ self: { description = "An implementation of Douglas Crockford's base32 encoding"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crocodile" = callPackage @@ -72577,8 +72323,8 @@ self: { pname = "crypto-random"; version = "0.0.9"; sha256 = "0139kbbb2h7vshf68y3fvjda29lhj7jjwl4vq78w4y8k8hc7l2hp"; - revision = "1"; - editedCabalFile = "1ax1iafbbqkcrvjnnxlvqh2zgpx8xzcbxl6l870207bpzwrja2f1"; + revision = "2"; + editedCabalFile = "0ixdn7pww1nh1c41qyswqi69xnzlap6kaqayp09f1h4b5l20dj2p"; libraryHaskellDepends = [ base bytestring securemem unix vector ]; description = "Simple cryptographic random related types"; license = lib.licenses.bsd3; @@ -72676,6 +72422,8 @@ self: { pname = "crypto-sodium"; version = "0.0.5.0"; sha256 = "0c1q0kmvglmlvv8z8q8nyjjjy02r41bk32pr1z080x79z612zad5"; + revision = "2"; + editedCabalFile = "18s2gl27ac953v61cgfqmmsbq9y6by5zijq90anwm3k06j2s8rfy"; libraryHaskellDepends = [ base bytestring cereal libsodium memory NaCl random safe-exceptions ]; @@ -72967,27 +72715,30 @@ self: { "cryptol" = callPackage ({ mkDerivation, alex, ansi-terminal, arithmoi, array, async, base , base-compat, blaze-html, bv-sized, bytestring, containers - , criterion, cryptohash-sha1, deepseq, directory, exceptions, extra - , filepath, ghc-bignum, ghc-prim, gitrev, GraphSCC, happy - , haskeline, heredoc, libBF, MemoTrie, monad-control, monadLib, mtl - , optparse-applicative, panic, parameterized-utils, prettyprinter - , process, sbv, simple-smt, stm, strict, temporary, text, tf-random - , time, transformers, transformers-base, what4 + , criterion, criterion-measurement, cryptohash-sha1, deepseq + , directory, exceptions, extra, filepath, ghc-bignum, ghc-prim + , gitrev, GraphSCC, happy, haskeline, heredoc, hgmp, language-c99 + , language-c99-simple, libBF, libffi, MemoTrie, monad-control + , monadLib, mtl, optparse-applicative, panic, parameterized-utils + , pretty, pretty-show, prettyprinter, process, sbv, simple-smt, stm + , strict, temporary, text, tf-random, time, transformers + , transformers-base, unix, vector, what4 }: mkDerivation { pname = "cryptol"; - version = "2.13.0"; - sha256 = "10rbc3sw4r252alz5ql6vn8ddrrwwim8ibdvdn1hdichnb87lnsw"; + version = "3.0.0"; + sha256 = "0kymqn6v2k2v8nyrcbr9kimxjdy6363mxqb1a5vg6w2im3360il4"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; libraryHaskellDepends = [ arithmoi array async base base-compat bv-sized bytestring - containers cryptohash-sha1 deepseq directory exceptions filepath - ghc-bignum ghc-prim gitrev GraphSCC heredoc libBF MemoTrie - monad-control monadLib mtl panic parameterized-utils prettyprinter - process sbv simple-smt stm strict text tf-random time - transformers-base what4 + containers criterion-measurement cryptohash-sha1 deepseq directory + exceptions filepath ghc-bignum ghc-prim gitrev GraphSCC heredoc + hgmp language-c99 language-c99-simple libBF libffi MemoTrie + monad-control monadLib mtl panic parameterized-utils pretty + pretty-show prettyprinter process sbv simple-smt stm strict text + tf-random time transformers-base unix vector what4 ]; libraryToolDepends = [ alex happy ]; executableHaskellDepends = [ @@ -73010,8 +72761,8 @@ self: { }: mkDerivation { pname = "crypton"; - version = "0.31"; - sha256 = "1vjar7nvjc7gbyv0ij0sjlaqkd4nlxibs2asxpb4div844xm20ls"; + version = "0.32"; + sha256 = "13108lxrnlmh3gi828lmqcz42v9id6pr3v9ph288yx2s6zyr0j2l"; libraryHaskellDepends = [ base basement bytestring deepseq ghc-prim integer-gmp memory ]; @@ -73025,6 +72776,29 @@ self: { license = lib.licenses.bsd3; }) {}; + "crypton_0_33" = callPackage + ({ mkDerivation, base, basement, bytestring, deepseq, gauge + , ghc-prim, integer-gmp, memory, random, tasty, tasty-hunit + , tasty-kat, tasty-quickcheck + }: + mkDerivation { + pname = "crypton"; + version = "0.33"; + sha256 = "0805ws7yadwyscr1cm8nh56sj7yk0mplk7yz0n919ziabjks0vz6"; + libraryHaskellDepends = [ + base basement bytestring deepseq ghc-prim integer-gmp memory + ]; + testHaskellDepends = [ + base bytestring memory tasty tasty-hunit tasty-kat tasty-quickcheck + ]; + benchmarkHaskellDepends = [ + base bytestring deepseq gauge memory random + ]; + description = "Cryptography Primitives sink"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "crypton-connection" = callPackage ({ mkDerivation, base, basement, bytestring, containers , crypton-x509, crypton-x509-store, crypton-x509-system @@ -73042,6 +72816,7 @@ self: { description = "Simple and easy network connections API"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "crypton-x509" = callPackage @@ -73065,8 +72840,6 @@ self: { ]; description = "X509 reader and writer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "crypton-x509-store" = callPackage @@ -73087,7 +72860,6 @@ self: { ]; description = "X.509 collection accessing and storing methods"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "crypton-x509-system" = callPackage @@ -73104,7 +72876,6 @@ self: { ]; description = "Handle per-operating-system X.509 accessors and storage"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "crypton-x509-validation" = callPackage @@ -73129,7 +72900,6 @@ self: { ]; description = "X.509 Certificate and CRL validation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "cryptonite" = callPackage @@ -73177,6 +72947,7 @@ self: { ]; description = "Cryptography Primitives sink"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "cryptonite-conduit" = callPackage @@ -73229,8 +73000,8 @@ self: { }: mkDerivation { pname = "cryptostore"; - version = "0.2.3.0"; - sha256 = "1w84klg3r10vapkc8s6q21ldnp3014x9nvi5ffsmzikn7g7pw1g5"; + version = "0.3.0.1"; + sha256 = "0f88shhy9b0yxvifb5jpk2jywqdafz4r1djihwqaia6q6k0mjvi8"; libraryHaskellDepends = [ asn1-encoding asn1-types base basement bytestring cryptonite hourglass memory pem x509 x509-validation @@ -73243,28 +73014,6 @@ self: { license = lib.licenses.bsd3; }) {}; - "cryptostore_0_3_0_0" = callPackage - ({ mkDerivation, asn1-encoding, asn1-types, base, basement - , bytestring, cryptonite, hourglass, memory, pem, tasty - , tasty-hunit, tasty-quickcheck, x509, x509-validation - }: - mkDerivation { - pname = "cryptostore"; - version = "0.3.0.0"; - sha256 = "0s6r7pjdp2jqqxq0b1f1ks23h1dh8hh4vqzbqm8irgvmsz445pwh"; - libraryHaskellDepends = [ - asn1-encoding asn1-types base basement bytestring cryptonite - hourglass memory pem x509 x509-validation - ]; - testHaskellDepends = [ - asn1-types base bytestring cryptonite hourglass memory pem tasty - tasty-hunit tasty-quickcheck x509 - ]; - description = "Serialization of cryptographic data types"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "cryptsy-api" = callPackage ({ mkDerivation, aeson, base, bytestring, deepseq, either , http-client, http-client-tls, old-locale, pipes-attoparsec @@ -73605,6 +73354,8 @@ self: { benchmarkHaskellDepends = [ base criterion mtl text text-builder ]; description = "eDSL for CSS"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "css-syntax" = callPackage @@ -73624,8 +73375,6 @@ self: { ]; description = "High-performance CSS tokenizer and serializer"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "css-text" = callPackage @@ -73881,10 +73630,8 @@ self: { }: mkDerivation { pname = "cubicbezier"; - version = "0.6.0.6"; - sha256 = "0s7s1ak0x89jy3q4yxrcvjzsq9w4yh23ycjcja6i7klj5gggqwss"; - revision = "1"; - editedCabalFile = "084inqa0mpm6m958fmjwsnn2fn46mcdpfin482mzs5fk6c9fwywl"; + version = "0.6.0.7"; + sha256 = "1ra6k29p603idldkc7akb67cvw9npxc9v5ndif2naawcqw65xs72"; libraryHaskellDepends = [ base containers fast-math integration matrices microlens microlens-mtl microlens-th mtl vector vector-space @@ -74164,8 +73911,8 @@ self: { ({ mkDerivation, base, parsec, text }: mkDerivation { pname = "curly-expander"; - version = "0.3.0.1"; - sha256 = "09hhlsya3ibk1v0k487a5dj35p9d838vixfnkzlfai3rmgs5awdz"; + version = "0.3.0.2"; + sha256 = "0ag6yqg260y9hal6kzp3phsfa3rwj6lxd8g6k85x81s2lilxgynx"; libraryHaskellDepends = [ base parsec text ]; testHaskellDepends = [ base parsec text ]; description = "Curly braces (brackets) expanding"; @@ -74184,6 +73931,8 @@ self: { testHaskellDepends = [ base hspec text ]; description = "Currencies representation, pretty printing and conversion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "currency" = callPackage @@ -74408,7 +74157,9 @@ self: { ]; description = "Terminal tool for viewing tabular data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "cursedcsv"; + broken = true; }) {}; "cursor" = callPackage @@ -74652,8 +74403,8 @@ self: { pname = "cutter"; version = "0.0"; sha256 = "1hka1k012d2nwnkbhbiga6307v1p5s88s2nxkrnymvr0db1ijwqi"; - revision = "1"; - editedCabalFile = "00fh0bhdlsrik1mq1hm3w6dg4m9c03bk22c3ans309dk5swr9hcy"; + revision = "2"; + editedCabalFile = "190j32blf658wdbbawzzscdsf67vd1x0q28d9mlnk7vrgpgrnqc5"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -74815,8 +74566,8 @@ self: { ({ mkDerivation, base, hashable, hedgehog, template-haskell }: mkDerivation { pname = "d10"; - version = "1.0.1.2"; - sha256 = "138mhpl9yhaxbd98m1n5g8h4skbb4agyf7igl1ar3mr6snfhilas"; + version = "1.0.1.3"; + sha256 = "0mgcwvq5n663mimk4vfnqrkrbxni3nb9cjwgfmb00fxll26frjxg"; libraryHaskellDepends = [ base hashable hedgehog template-haskell ]; @@ -75602,6 +75353,7 @@ self: { base quickcheck-classes-base tasty tasty-quickcheck template-haskell ]; + doHaddock = false; description = "Compatibility layer for Data.Array.Byte"; license = lib.licenses.bsd3; }) {}; @@ -76032,6 +75784,8 @@ self: { libraryHaskellDepends = [ base data-default-class text ]; description = "Default instances for (lazy and strict) Text and Text Builder"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-default-instances-unordered-containers" = callPackage @@ -76304,6 +76058,8 @@ self: { libraryHaskellDepends = [ base data-default ]; description = "Utilities for filtering"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-fin" = callPackage @@ -76407,16 +76163,18 @@ self: { testHaskellDepends = [ base containers HUnit ]; description = "Specify that lifted values were forced to WHNF or NF"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "data-forest" = callPackage - ({ mkDerivation, base }: + ({ mkDerivation, base, hspec }: mkDerivation { pname = "data-forest"; - version = "0.1.0.10"; - sha256 = "0wfw87vb00lgc1pf6cmqmlzfqskhy42kyzfj5nyfw1lch8s6sbvm"; + version = "0.1.0.12"; + sha256 = "1lblcriszl2380qyingjr6dsy6hv88yr3rw9ajmjprbrxzq7lqls"; libraryHaskellDepends = [ base ]; - testHaskellDepends = [ base ]; + testHaskellDepends = [ base hspec ]; description = "A simple multi-way tree data structure"; license = lib.licenses.asl20; }) {}; @@ -76912,6 +76670,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 @@ -76948,18 +76708,6 @@ self: { }) {}; "data-ref" = callPackage - ({ mkDerivation, base, data-accessor, stm, transformers }: - mkDerivation { - pname = "data-ref"; - version = "0.0.2"; - sha256 = "0xqgzcpp9b0y2w5h1nln529dizdplhpfl41vxvbhxxcdkng3j53v"; - libraryHaskellDepends = [ base data-accessor stm transformers ]; - description = "Unify STRef and IORef in plain Haskell 98"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.thielema ]; - }) {}; - - "data-ref_0_1" = callPackage ({ mkDerivation, base, data-accessor, stm, transformers }: mkDerivation { pname = "data-ref"; @@ -76968,7 +76716,6 @@ self: { libraryHaskellDepends = [ base data-accessor stm transformers ]; description = "Unify STRef and IORef in plain Haskell 98"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.thielema ]; }) {}; @@ -77436,6 +77183,8 @@ self: { testHaskellDepends = [ async base vector ]; description = "Dynamic growable resizable mutable generic vector"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "database-id-class" = callPackage @@ -77908,6 +77657,8 @@ self: { ]; description = "Directed acyclic word graphs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "daytripper" = callPackage @@ -78705,8 +78456,8 @@ self: { pname = "dear-imgui"; version = "2.1.3"; sha256 = "1czb3g51wh761r0s7d9v47fyx926r1prp3agi5cxpa34vwmghr9x"; - revision = "1"; - editedCabalFile = "14i9spw9cwqilhhj45aq51dsvhlln4rfddsml8wh6i1dkzl1sa17"; + revision = "2"; + editedCabalFile = "08sif5iw24l329ikzfa2540f44667f95ck78a13ggl0wp7kjxzjx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -78719,6 +78470,8 @@ self: { doHaddock = false; description = "Haskell bindings for Dear ImGui"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) SDL2; inherit (pkgs) glew;}; "debian" = callPackage @@ -78896,6 +78649,20 @@ self: { license = lib.licenses.mit; }) {}; + "debug-trace-file" = callPackage + ({ mkDerivation, base, directory, tasty, tasty-golden }: + mkDerivation { + pname = "debug-trace-file"; + version = "1.0.0.1"; + sha256 = "1fcq5wi2drdmqqbn4z0s8f0rk3ka1i4yygc678ia06bbx772mmqf"; + libraryHaskellDepends = [ base ]; + testHaskellDepends = [ base directory tasty tasty-golden ]; + description = "Like Debug.Trace but writing to files."; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "debug-trace-var" = callPackage ({ mkDerivation, base, template-haskell, unicode-show }: mkDerivation { @@ -78935,6 +78702,8 @@ self: { testHaskellDepends = [ base hspec mtl neat-interpolation text ]; description = "Write your GDB scripts in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "deburr" = callPackage @@ -78977,14 +78746,14 @@ self: { "decidable" = callPackage ({ mkDerivation, base, functor-products, microlens, singletons - , vinyl + , singletons-base, vinyl }: mkDerivation { pname = "decidable"; - version = "0.3.0.0"; - sha256 = "1phzfp2q82ylxj09150v1gqmk8858qjw9prhn32zjfnyzfzcg3mq"; + version = "0.3.1.0"; + sha256 = "1l7ichqcpqxdv9xagiy2q3aab0zy38piihwqa0klkbd7wh5cmvid"; libraryHaskellDepends = [ - base functor-products microlens singletons vinyl + base functor-products microlens singletons singletons-base vinyl ]; description = "Combinators for manipulating dependently-typed predicates"; license = lib.licenses.bsd3; @@ -79144,8 +78913,8 @@ self: { }: mkDerivation { pname = "deep-transformations"; - version = "0.2.1.1"; - sha256 = "1fr89jp4gmlhfkc6n3hwnig3fg7ni2wp67jagzican2i48ng58wp"; + version = "0.2.1.2"; + sha256 = "0g4544w9x2djwl3r7nl7lvg5w36hlzh2r7q3xahxs3wc4yyn4q7z"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ base generic-lens rank2classes template-haskell transformers @@ -79516,6 +79285,8 @@ self: { ]; description = "Small and typesafe configuration library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dejafu" = callPackage @@ -79822,6 +79593,8 @@ self: { ]; description = "Dependency injection for records-of-functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dep-t-advice" = callPackage @@ -79847,6 +79620,7 @@ self: { ]; description = "Giving good advice to functions in records-of-functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "dep-t-dynamic" = callPackage @@ -79953,6 +79727,7 @@ self: { ]; description = "Library for dependent-literals-plugin"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "dependent-literals-plugin" = callPackage @@ -80020,6 +79795,8 @@ self: { ]; description = "Dependent map that uses semigroup mappend"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dependent-state" = callPackage @@ -80091,6 +79868,25 @@ self: { license = lib.licenses.publicDomain; }) {}; + "dependent-sum-template_0_1_2_0" = callPackage + ({ mkDerivation, base, constraints-extras, containers, mtl, some + , template-haskell, th-abstraction + }: + mkDerivation { + pname = "dependent-sum-template"; + version = "0.1.2.0"; + sha256 = "1xi8qpi16z06flj3pdy7fhiyrr0wlrh9kxrsj3glw0bwq2b1hyp1"; + libraryHaskellDepends = [ + base containers mtl some template-haskell th-abstraction + ]; + testHaskellDepends = [ + base constraints-extras some template-haskell th-abstraction + ]; + description = "Template Haskell code to generate instances of classes in some package"; + license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; + }) {}; + "depends" = callPackage ({ mkDerivation, base, containers, directory, filepath, hspec , process, QuickCheck, transformers, yaml-config @@ -80503,18 +80299,37 @@ self: { }) {}; "deriving-trans" = callPackage - ({ mkDerivation, base, exceptions, logict, monad-control - , monad-control-identity, mtl, primitive, random, resourcet - , transformers, transformers-base, unliftio-core + ({ mkDerivation, base, exceptions, monad-control + , monad-control-identity, mtl, primitive, transformers + , transformers-base, unliftio-core }: mkDerivation { pname = "deriving-trans"; - version = "0.8.1.0"; - sha256 = "0h0hxsazvg9vbzm81za3qglqkxw6chxxcfcvf8cinhi3hfy41cir"; + version = "0.5.2.0"; + sha256 = "0890885anzr9rvgmia5pm7ppxabgkssxg0i4jkfgxsnayj9rhd27"; libraryHaskellDepends = [ - base exceptions logict monad-control monad-control-identity mtl - primitive random resourcet transformers transformers-base - unliftio-core + base exceptions monad-control monad-control-identity mtl primitive + transformers transformers-base unliftio-core + ]; + description = "Derive instances for monad transformer stacks"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + + "deriving-trans_0_9_1_0" = callPackage + ({ mkDerivation, base, exceptions, logict, monad-control + , monad-control-identity, monad-logger, mtl, primitive, random + , resourcet, transformers, transformers-base, unliftio-core + }: + mkDerivation { + pname = "deriving-trans"; + version = "0.9.1.0"; + sha256 = "0fb3ghz8zz7z209f4sip0bkbpfxz8l37iaf7xq6icf7hw0sggp93"; + libraryHaskellDepends = [ + base exceptions logict monad-control monad-control-identity + monad-logger mtl primitive random resourcet transformers + transformers-base unliftio-core ]; description = "Derive instances for monad transformer stacks"; license = lib.licenses.bsd3; @@ -81230,8 +81045,8 @@ self: { pname = "dhall"; version = "1.42.0"; sha256 = "0yykf7va25pqf3pxm4zx3jsjsvdxy9q6dmzxdwhbag31h8isif4w"; - revision = "1"; - editedCabalFile = "01vflwxxxcwsnh63wmrz4bx4zcgw3wgsyz7gvc71m38kdsv38in4"; + revision = "2"; + editedCabalFile = "06p5paqqzgrbymagkvj8jr983g08qg004f73y63x8ar6xmgaldsw"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -81508,6 +81323,8 @@ self: { pname = "dhall-json"; version = "1.7.12"; sha256 = "1ynm347ccqgh2jmnq9mwj3mc3zd81pwqja5ivdwxkjw08d1wsj6a"; + revision = "1"; + editedCabalFile = "0rf3zlr75x6g4hl1759j21fnnrp21shc7a35x7c73a0xyzpviqqi"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -81574,8 +81391,10 @@ self: { ]; description = "Language Server Protocol (LSP) server for Dhall"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "dhall-lsp-server"; maintainers = [ lib.maintainers.Gabriella439 ]; + broken = true; }) {}; "dhall-nix" = callPackage @@ -81860,6 +81679,8 @@ self: { pname = "dhall-yaml"; version = "1.2.12"; sha256 = "1sh802maai9vxfrjd0w4k9cv4pklhkxid1s5xdbagywcaqdhk272"; + revision = "1"; + editedCabalFile = "0l408ja5505krp0zpdsh64fccv12firn9q39s9m6rvqzbfzyd1y3"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -82069,8 +81890,8 @@ self: { }: mkDerivation { pname = "diagnose"; - version = "2.4.0"; - sha256 = "08y6r3kbrql2ysyrs81h9rdp3ifg9sln9l4bvcmk3hcscifgglgg"; + version = "2.5.1"; + sha256 = "1fxbbjgp40545jap89clsdpf2bp2lgh7fvljji2dhw839i8a1yh5"; libraryHaskellDepends = [ array base data-default dlist hashable prettyprinter prettyprinter-ansi-terminal text unordered-containers wcwidth @@ -82081,6 +81902,8 @@ self: { ]; description = "Beautiful error reporting done easily"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diagrams" = callPackage @@ -82089,8 +81912,8 @@ self: { }: mkDerivation { pname = "diagrams"; - version = "1.4.0.1"; - sha256 = "1y3yij2k2bpvmfxykr2s0hadbcprl1yi6z3pz4yjzqkib5s7y1mq"; + version = "1.4.1"; + sha256 = "0z4i169yzznfj6bmkvgs09v85zchq7visajn6v5hvhj3m0ic0cmh"; libraryHaskellDepends = [ diagrams-contrib diagrams-core diagrams-lib diagrams-svg ]; @@ -82150,10 +81973,8 @@ self: { }: mkDerivation { pname = "diagrams-builder"; - version = "0.8.0.5"; - sha256 = "0dz617kfkvjf3f2zbphkdx1scglcjj162qsfk9xj7slbapnj918m"; - revision = "5"; - editedCabalFile = "0h1wk2b256fv9h5h2r43rqia6n4i3fapsizflrhw2bfyqf0kw736"; + version = "0.8.0.6"; + sha256 = "17yi5dmcxx4sgk3wha386zbv9h69pwq72j8i21vmfh35brxhs9f4"; configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ]; isLibrary = true; isExecutable = true; @@ -82181,10 +82002,8 @@ self: { }: mkDerivation { pname = "diagrams-cairo"; - version = "1.4.2"; - sha256 = "094vavgsfn7hxn2h7phvmx82wdhw51vqqv29p8hsvmijf1gxa7c1"; - revision = "3"; - editedCabalFile = "094l4p8kwqbpdrgmkpy93znljl94la7spkmsd2v3lrc8c4i7r022"; + version = "1.4.2.1"; + sha256 = "0fqma8m4xrqha079aqqynk23y252x47xfzvb0gss4bvgdmwa0lzc"; libraryHaskellDepends = [ array base bytestring cairo colour containers data-default-class diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl @@ -82202,8 +82021,8 @@ self: { }: mkDerivation { pname = "diagrams-canvas"; - version = "1.4.1.1"; - sha256 = "0vhjrmnf2bf4sfyaqhijsx79wah4p2dkg3h79yj9q8l7n90vbfw5"; + version = "1.4.1.2"; + sha256 = "165iwjvx17ym5qsrxsj7va4kmmifg8nay1qq7mbyp3crvfvkfgv2"; libraryHaskellDepends = [ base blank-canvas cmdargs containers data-default-class diagrams-core diagrams-lib lens mtl NumInstances @@ -82223,10 +82042,8 @@ self: { }: mkDerivation { pname = "diagrams-contrib"; - version = "1.4.5"; - sha256 = "0v18a8hyrmpxqi9r30292956afqd4smxnn5v01s66sx382fay2wh"; - revision = "1"; - editedCabalFile = "0i5s9mr88kc68v2wc07jpdy2hzqh2gc1dsawvb2sracnqmv9q658"; + version = "1.4.5.1"; + sha256 = "0whp2p9m7pcb2sgyr8rvhf518f18w5i0vxziganw7qj6ijn9kdyb"; libraryHaskellDepends = [ base circle-packing colour containers cubicbezier data-default data-default-class diagrams-core diagrams-lib diagrams-solve @@ -82287,8 +82104,8 @@ self: { pname = "diagrams-graphviz"; version = "1.4.1.1"; sha256 = "0lscrxd682jvyrl5bj4dxp7593qwyis01sl0p4jm2jfn335wdq40"; - revision = "3"; - editedCabalFile = "1rp3rxpv0dp810rsxwqj8n8lgx60pyh6dxyc27lflp1ag38v8887"; + revision = "4"; + editedCabalFile = "0gkj1l3vhyn0haphk8f89qc1ibgxlyprh2jw9yi1m0wmd3whwif4"; libraryHaskellDepends = [ base containers diagrams-lib fgl graphviz split ]; @@ -82302,8 +82119,8 @@ self: { pname = "diagrams-gtk"; version = "1.4"; sha256 = "1sga2wwkircjgryd4pn9i0wvvcnh3qnhpxas32crpdq939idwsxn"; - revision = "5"; - editedCabalFile = "0jsh7b9hyjfy6k4jy09wb27fkm73ivb5ivf0xq66vk7jfwfb1ank"; + revision = "6"; + editedCabalFile = "0fiv5w3pk8rbj6d28qyay13h25px7fs1flzqdriz1n74f6prnj98"; libraryHaskellDepends = [ base cairo diagrams-cairo diagrams-lib gtk ]; @@ -82320,10 +82137,8 @@ self: { }: mkDerivation { pname = "diagrams-haddock"; - version = "0.4.1.1"; - sha256 = "1azc42pr0hb5qamgf8i0kpkvpzxqlgc9npmi21sxnsw66bnzxw7i"; - revision = "1"; - editedCabalFile = "0ha61hb4g1izyz7v5gynbrm9q3260kjv6x7zmqb0hqmsaqhxsqnc"; + version = "0.4.1.2"; + sha256 = "00g11i1b3bz59jzsnvv9gsxr50593mky8qv4djnhq4xsx6p7i8rj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -82371,6 +82186,8 @@ self: { pname = "diagrams-html5"; version = "1.4.2"; sha256 = "115ch8642cl84mwpj2c23g94fbrrg256s6y1qhsh80qjaq42y1yl"; + revision = "1"; + editedCabalFile = "0x5c3jiqblz5jvvj58s62d4qphry5g89f6azisjf0qhw01vvpkgj"; libraryHaskellDepends = [ base cmdargs containers data-default-class diagrams-core diagrams-lib lens mtl NumInstances optparse-applicative split @@ -82391,8 +82208,8 @@ self: { }: mkDerivation { pname = "diagrams-input"; - version = "0.1.2"; - sha256 = "0p16anpvi627w89aqiz9hi1d8wi22pj35lsmk65gmrzbvp7hyzf3"; + version = "0.1.3"; + sha256 = "1ia8anpmzgdz4087m75x7pcb2hmfs2jilgxlchrcc1vk417z5a6l"; libraryHaskellDepends = [ attoparsec base base64-bytestring blaze-builder blaze-markup bytestring colour conduit conduit-extra containers css-text @@ -82402,43 +82219,9 @@ self: { ]; description = "Parse raster and SVG files for diagrams"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "diagrams-lib" = callPackage - ({ mkDerivation, active, adjunctions, array, base, bytestring - , cereal, colour, containers, criterion, data-default-class - , deepseq, diagrams-core, diagrams-solve, directory, distributive - , dual-tree, exceptions, filepath, fingertree, fsnotify, hashable - , intervals, JuicyPixels, lens, linear, monoid-extras, mtl - , numeric-extras, optparse-applicative, process, profunctors - , QuickCheck, semigroups, tagged, tasty, tasty-hunit - , tasty-quickcheck, text, transformers, unordered-containers - }: - mkDerivation { - pname = "diagrams-lib"; - version = "1.4.5.2"; - sha256 = "1vx51g9znb4a9bf20pjd9zr98wmh39avk2i06217p0iidcw8whz6"; - revision = "1"; - editedCabalFile = "14lxvlxdzkrhdgblgglr5k0rwak0yl4gzawqkfla04mkg6hkh5bb"; - libraryHaskellDepends = [ - active adjunctions array base bytestring cereal colour containers - data-default-class diagrams-core diagrams-solve directory - distributive dual-tree exceptions filepath fingertree fsnotify - hashable intervals JuicyPixels lens linear monoid-extras mtl - optparse-applicative process profunctors semigroups tagged text - transformers unordered-containers - ]; - testHaskellDepends = [ - base deepseq diagrams-solve distributive lens numeric-extras - QuickCheck tasty tasty-hunit tasty-quickcheck - ]; - benchmarkHaskellDepends = [ base criterion diagrams-core ]; - description = "Embedded domain-specific language for declarative graphics"; - license = lib.licenses.bsd3; - }) {}; - - "diagrams-lib_1_4_6" = callPackage ({ mkDerivation, active, adjunctions, array, base, bytestring , cereal, colour, containers, criterion, data-default-class , deepseq, diagrams-core, diagrams-solve, directory, distributive @@ -82469,7 +82252,6 @@ self: { benchmarkHaskellDepends = [ base criterion diagrams-core ]; description = "Embedded domain-specific language for declarative graphics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "diagrams-pandoc" = callPackage @@ -82480,8 +82262,8 @@ self: { }: mkDerivation { pname = "diagrams-pandoc"; - version = "0.3.1"; - sha256 = "1c23xwagsxb6r7lfsrrh8s959aqiacazqxic4s8cg5q6l9vdn9xm"; + version = "0.3.1.1"; + sha256 = "0j8xkb3s3g8n53nyz7x5950zwk85zdrplingl8yrc8gvghlmvfvv"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -82526,10 +82308,8 @@ self: { }: mkDerivation { pname = "diagrams-pgf"; - version = "1.4.2"; - sha256 = "1x7qz8683rsfi0gpmfmhicswmmxppil779d4mhfwkp537b6l2zmh"; - revision = "2"; - editedCabalFile = "027i9cll25m6i1b1ibk31wbxx45wqrwqd0k9dj0ky6lzyl113i8n"; + version = "1.4.2.1"; + sha256 = "1778sjjvggq5ks73489y76f4z0cvzkn9ixn176fm8kf8swaf82ja"; libraryHaskellDepends = [ base bytestring bytestring-builder colour containers diagrams-core diagrams-lib directory filepath hashable JuicyPixels mtl @@ -82548,6 +82328,8 @@ self: { pname = "diagrams-postscript"; version = "1.5.1.1"; sha256 = "1kwb100k3qif9gc8kgvglya5by61522128cxsjrxk5a8dzpgwal4"; + revision = "1"; + editedCabalFile = "0h6wkzncxcz8pjqqr696y3m6d3xbsm5n5d5r4pfx7b81kq53l6x8"; libraryHaskellDepends = [ base bytestring containers data-default-class diagrams-core diagrams-lib hashable lens monoid-extras mtl semigroups split @@ -83318,6 +83100,8 @@ self: { ]; description = "Heist frontend for the digestive-functors library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digestive-functors-hsp" = callPackage @@ -83342,6 +83126,8 @@ self: { libraryHaskellDepends = [ base digestive-functors lucid text ]; description = "Lucid frontend for the digestive-functors library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "digestive-functors-scotty" = callPackage @@ -83430,8 +83216,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 @@ -83632,22 +83416,23 @@ self: { "diohsc" = callPackage ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring - , containers, cryptonite, data-default-class, data-hash, directory - , drunken-bishop, exceptions, filepath, haskeline, hourglass, iconv - , memory, mime, mtl, network, network-simple, network-uri, parsec - , pem, process, regex-compat, rset, safe, temporary, terminal-size - , text, tls, transformers, unix, x509, x509-store, x509-validation + , containers, cryptonite, data-default-class, directory + , drunken-bishop, exceptions, filepath, hashable, haskeline + , hourglass, iconv, memory, mime, mtl, network, network-simple + , network-uri, parsec, pem, process, regex-compat, rset, safe + , temporary, terminal-size, text, tls, transformers, unix, x509 + , x509-store, x509-validation }: mkDerivation { pname = "diohsc"; - version = "0.1.13"; - sha256 = "0fiahbzidrwqn0hfpp6v7ja98rcd5wyxk7f2vnybhg19k50k3zri"; + version = "0.1.14.2"; + sha256 = "08ckfq19xysyr2kah3yccxzld189gwp0g50za7xmxx94glxkwdas"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ asn1-encoding asn1-types base bytestring containers cryptonite - data-default-class data-hash directory drunken-bishop exceptions - filepath haskeline hourglass iconv memory mime mtl network + data-default-class directory drunken-bishop exceptions filepath + hashable haskeline hourglass iconv memory mime mtl network network-simple network-uri parsec pem process regex-compat rset safe temporary terminal-size text tls transformers unix x509 x509-store x509-validation @@ -83961,8 +83746,8 @@ self: { }: mkDerivation { pname = "directory-ospath-streaming"; - version = "0.1"; - sha256 = "1xjjb9h3gxdc8m8z2xx7c7bawcrqmb94jvpfppfv01k48b6w8y3v"; + version = "0.1.0.1"; + sha256 = "0j01kdp8jmi1h40li2fh53iz32gi7hxmlzmx8z3ks2cmp856bv7k"; libraryHaskellDepends = [ base filepath unix ]; testHaskellDepends = [ base directory filepath random tasty tasty-hunit unix @@ -84202,8 +83987,8 @@ self: { }: mkDerivation { pname = "discord-haskell"; - version = "1.15.4"; - sha256 = "10bnfljxgb9d3lwxp0mcqr5r2fbvspb7jy7ndh16yd5qs988b9hb"; + version = "1.15.5"; + sha256 = "17i4bnpg629lk0azvgh7cj41s3xv572yjf2xb94s6i89fl8vjlcz"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -84215,6 +84000,8 @@ self: { executableHaskellDepends = [ base bytestring text unliftio ]; description = "Write bots for Discord in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "discord-haskell-voice" = callPackage @@ -85278,28 +85065,6 @@ self: { }) {}; "distribution-opensuse" = callPackage - ({ mkDerivation, aeson, base, binary, bytestring, containers - , deepseq, Diff, extra, foldl, hashable, hsemail, mtl, parsec-class - , pretty, text, time, turtle - }: - mkDerivation { - pname = "distribution-opensuse"; - version = "1.1.3"; - sha256 = "1yrir5x70nsw5rajcphmr7bzi7k2m05iw97bl7b3v3a5q1i69as5"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base binary bytestring containers deepseq Diff extra foldl - hashable hsemail mtl parsec-class pretty text time turtle - ]; - executableHaskellDepends = [ base containers text turtle ]; - testHaskellDepends = [ base ]; - description = "Types, functions, and tools to manipulate the openSUSE distribution"; - license = lib.licenses.bsd3; - mainProgram = "guess-changelog"; - }) {}; - - "distribution-opensuse_1_1_4" = callPackage ({ mkDerivation, aeson, base, binary, bytestring, containers , deepseq, Diff, extra, foldl, hashable, hsemail, mtl, parsec-class , pretty, text, time, turtle @@ -85318,7 +85083,6 @@ self: { testHaskellDepends = [ base ]; description = "Types, functions, and tools to manipulate the openSUSE distribution"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "guess-changelog"; }) {}; @@ -85376,6 +85140,8 @@ self: { libraryHaskellDepends = [ base ditto lucid path-pieces text ]; description = "Add support for using lucid with Ditto"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "diversity" = callPackage @@ -85526,6 +85292,8 @@ self: { pname = "dl-fedora"; version = "0.9.5"; sha256 = "105vy7bnwbvp6pv8p1lk96qp1asck5wk3677l56snxyqds5qfx0i"; + revision = "1"; + editedCabalFile = "1fwlb1lp4bxxr78rnkgb110xvl1v6c1ndadjn8hd7c9pcj6vr429"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -85540,6 +85308,30 @@ self: { mainProgram = "dl-fedora"; }) {}; + "dl-fedora_0_9_5_1" = callPackage + ({ mkDerivation, ansi-wl-pprint, base, bytestring, directory, extra + , filepath, http-client, http-client-tls, http-directory + , http-types, optparse-applicative, regex-posix, simple-cmd + , simple-cmd-args, text, time, unix, xdg-userdirs + }: + mkDerivation { + pname = "dl-fedora"; + version = "0.9.5.1"; + sha256 = "1fiman4bwgc2rz1nwvcbzj6xflh9fr4l4fr32x2i8q8zxhisd541"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + ansi-wl-pprint base bytestring directory extra filepath http-client + http-client-tls http-directory http-types optparse-applicative + regex-posix simple-cmd simple-cmd-args text time unix xdg-userdirs + ]; + testHaskellDepends = [ base simple-cmd ]; + description = "Fedora image download tool"; + license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + mainProgram = "dl-fedora"; + }) {}; + "dlist" = callPackage ({ mkDerivation, base, deepseq, QuickCheck }: mkDerivation { @@ -85564,26 +85356,6 @@ self: { }) {}; "dlist-nonempty" = callPackage - ({ mkDerivation, base, base-compat, Cabal, criterion, deepseq - , dlist, dlist-instances, QuickCheck, quickcheck-instances - , semigroupoids - }: - mkDerivation { - pname = "dlist-nonempty"; - version = "0.1.2"; - sha256 = "1phdqr9fi2smscmqn7l9kfjxfnqfw6ws1v0a1lrqm5civ15gxhms"; - libraryHaskellDepends = [ base deepseq dlist semigroupoids ]; - testHaskellDepends = [ - base Cabal QuickCheck quickcheck-instances - ]; - benchmarkHaskellDepends = [ - base base-compat criterion dlist dlist-instances - ]; - description = "Non-empty difference lists"; - license = lib.licenses.bsd3; - }) {}; - - "dlist-nonempty_0_1_3" = callPackage ({ mkDerivation, base, base-compat, Cabal, criterion, deepseq , dlist, dlist-instances, foldable1-classes-compat, QuickCheck , quickcheck-instances, semigroupoids @@ -85603,7 +85375,6 @@ self: { ]; description = "Non-empty difference lists"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "dmc" = callPackage @@ -85729,8 +85500,8 @@ self: { }: mkDerivation { pname = "dnf-repo"; - version = "0.5.4"; - sha256 = "0z6fl2rc25ikr84vknj6g29ppp8kaxw44vwav62b5hyrs5kg27bg"; + version = "0.5.5"; + sha256 = "0yj0dizzdhrb44hzr7b6pa5wy5bik4m8pz6ckx4r3lg9rkgqhjfk"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -85772,6 +85543,34 @@ self: { license = lib.licenses.bsd3; }) {}; + "dns_4_2_0" = callPackage + ({ mkDerivation, array, async, attoparsec, auto-update, base + , base16-bytestring, base64-bytestring, bytestring + , case-insensitive, containers, crypton, hourglass, hspec + , hspec-discover, iproute, mtl, network, psqueues, QuickCheck + , word8 + }: + mkDerivation { + pname = "dns"; + version = "4.2.0"; + sha256 = "1ycpnh6vlyb7a087zfcwqacchnc1d7jjhyc7cbiy57582m9wxly2"; + libraryHaskellDepends = [ + array async attoparsec auto-update base base16-bytestring + base64-bytestring bytestring case-insensitive containers crypton + hourglass iproute mtl network psqueues + ]; + testHaskellDepends = [ + base bytestring case-insensitive hspec iproute network QuickCheck + word8 + ]; + testToolDepends = [ hspec-discover ]; + doHaddock = false; + testTarget = "spec"; + description = "DNS library in Haskell"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "dns-patterns" = callPackage ({ mkDerivation, attoparsec, base, bytestring, criterion, HUnit , parser-combinators, text @@ -85789,6 +85588,8 @@ self: { ]; description = "DNS name parsing and pattern matching utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dnscache" = callPackage @@ -86173,6 +85974,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 @@ -86352,34 +86155,6 @@ self: { }) {}; "doctemplates" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, criterion - , doclayout, filepath, Glob, HsYAML, mtl, parsec, safe, scientific - , tasty, tasty-golden, tasty-hunit, temporary, text - , text-conversions, vector - }: - mkDerivation { - pname = "doctemplates"; - version = "0.10.0.2"; - sha256 = "0as0sc4x4ch5z233dqlb8xqg97xbfbzw2dqsz9rfq8rw10v9yx57"; - revision = "1"; - editedCabalFile = "17r6ig72bzqd59p11sjaf9y27pm4yig1a1s1igs57s88cy47qz05"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson base containers doclayout filepath HsYAML mtl parsec safe - scientific text text-conversions vector - ]; - testHaskellDepends = [ - aeson base bytestring containers doclayout filepath Glob tasty - tasty-golden tasty-hunit temporary text - ]; - benchmarkHaskellDepends = [ - aeson base containers criterion doclayout filepath mtl text - ]; - description = "Pandoc-style document templates"; - license = lib.licenses.bsd3; - }) {}; - - "doctemplates_0_11" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, criterion , doclayout, filepath, Glob, mtl, parsec, safe, scientific, tasty , tasty-golden, tasty-hunit, temporary, text, text-conversions @@ -86403,7 +86178,6 @@ self: { ]; description = "Pandoc-style document templates"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "doctest_0_18_2" = callPackage @@ -86468,7 +86242,7 @@ self: { mainProgram = "doctest"; }) {}; - "doctest_0_21_1" = callPackage + "doctest_0_22_0" = callPackage ({ mkDerivation, base, base-compat, code-page, deepseq, directory , exceptions, filepath, ghc, ghc-paths, hspec, hspec-core , hspec-discover, HUnit, mockery, process, QuickCheck, setenv @@ -86476,8 +86250,8 @@ self: { }: mkDerivation { pname = "doctest"; - version = "0.21.1"; - sha256 = "0vgl89p6iaj2mwnd1gkpq86q1g18shdcws0p3can25algi2sldk3"; + version = "0.22.0"; + sha256 = "1fkz2ygj3q88m2mf1b6c5yw29kmacip7r8xn3xq88yxxd39m6cvn"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -86617,34 +86391,6 @@ self: { }) {}; "doctest-parallel" = callPackage - ({ mkDerivation, base, base-compat, Cabal, code-page, containers - , deepseq, directory, exceptions, extra, filepath, ghc, ghc-paths - , Glob, hspec, hspec-core, hspec-discover, HUnit, mockery, pretty - , process, QuickCheck, random, setenv, silently, stringbuilder, syb - , template-haskell, transformers, unordered-containers - }: - mkDerivation { - pname = "doctest-parallel"; - version = "0.2.6"; - sha256 = "13hjwhdjw8jrj07zxkrrfbzr0mrk8gwyis1rbdi4ld4jbq3rr1z7"; - libraryHaskellDepends = [ - base base-compat Cabal code-page containers deepseq directory - exceptions extra filepath ghc ghc-paths Glob pretty process random - syb template-haskell transformers unordered-containers - ]; - testHaskellDepends = [ - base base-compat code-page containers deepseq directory exceptions - filepath ghc ghc-paths hspec hspec-core hspec-discover HUnit - mockery process QuickCheck setenv silently stringbuilder syb - transformers - ]; - testToolDepends = [ hspec-discover ]; - doHaddock = false; - description = "Test interactive Haskell examples"; - license = lib.licenses.mit; - }) {}; - - "doctest-parallel_0_3_0_1" = callPackage ({ mkDerivation, base, base-compat, Cabal, code-page, containers , deepseq, directory, exceptions, filepath, ghc, ghc-paths, Glob , hspec, hspec-core, HUnit, mockery, process, QuickCheck, random @@ -86670,7 +86416,6 @@ self: { doHaddock = false; description = "Test interactive Haskell examples"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "doctest-prop" = callPackage @@ -86860,6 +86605,8 @@ self: { testHaskellDepends = [ base ]; description = "DOM Events expressed as Haskell types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dom-lt" = callPackage @@ -87095,6 +86842,8 @@ self: { ]; description = "Batteries included event sourcing and CQRS"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dominion" = callPackage @@ -87244,43 +86993,14 @@ self: { }) {}; "dotenv" = callPackage - ({ mkDerivation, base, base-compat, containers, directory - , exceptions, hspec, hspec-discover, hspec-megaparsec, megaparsec - , optparse-applicative, process, shellwords, text - }: - mkDerivation { - pname = "dotenv"; - version = "0.10.0.0"; - sha256 = "04brkjk9a17xv2qv2xbsdxbil6ncrrzxcfji9q0civmxhj4vbcfq"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - base base-compat containers directory exceptions megaparsec process - shellwords text - ]; - executableHaskellDepends = [ - base base-compat megaparsec optparse-applicative process text - ]; - testHaskellDepends = [ - base base-compat containers directory exceptions hspec - hspec-megaparsec megaparsec process shellwords text - ]; - testToolDepends = [ hspec-discover ]; - description = "Loads environment variables from dotenv files"; - license = lib.licenses.mit; - mainProgram = "dotenv"; - }) {}; - - "dotenv_0_11_0_1" = callPackage ({ mkDerivation, base, base-compat, containers, data-default-class , directory, exceptions, hspec, hspec-discover, hspec-megaparsec , megaparsec, mtl, optparse-applicative, process, shellwords, text }: mkDerivation { pname = "dotenv"; - version = "0.11.0.1"; - sha256 = "0z09l3dmj9dhq8vgkdiz07wjmn3i0d9fg6zqs9ryjnqdfa27yy4i"; + version = "0.11.0.2"; + sha256 = "1h7d9wh85g78i18053jis88h1lq763znwd7pvpg5akjnr18v1pvv"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -87297,10 +87017,22 @@ self: { testToolDepends = [ hspec-discover ]; description = "Loads environment variables from dotenv files"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "dotenv"; }) {}; + "dotenv-micro" = callPackage + ({ mkDerivation, base, directory }: + mkDerivation { + pname = "dotenv-micro"; + version = "0.1.0.1"; + sha256 = "0s2aldkayl4idmlg2kxz9ljh5gwgzhmqh6jfi9871yh340vcmpjw"; + revision = "1"; + editedCabalFile = "1xgx1a11wyk4vp8rf5lgr5rvpvlwwqz1s2sc3vyvicjjhjnxii3w"; + libraryHaskellDepends = [ base directory ]; + description = "Tiny dotenv library"; + license = lib.licenses.bsd3; + }) {}; + "dotfs" = callPackage ({ mkDerivation, base, bytestring, containers, directory, filepath , haskell-src, HFuse, HUnit, parsec, process, QuickCheck @@ -87382,8 +87114,9 @@ self: { }) {}; "double-conversion" = callPackage - ({ mkDerivation, base, bytestring, ghc-prim, HUnit, test-framework - , test-framework-hunit, test-framework-quickcheck2, text + ({ mkDerivation, base, bytestring, ghc-prim, HUnit + , system-cxx-std-lib, test-framework, test-framework-hunit + , test-framework-quickcheck2, text }: mkDerivation { pname = "double-conversion"; @@ -87391,7 +87124,9 @@ self: { sha256 = "0r7c1801gzdm5x1flmpx8ajxygbc9dl7sgdj0xn3bpm71wgvrf4s"; revision = "2"; editedCabalFile = "1mpnx4m2pg5crfz9k8wamh5mgsha0np3ynnllrmglmwh54gvfjj3"; - libraryHaskellDepends = [ base bytestring ghc-prim text ]; + libraryHaskellDepends = [ + base bytestring ghc-prim system-cxx-std-lib text + ]; testHaskellDepends = [ base bytestring HUnit test-framework test-framework-hunit test-framework-quickcheck2 text @@ -88401,6 +88136,8 @@ self: { ]; description = "DSV (delimiter-separated values)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "dtab" = callPackage @@ -88534,7 +88271,9 @@ self: { ]; description = "Network multiplayer 2D shooting game"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "dual"; + broken = true; }) {}; "dual-tree" = callPackage @@ -88726,8 +88465,8 @@ self: { }: mkDerivation { pname = "dunai"; - version = "0.9.2"; - sha256 = "08skmwkfwiyy83s764fcpa9i8zny10bdbpv9wha6fjqr1b80i80f"; + version = "0.11.1"; + sha256 = "1cypw949jqf3m8xpic5niq385a23k61fr9p8kbys8vxnskykvj23"; libraryHaskellDepends = [ base MonadRandom simple-affine-space transformers transformers-base ]; @@ -88737,24 +88476,6 @@ self: { maintainers = [ lib.maintainers.turion ]; }) {}; - "dunai_0_11_0" = callPackage - ({ mkDerivation, base, MonadRandom, simple-affine-space, tasty - , tasty-hunit, transformers, transformers-base - }: - mkDerivation { - pname = "dunai"; - version = "0.11.0"; - sha256 = "0vnzvd5m917dy4jvbrs8zywq6ch0c77saj5dy04fw2gyfc0wrm3x"; - libraryHaskellDepends = [ - base MonadRandom simple-affine-space transformers transformers-base - ]; - testHaskellDepends = [ base tasty tasty-hunit transformers ]; - description = "Generalised reactive framework supporting classic, arrowized and monadic FRP"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - maintainers = [ lib.maintainers.turion ]; - }) {}; - "dunai-core" = callPackage ({ mkDerivation, base, MonadRandom, transformers, transformers-base }: @@ -88775,8 +88496,8 @@ self: { ({ mkDerivation, base, dunai, normaldistribution, QuickCheck }: mkDerivation { pname = "dunai-test"; - version = "0.11.0"; - sha256 = "1rgyid4zl5xhrh728warbyzm4074dbhcal5nwzy2vlw7nbl7srfw"; + version = "0.11.1"; + sha256 = "19v5rqyfl3dany833bavl8893nzjj3l99dsly71bkwq26y0j9l82"; libraryHaskellDepends = [ base dunai normaldistribution QuickCheck ]; @@ -90089,6 +89810,7 @@ self: { pretty-simple text time unordered-containers vector ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "hectare"; }) {}; @@ -90265,6 +89987,8 @@ self: { libraryHaskellDepends = [ base binary bytestring text ]; description = "EDF parsing library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "edge" = callPackage @@ -90610,38 +90334,15 @@ self: { }) {}; "effectful-plugin" = callPackage - ({ mkDerivation, base, containers, effectful-core, ghc - , ghc-tcplugins-extra - }: - mkDerivation { - pname = "effectful-plugin"; - version = "1.0.0.0"; - sha256 = "11y9d1ylwhgrrwf0pcpjqix2vrwzbwr2rlma6rm0h8yqpkchbx81"; - revision = "3"; - editedCabalFile = "127phsvh3pq96lram633hwawcy594n36gc5cxiwaagaksi240568"; - libraryHaskellDepends = [ - base containers effectful-core ghc ghc-tcplugins-extra - ]; - testHaskellDepends = [ base effectful-core ]; - description = "A GHC plugin for improving disambiguation of effects"; - license = lib.licenses.bsd3; - }) {}; - - "effectful-plugin_1_1_0_1" = callPackage - ({ mkDerivation, base, containers, effectful-core, ghc - , ghc-tcplugins-extra - }: + ({ mkDerivation, base, containers, effectful-core, ghc }: mkDerivation { pname = "effectful-plugin"; version = "1.1.0.1"; sha256 = "1clm190xhf9wibck7i5slzchbq926f2xfxij6zxqv656fx9l5vf6"; - libraryHaskellDepends = [ - base containers effectful-core ghc ghc-tcplugins-extra - ]; + libraryHaskellDepends = [ base containers effectful-core ghc ]; testHaskellDepends = [ base effectful-core ]; description = "A GHC plugin for improving disambiguation of effects"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "effectful-st" = callPackage @@ -91372,6 +91073,7 @@ self: { testHaskellDepends = [ base ]; description = "Easily expose your EKG metrics to Prometheus"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ekg-push" = callPackage @@ -91596,14 +91298,15 @@ self: { "eliminators" = callPackage ({ mkDerivation, base, extra, hspec, hspec-discover, singleton-nats - , singletons-base, template-haskell, th-abstraction, th-desugar + , singletons-base, template-haskell, text, th-abstraction + , th-desugar }: mkDerivation { pname = "eliminators"; - version = "0.9"; - sha256 = "118bd51hfbh29yhs9ai3srk431avwsmccm1500mp21fbwxq8phsj"; + version = "0.9.2"; + sha256 = "0j0k1lw6b5yqz7kxckb5s0phqcnzdis0b469nxryawsv12wvv335"; libraryHaskellDepends = [ - base extra singleton-nats singletons-base template-haskell + base extra singleton-nats singletons-base template-haskell text th-abstraction th-desugar ]; testHaskellDepends = [ base hspec singleton-nats singletons-base ]; @@ -92199,8 +91902,8 @@ self: { }: mkDerivation { pname = "elynx"; - version = "0.7.2.1"; - sha256 = "031wmjf9vbfkvcrkqjy0c27g9c7qkmcdnldq51zc9jpxnhy03s6y"; + version = "0.7.2.2"; + sha256 = "1q5c663qzh24mpnx5zfnxjw90cbfalld76claly9i2xy763pshdj"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -92219,8 +91922,8 @@ self: { }: mkDerivation { pname = "elynx-markov"; - version = "0.7.2.1"; - sha256 = "0zp3xjvbpnd6i2j8aviil82zah0qf2j8m4ys22xbggsmr2jmcyfr"; + version = "0.7.2.2"; + sha256 = "026cpdf6lbllsi4pi8j58xlinnxr333l50drb6hmh5zq5c5ag1jx"; libraryHaskellDepends = [ async attoparsec base bytestring containers elynx-seq hmatrix integration math-functions mwc-random random statistics vector @@ -92238,8 +91941,8 @@ self: { ({ mkDerivation, attoparsec, base, bytestring, hspec }: mkDerivation { pname = "elynx-nexus"; - version = "0.7.2.1"; - sha256 = "1lfadvw43m97jv4if1prb4xnnsbva96fjplhbzgvvc2anpaarfy0"; + version = "0.7.2.2"; + sha256 = "0l18m1ji9034vxny4vdicwnycsxyq5kzzncdddlzs43gv6p8vnww"; libraryHaskellDepends = [ attoparsec base bytestring ]; testHaskellDepends = [ base hspec ]; description = "Import and export Nexus files"; @@ -92254,8 +91957,8 @@ self: { }: mkDerivation { pname = "elynx-seq"; - version = "0.7.2.1"; - sha256 = "0cp44r66cb3vw5dahlzxk7gqqb2dafy4diygc28k0h9az4iv7w8k"; + version = "0.7.2.2"; + sha256 = "1rv6gi5s31jdhxlyhhk0gdqapvxx7yalwqqz98r6461fy3mpm5i0"; libraryHaskellDepends = [ aeson attoparsec base bytestring containers matrices parallel primitive random vector vector-th-unbox word8 @@ -92288,6 +91991,27 @@ self: { maintainers = [ lib.maintainers.dschrempf ]; }) {}; + "elynx-tools_0_7_2_2" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base16-bytestring + , bytestring, cryptohash-sha256, directory, hmatrix + , optparse-applicative, random, template-haskell, time + , transformers, zlib + }: + mkDerivation { + pname = "elynx-tools"; + version = "0.7.2.2"; + sha256 = "0yf8ybw6w0lsdyckvl5h2svkr6v22ymagzlnpvjlkscnb2654xss"; + libraryHaskellDepends = [ + aeson attoparsec base base16-bytestring bytestring + cryptohash-sha256 directory hmatrix optparse-applicative random + template-haskell time transformers zlib + ]; + description = "Tools for ELynx"; + license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.dschrempf ]; + }) {}; + "elynx-tree" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring, comonad , containers, criterion, data-default, data-default-class, deepseq @@ -92296,8 +92020,8 @@ self: { }: mkDerivation { pname = "elynx-tree"; - version = "0.7.2.1"; - sha256 = "018hk2gsh1qf6vk4vcs76mc7sakvq34a2lamlwasgw8q155mc45g"; + version = "0.7.2.2"; + sha256 = "0birkpczwr84x69m44b8hlxm06nx6ibsnr1x2rjlj4x1yzbzjq8m"; libraryHaskellDepends = [ aeson attoparsec base bytestring comonad containers data-default-class deepseq elynx-nexus math-functions parallel @@ -92358,6 +92082,7 @@ self: { ]; description = "Useful route types for Ema"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "ema-generics" = callPackage @@ -92378,6 +92103,8 @@ self: { ]; description = "Generic deriving for Ema routes"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "emacs-keys" = callPackage @@ -92659,6 +92386,7 @@ self: { description = "Emanate a structured view of your plain-text notes"; license = lib.licenses.agpl3Only; badPlatforms = [ "x86_64-darwin" ]; + hydraPlatforms = lib.platforms.none; mainProgram = "emanote"; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -93421,24 +93149,6 @@ self: { }) {}; "enummapset" = callPackage - ({ mkDerivation, array, base, containers, deepseq, ghc-prim, HUnit - , QuickCheck, semigroups, test-framework, test-framework-hunit - , test-framework-quickcheck2 - }: - mkDerivation { - pname = "enummapset"; - version = "0.6.0.3"; - sha256 = "0sxbg053z9v68l9mw906npnm0864jn17rp28bnv4h6ifxyjckb2y"; - libraryHaskellDepends = [ base containers deepseq semigroups ]; - testHaskellDepends = [ - array base containers deepseq ghc-prim HUnit QuickCheck semigroups - test-framework test-framework-hunit test-framework-quickcheck2 - ]; - description = "IntMap and IntSet with Enum keys/elements"; - license = lib.licenses.bsd3; - }) {}; - - "enummapset_0_7_1_0" = callPackage ({ mkDerivation, aeson, array, base, containers, deepseq, ghc-prim , HUnit, QuickCheck, test-framework, test-framework-hunit , test-framework-quickcheck2 @@ -93454,7 +93164,6 @@ self: { ]; description = "IntMap and IntSet with Enum keys/elements"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "enummapset-th" = callPackage @@ -93505,6 +93214,8 @@ self: { ]; description = "Safe helpers for accessing and modifying environment variables"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "env-guard" = callPackage @@ -93639,6 +93350,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Provides FromEnv in envy instance for Record of extensible"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "epanet-haskell" = callPackage @@ -93777,44 +93490,45 @@ self: { "epub-metadata" = callPackage ({ mkDerivation, base, bytestring, containers, directory, filepath - , HUnit, hxt, mtl, regex-compat-tdfa, utf8-string, zip-archive + , HUnit, hxt, mtl, regex-compat, utf8-string, zip-archive }: mkDerivation { pname = "epub-metadata"; - version = "4.5"; - sha256 = "0j839h7894l8hf846zmx0vx640ii3rgswr3jin690djrvwa3kbhr"; + version = "5.1"; + sha256 = "0xmlw4wpwlgyyms0lwvnnhs8mdwjrrlww3sxhvyrgmn0jz41zczj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base bytestring containers directory filepath hxt mtl - regex-compat-tdfa utf8-string zip-archive + base bytestring containers directory filepath hxt mtl regex-compat + utf8-string zip-archive ]; executableHaskellDepends = [ base mtl ]; testHaskellDepends = [ - base bytestring directory filepath HUnit hxt mtl regex-compat-tdfa - utf8-string zip-archive + base containers directory filepath HUnit mtl zip-archive ]; description = "Library for parsing epub document metadata"; - license = lib.licenses.bsd3; + license = lib.licenses.isc; mainProgram = "epub-metadata-example"; }) {}; "epub-tools" = callPackage - ({ mkDerivation, base, bytestring, directory, epub-metadata - , filepath, HUnit, mtl, parsec, process, regex-compat, zip-archive + ({ mkDerivation, base, bytestring, containers, directory + , epub-metadata, filepath, HUnit, mtl, parsec, process + , regex-compat, zip-archive }: mkDerivation { pname = "epub-tools"; - version = "2.11"; - sha256 = "18k4aipaw6zlzhpxidl5b7q5hvy51sj030p7mw89flrgd8kd3g2p"; + version = "3.0"; + sha256 = "0wgylv4jsd9c7bpfnh82yh05vgli907c9fgldvv207lj4bhmdvsz"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ - base bytestring directory epub-metadata filepath mtl parsec process - regex-compat zip-archive + base bytestring containers directory epub-metadata filepath mtl + parsec process regex-compat zip-archive ]; testHaskellDepends = [ - base directory epub-metadata filepath HUnit mtl parsec regex-compat + base containers directory epub-metadata filepath HUnit mtl parsec + regex-compat ]; description = "Command line utilities for working with epub files"; license = lib.licenses.isc; @@ -93860,6 +93574,8 @@ self: { pname = "equal-files"; version = "0.0.5.4"; sha256 = "13gf8f8ik1wdr8n8sa1jlzzfh1bi2892fb5bhmixlxk0d81dm76i"; + revision = "1"; + editedCabalFile = "080kis1vhczq71ryvb1r7756irmd0l56rabq7yr6j9829gz7y1vd"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -94094,8 +93810,8 @@ self: { }: mkDerivation { pname = "errata"; - version = "0.4.0.0"; - sha256 = "1nrmakr76x53hdnykl1imcm57s07v85fbmb10pkzd4wwabk9kajp"; + version = "0.4.0.1"; + sha256 = "1xj7cg93pi242mx99vw31262sx5m78fd13nzjpzxp5zcw40k1mw2"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base containers text ]; @@ -94146,10 +93862,8 @@ self: { ({ mkDerivation, base, primitive, primitive-unlifted }: mkDerivation { pname = "error-codes"; - version = "0.1.0.1"; - sha256 = "0df14g66vwz56bbiyjbis86cv106rlnniaf39kqzrnrdwswx1s1d"; - revision = "1"; - editedCabalFile = "0v26qnz6vdkxr9y59lbvvbklzxmcw8ksv87xhwnmc4c2qmjnc8ml"; + version = "0.1.1.0"; + sha256 = "0sz2wr2aa87nj8k3izrqcwzgl7cqfa5qsyghny8iv1sp4xhpvpwn"; libraryHaskellDepends = [ base primitive primitive-unlifted ]; testHaskellDepends = [ base ]; description = "Error code functions"; @@ -94366,6 +94080,8 @@ self: { pname = "ersatz"; version = "0.4.13"; sha256 = "0ph2ayw4vb4rrgfmm8dhwr18172igx2sczjhv2vf3b6vd5r0z1hy"; + revision = "1"; + editedCabalFile = "1xmmxr1n8mlchlkbl8n93yck4zn5308q5pvp946zr9d7866wl3l5"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -94652,6 +94368,7 @@ self: { ]; description = "Memory-constant streaming of Esqueleto results from PostgreSQL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ess" = callPackage @@ -95664,32 +95381,6 @@ self: { }) {}; "eventlog2html" = callPackage - ({ mkDerivation, aeson, array, attoparsec, base, blaze-html - , bytestring, containers, file-embed, filepath, ghc-events - , ghc-heap, githash, hashable, hashtables, hvega, mtl - , optparse-applicative, semigroups, statistics-linreg, text, time - , trie-simple, vector - }: - mkDerivation { - pname = "eventlog2html"; - version = "0.9.3"; - sha256 = "1wgpqrqkk0cvyxmmgkmq04k3d1v91qdqb737xx7k51d3lb909n7l"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson array attoparsec base blaze-html bytestring containers - file-embed filepath ghc-events ghc-heap hashable hashtables hvega - mtl optparse-applicative semigroups statistics-linreg text time - trie-simple vector - ]; - executableHaskellDepends = [ aeson base filepath githash text ]; - description = "Visualise an eventlog"; - license = lib.licenses.bsd3; - mainProgram = "eventlog2html"; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "eventlog2html_0_10_0" = callPackage ({ mkDerivation, aeson, array, attoparsec, base, blaze-html , blaze-markup, bytestring, containers, file-embed, filepath , ghc-events, ghc-heap, githash, hashable, hashtables, hvega, mtl @@ -95711,7 +95402,6 @@ self: { executableHaskellDepends = [ aeson base filepath githash text ]; description = "Visualise an eventlog"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "eventlog2html"; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -96076,6 +95766,8 @@ self: { ]; description = "A GHC plugin to derive instances"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ewe" = callPackage @@ -97193,31 +96885,18 @@ self: { }) {}; "explicit-exception" = callPackage - ({ mkDerivation, base, deepseq, semigroups, transformers }: - mkDerivation { - pname = "explicit-exception"; - version = "0.1.10.1"; - sha256 = "1pv57m0ynwfljnr0g3snpc716q497l4h9x0d66vj46jgp909iw79"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base deepseq semigroups transformers ]; - description = "Exceptions which are explicit in the type signature"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.thielema ]; - }) {}; - - "explicit-exception_0_2" = callPackage ({ mkDerivation, base, deepseq, semigroups, transformers }: mkDerivation { pname = "explicit-exception"; version = "0.2"; sha256 = "0n2cgliy0ls9740crzpk19wl3cbk5zq90x7qmhhw8idbip7xidni"; + revision = "1"; + editedCabalFile = "0k1299cvh6ayh26nidxnywpdmby5v52k23kyaxzla5i611306v10"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base deepseq semigroups transformers ]; description = "Exceptions which are explicit in the type signature"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.thielema ]; }) {}; @@ -97302,6 +96981,8 @@ self: { ]; description = "A generic exploring interpreter for exploratory programming"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "exposed-containers" = callPackage @@ -97330,8 +97011,8 @@ self: { ({ mkDerivation, base, leancheck, template-haskell }: mkDerivation { pname = "express"; - version = "1.0.10"; - sha256 = "08y0ssnlfwcqw3vr8mswfc9yhjwhgwrl0yvx439443qwvfm64dc0"; + version = "1.0.12"; + sha256 = "0b3z91qv780zqrxfdhfadba3vpcnzhg13j7g78m3zcpgc6xw7iyr"; libraryHaskellDepends = [ base template-haskell ]; testHaskellDepends = [ base leancheck ]; benchmarkHaskellDepends = [ base leancheck ]; @@ -97693,7 +97374,9 @@ self: { ]; description = "Inspect extensions in cabal and hpack files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "extensioneer"; + broken = true; }) {}; "extensions" = callPackage @@ -97773,8 +97456,8 @@ self: { }: mkDerivation { pname = "extra"; - version = "1.7.13"; - sha256 = "0rvvbix6dh6nwg0c2vdfvnkmkgzjrrwpnbz0magn9r3c66qcbsmx"; + version = "1.7.14"; + sha256 = "0rzm3r3rc16hyikm4gg8q6lg10m72m4d7d2k2rm0gf74y3w0kadn"; libraryHaskellDepends = [ base clock directory filepath process time unix ]; @@ -97852,6 +97535,8 @@ self: { ]; description = "API Client for ExtraLife team and user data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "extrapolate" = callPackage @@ -98493,6 +98178,7 @@ self: { doHaddock = false; description = "Fast functions on integers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "fast-bech32" = callPackage @@ -98593,34 +98279,14 @@ self: { }) {}; "fast-logger" = callPackage - ({ mkDerivation, array, auto-update, base, bytestring, directory - , easy-file, filepath, hspec, hspec-discover, text, unix-compat - , unix-time - }: - mkDerivation { - pname = "fast-logger"; - version = "3.1.2"; - sha256 = "1l0h4ddb17xm6qkjhn5gqyfz18szyqcq9wqq92fc24sp2zbd7rv5"; - libraryHaskellDepends = [ - array auto-update base bytestring directory easy-file filepath text - unix-compat unix-time - ]; - testHaskellDepends = [ base bytestring directory hspec ]; - testToolDepends = [ hspec-discover ]; - description = "A fast logging system"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.sternenseemann ]; - }) {}; - - "fast-logger_3_2_1" = callPackage ({ mkDerivation, array, async, auto-update, base, bytestring , directory, easy-file, filepath, hspec, hspec-discover, stm, text , unix-compat, unix-time }: mkDerivation { pname = "fast-logger"; - version = "3.2.1"; - sha256 = "1qsy9x14sv1718anmqwj46p2cwjqxbzqnvai47sj9kkfi2r71l49"; + version = "3.2.2"; + sha256 = "1pdg8jc8qalwz0rrbdb0rdgq5d00j8s3bldnbdkgwc6iqagvwnsp"; libraryHaskellDepends = [ array auto-update base bytestring directory easy-file filepath stm text unix-compat unix-time @@ -98629,7 +98295,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A fast logging system"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.sternenseemann ]; }) {}; @@ -100411,6 +100076,7 @@ self: { ]; description = "Automatic C++ binding generation"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "fficxx-runtime" = callPackage @@ -100446,6 +100112,8 @@ self: { ]; description = "Minimal bindings to the FFmpeg library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ffmpeg; libavcodec = null; libavdevice = null; libavformat = null; libswresample = null; libswscale = null;}; @@ -100540,10 +100208,10 @@ self: { }: mkDerivation { pname = "fgl"; - version = "5.7.0.3"; - sha256 = "04k5grp5d381wkc7sxgcl0sd3z3nlm6l6mmh103vhzh6p49vhs99"; + version = "5.8.0.0"; + sha256 = "02cdigf5m3520vh30lld0j5d4al7nmsa4m9v9bjw1fprfaac03nn"; revision = "1"; - editedCabalFile = "0d5b88j42a3f50b7kbksszvwvcgr59f8pcg3p6cvzq9f4n7y51s7"; + editedCabalFile = "0g96jxn24vmq5y84klh95ng4lm7ghjbgka6rfkjf9kbyn7fqypnp"; libraryHaskellDepends = [ array base containers deepseq transformers ]; @@ -100934,6 +100602,8 @@ self: { ]; description = "A cache system associating values to files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "filediff" = callPackage @@ -101001,21 +100671,21 @@ self: { broken = true; }) {}; - "filepath_1_4_100_3" = callPackage - ({ mkDerivation, base, bytestring, checkers, deepseq, exceptions - , QuickCheck, template-haskell + "filepath_1_4_100_4" = callPackage + ({ mkDerivation, base, bytestring, deepseq, exceptions, QuickCheck + , quickcheck-classes-base, tasty-bench, template-haskell }: mkDerivation { pname = "filepath"; - version = "1.4.100.3"; - sha256 = "1qkx057ddixpvnkps8rbml1iiymv9bpvan6zs4f4cljh7wbi27gd"; + version = "1.4.100.4"; + sha256 = "1bg9jr7nr6ki62d1srqvjlvrylq29zj8qi75kl7xybvw6i8651w2"; libraryHaskellDepends = [ base bytestring deepseq exceptions template-haskell ]; testHaskellDepends = [ - base bytestring checkers deepseq QuickCheck + base bytestring deepseq QuickCheck quickcheck-classes-base ]; - benchmarkHaskellDepends = [ base bytestring deepseq ]; + benchmarkHaskellDepends = [ base bytestring deepseq tasty-bench ]; description = "Library for manipulating FilePaths in a cross platform way"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -101027,8 +100697,8 @@ self: { }: mkDerivation { pname = "filepath-bytestring"; - version = "1.4.2.1.12"; - sha256 = "0i8j724fz8h1bcqvlvp3sxmgyrvx2sim74cvzkpc9m05yn9p27sq"; + version = "1.4.2.1.13"; + sha256 = "0dvsn98xb5hjczs21r8868n79jygaava1pp5l1mdr823hqlz1bcw"; libraryHaskellDepends = [ base bytestring unix ]; testHaskellDepends = [ base bytestring filepath QuickCheck ]; benchmarkHaskellDepends = [ base criterion filepath ]; @@ -101268,6 +100938,8 @@ self: { pname = "filtrable"; version = "0.1.6.0"; sha256 = "058jl7wjaxzvcayc9qzpikxvi9x42civ4sb02jh66rcvpndbfh5y"; + revision = "1"; + editedCabalFile = "05xz53br6bsdfcv71js7sq4agb8xidl4zvv3f8xfls2a9rvb1jw0"; libraryHaskellDepends = [ base containers transformers ]; testHaskellDepends = [ base smallcheck tasty tasty-smallcheck ]; description = "Class of filtrable containers"; @@ -101275,24 +100947,6 @@ self: { }) {}; "fin" = callPackage - ({ mkDerivation, base, boring, dec, deepseq, hashable - , inspection-testing, QuickCheck, some, tagged, universe-base - }: - mkDerivation { - pname = "fin"; - version = "0.2.1"; - sha256 = "14zknp1f65i57nsx8v0np08d7y0szzblybmq7fa5ydazhqwnxlrv"; - revision = "1"; - editedCabalFile = "0qk48l13k8xr0qcs4nr5mpr5y84s8apdm5wlqldjdl9l3qbp58aw"; - libraryHaskellDepends = [ - base boring dec deepseq hashable QuickCheck some universe-base - ]; - testHaskellDepends = [ base inspection-testing tagged ]; - description = "Nat and Fin: peano naturals and finite numbers"; - license = lib.licenses.bsd3; - }) {}; - - "fin_0_3" = callPackage ({ mkDerivation, base, boring, dec, deepseq, hashable , inspection-testing, QuickCheck, some, tagged, universe-base }: @@ -101308,7 +100962,6 @@ self: { testHaskellDepends = [ base inspection-testing tagged ]; description = "Nat and Fin: peano naturals and finite numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "fin-int" = callPackage @@ -101325,6 +100978,7 @@ self: { ]; description = "Finite sets of static size"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "final" = callPackage @@ -102203,14 +101857,17 @@ self: { }) {}; "fixed-vector-hetero" = callPackage - ({ mkDerivation, base, deepseq, fixed-vector, primitive }: + ({ mkDerivation, base, deepseq, doctest, fixed-vector, primitive }: mkDerivation { pname = "fixed-vector-hetero"; version = "0.6.1.1"; sha256 = "1amqpbvzyqfg5rsl4zm99qmiffbh0a5bf9jbwlm6snwm9024qsj3"; libraryHaskellDepends = [ base deepseq fixed-vector primitive ]; + testHaskellDepends = [ base doctest fixed-vector ]; description = "Library for working with product types generically"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fixed-width" = callPackage @@ -102449,8 +102106,8 @@ self: { pname = "flac"; version = "0.2.0"; sha256 = "03zmsnnpkk26ss8ka2l7x9gsfcmiqfyc73v7fna6sk5cwzxsb33c"; - revision = "3"; - editedCabalFile = "1cjy3066klhcywx5yba7ky58wsibhhwiamjbimdv04qc8vmdfm45"; + revision = "4"; + editedCabalFile = "0vgc21i3srxq6is8c05qghrz71nmv3mlvcy3aincsvsgib852kk3"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base bytestring containers directory exceptions filepath mtl text @@ -102678,6 +102335,8 @@ self: { testHaskellDepends = [ base vector ]; description = "Painless general-purpose sampling"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "flat-tex" = callPackage @@ -102731,29 +102390,6 @@ self: { }) {}; "flatparse" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, containers, gauge - , hspec, HUnit, integer-gmp, megaparsec, parsec, primitive - , QuickCheck, quickcheck-instances, template-haskell - }: - mkDerivation { - pname = "flatparse"; - version = "0.3.5.1"; - sha256 = "1gv6c5qas3n9hxfm2anj99df9m960grhi7csb5g3w9w4lshcw9vz"; - libraryHaskellDepends = [ - base bytestring containers integer-gmp template-haskell - ]; - testHaskellDepends = [ - base bytestring hspec HUnit QuickCheck quickcheck-instances - ]; - benchmarkHaskellDepends = [ - attoparsec base bytestring gauge integer-gmp megaparsec parsec - primitive - ]; - description = "High-performance parsing from strict bytestrings"; - license = lib.licenses.mit; - }) {}; - - "flatparse_0_4_1_0" = callPackage ({ mkDerivation, attoparsec, base, bytestring, containers, gauge , hspec, HUnit, integer-gmp, megaparsec, parsec, primitive , QuickCheck, quickcheck-instances, template-haskell, utf8-string @@ -102775,7 +102411,7 @@ self: { ]; description = "High-performance parsing from strict bytestrings"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.raehik ]; }) {}; "flay" = callPackage @@ -103857,6 +103493,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Regulate input traffic from conduit Source with Control.FoldDebounce"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foldable-ix" = callPackage @@ -103917,10 +103555,8 @@ self: { }: mkDerivation { pname = "foldl"; - version = "1.4.14"; - sha256 = "0ihfari2d8czfxfxv5svczpq1cvi3qi55mxphjjqlnabxa76y1cc"; - revision = "2"; - editedCabalFile = "1a7g9j8ds4zrpdx9qrqzbz3clhz1caky9znb8yzfsc7xcnbbgqpn"; + version = "1.4.15"; + sha256 = "1bn00vv60kfwqcn1xv4yi5k2dm8kdksai034wv3cp20p2h2z3clw"; libraryHaskellDepends = [ base bytestring comonad containers contravariant hashable primitive profunctors random semigroupoids text transformers @@ -104018,6 +103654,8 @@ self: { ]; description = "Transducers for foldl folds"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "foldl-transduce-attoparsec" = callPackage @@ -104039,6 +103677,7 @@ self: { ]; description = "Attoparsec and foldl-transduce integration"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "folds" = callPackage @@ -104236,6 +103875,7 @@ self: { license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; mainProgram = "fontconfig-pure"; + broken = true; }) {inherit (pkgs) fontconfig;}; "foo" = callPackage @@ -104318,8 +103958,8 @@ self: { pname = "force-layout"; version = "0.4.0.6"; sha256 = "17956k3mab2xhrmfy7fj5gh08h43yjlsryi5acjhnkmin5arhwpp"; - revision = "10"; - editedCabalFile = "1mcs51d1a3klzy938wq0gcbx7ln49g940zhajmflxq6imy5h5kwa"; + revision = "11"; + editedCabalFile = "1l6v0yy0bb72k0gp58s8vykxyj8qncijax7ds42wgfn378ry8w4j"; libraryHaskellDepends = [ base containers data-default-class lens linear ]; @@ -104525,6 +104165,8 @@ self: { testHaskellDepends = [ aeson base containers hspec mtl text ]; description = "Parse and validate forms in JSON format"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "formal" = callPackage @@ -104597,17 +104239,6 @@ self: { }) {}; "formatn" = callPackage - ({ mkDerivation, base, containers, QuickCheck, text }: - mkDerivation { - pname = "formatn"; - version = "0.2.2"; - sha256 = "0vi29difvl87q7mr088viv3fff2p9nym8gjd20ndh0kwykhjfr8s"; - libraryHaskellDepends = [ base containers QuickCheck text ]; - description = "Formatting of doubles"; - license = lib.licenses.bsd3; - }) {}; - - "formatn_0_3_0" = callPackage ({ mkDerivation, base, containers, QuickCheck, text }: mkDerivation { pname = "formatn"; @@ -104616,7 +104247,6 @@ self: { libraryHaskellDepends = [ base containers QuickCheck text ]; description = "Formatting of doubles"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "formattable" = callPackage @@ -104642,29 +104272,6 @@ self: { }) {}; "formatting" = callPackage - ({ mkDerivation, base, clock, criterion, double-conversion - , ghc-prim, hspec, old-locale, QuickCheck, scientific, text, time - , transformers - }: - mkDerivation { - pname = "formatting"; - version = "7.1.3"; - sha256 = "1vrc2i1b6lxx2aq5hysfl3gl6miq2wbhxc384axvgrkqjbibnqc0"; - revision = "2"; - editedCabalFile = "1i3qkhxqhvqd7mqfdc1mbizw1fin7vp4dwzayc2y0sqcbg7kkns7"; - libraryHaskellDepends = [ - base clock double-conversion ghc-prim old-locale scientific text - time transformers - ]; - testHaskellDepends = [ base ghc-prim hspec scientific text ]; - benchmarkHaskellDepends = [ - base criterion ghc-prim QuickCheck text - ]; - description = "Combinator-based type-safe formatting (like printf() or FORMAT)"; - license = lib.licenses.bsd3; - }) {}; - - "formatting_7_2_0" = callPackage ({ mkDerivation, base, clock, criterion, double-conversion, hspec , old-locale, QuickCheck, scientific, text, time, transformers }: @@ -104680,7 +104287,6 @@ self: { benchmarkHaskellDepends = [ base criterion QuickCheck text ]; description = "Combinator-based type-safe formatting (like printf() or FORMAT)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "forml" = callPackage @@ -104841,74 +104447,37 @@ self: { }) {}; "fortran-src" = callPackage - ({ mkDerivation, alex, array, base, binary, bytestring, containers - , deepseq, directory, either, fgl, filepath, GenericPretty, happy - , hspec, hspec-discover, mtl, pretty, QuickCheck, singletons - , singletons-base, singletons-th, temporary, text, uniplate - , vector-sized - }: - mkDerivation { - pname = "fortran-src"; - version = "0.12.0"; - sha256 = "02n9s5an0z39gx8ks9pr3vrj6h683yra2djwi2m62rl76yw9nsmw"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - array base binary bytestring containers deepseq directory either - fgl filepath GenericPretty mtl pretty singletons singletons-base - singletons-th temporary text uniplate vector-sized - ]; - libraryToolDepends = [ alex happy ]; - executableHaskellDepends = [ - array base binary bytestring containers deepseq directory either - fgl filepath GenericPretty mtl pretty singletons singletons-base - singletons-th temporary text uniplate vector-sized - ]; - testHaskellDepends = [ - array base binary bytestring containers deepseq directory either - fgl filepath GenericPretty hspec mtl pretty QuickCheck singletons - singletons-base singletons-th temporary text uniplate vector-sized - ]; - testToolDepends = [ hspec-discover ]; - description = "Parsers and analyses for Fortran standards 66, 77, 90, 95 and 2003 (partial)"; - license = lib.licenses.asl20; - mainProgram = "fortran-src"; - }) {}; - - "fortran-src_0_15_0" = callPackage ({ mkDerivation, alex, array, base, binary, bytestring, containers , deepseq, directory, either, fgl, filepath, GenericPretty, happy , hspec, hspec-discover, mtl, pretty, process, QuickCheck , singletons, singletons-base, singletons-th, temporary, text - , uniplate, vector-sized + , uniplate }: mkDerivation { pname = "fortran-src"; - version = "0.15.0"; - sha256 = "0a8sgr3pig8b8gakv4y6lgbk00k3ay3nv8n7vkaaqavinr8y7viq"; + version = "0.15.1"; + sha256 = "0h3wq3i18hy3w06dzk4l1w5vf3vzx24lyjznrplkbya6kc5y4kpp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ array base binary bytestring containers deepseq directory either fgl filepath GenericPretty mtl pretty process singletons - singletons-base singletons-th temporary text uniplate vector-sized + singletons-base singletons-th temporary text uniplate ]; libraryToolDepends = [ alex happy ]; executableHaskellDepends = [ array base binary bytestring containers deepseq directory either fgl filepath GenericPretty mtl pretty process singletons - singletons-base singletons-th temporary text uniplate vector-sized + singletons-base singletons-th temporary text uniplate ]; testHaskellDepends = [ array base binary bytestring containers deepseq directory either fgl filepath GenericPretty hspec mtl pretty process QuickCheck singletons singletons-base singletons-th temporary text uniplate - vector-sized ]; testToolDepends = [ hspec-discover ]; description = "Parsers and analyses for Fortran standards 66, 77, 90, 95 and 2003 (partial)"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; mainProgram = "fortran-src"; }) {}; @@ -104948,25 +104517,25 @@ self: { "fortran-vars" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, deepseq, fgl , fortran-src, fortran-src-extras, hspec, hspec-discover, HUnit - , text, uniplate + , mtl, text, uniplate }: mkDerivation { pname = "fortran-vars"; - version = "0.3.1"; - sha256 = "16b1f2h3q2bskz139p8v7w5aa9nsz73w05jby3s3h1rv4g7lj3f1"; + version = "0.4.0"; + sha256 = "0kx6y90m57fhxin9hq7zf8gj4ydyrabc4py0vpg9v6spxfkmks1g"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ aeson base bytestring containers deepseq fgl fortran-src - fortran-src-extras text uniplate + fortran-src-extras mtl text uniplate ]; executableHaskellDepends = [ aeson base bytestring containers deepseq fgl fortran-src - fortran-src-extras text uniplate + fortran-src-extras mtl text uniplate ]; testHaskellDepends = [ aeson base bytestring containers deepseq fgl fortran-src - fortran-src-extras hspec HUnit text uniplate + fortran-src-extras hspec HUnit mtl text uniplate ]; testToolDepends = [ hspec-discover ]; description = "Fortran memory model and other static analysis tools"; @@ -104987,6 +104556,8 @@ self: { testHaskellDepends = [ base doctest hspec ]; description = "Interactive terminal prompt"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "forward-chan" = callPackage @@ -105118,39 +104689,7 @@ self: { license = lib.licenses.bsd3; }) {}; - "fourmolu_0_3_0_0" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, directory - , dlist, exceptions, filepath, ghc-lib-parser, gitrev, hspec - , hspec-discover, HsYAML, HsYAML-aeson, mtl, optparse-applicative - , path, path-io, syb, text - }: - mkDerivation { - pname = "fourmolu"; - version = "0.3.0.0"; - sha256 = "0v89dvcr8l0swj23kkakc39q6lyxjz90rqgwy7m6a5p6iv3h2wms"; - revision = "2"; - editedCabalFile = "16ky7wzmnwhzkk18r63ynq78vlrg065z6mp3hqgs92khpjr33g1l"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson base bytestring containers directory dlist exceptions - filepath ghc-lib-parser HsYAML HsYAML-aeson mtl syb text - ]; - executableHaskellDepends = [ - base directory ghc-lib-parser gitrev optparse-applicative text - ]; - testHaskellDepends = [ - base containers filepath hspec path path-io text - ]; - testToolDepends = [ hspec-discover ]; - description = "A formatter for Haskell source code"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - mainProgram = "fourmolu"; - }) {}; - - "fourmolu" = callPackage + "fourmolu_0_9_0_0" = callPackage ({ mkDerivation, aeson, ansi-terminal, array, base, bytestring , Cabal, containers, Diff, directory, dlist, exceptions, filepath , ghc-lib-parser, gitrev, hspec, hspec-discover, hspec-megaparsec @@ -105183,6 +104722,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "fourmolu"; }) {}; @@ -105221,7 +104761,43 @@ self: { mainProgram = "fourmolu"; }) {}; - "fourmolu_0_13_0_0" = callPackage + "fourmolu" = callPackage + ({ mkDerivation, aeson, ansi-terminal, array, base, binary + , bytestring, Cabal-syntax, containers, Diff, directory, dlist + , file-embed, filepath, ghc-lib-parser, hspec, hspec-discover + , hspec-megaparsec, megaparsec, MemoTrie, mtl, optparse-applicative + , path, path-io, pretty, process, QuickCheck, syb, temporary, text + , th-env, yaml + }: + mkDerivation { + pname = "fourmolu"; + version = "0.11.0.0"; + sha256 = "1hs743r2saqzk4sbwqpyw8k62jhlrc914gizcw5yp0r1gpq83idr"; + revision = "2"; + editedCabalFile = "1gjmdwcm10d178bg468xzzg9b0fc4saxi2fhdc771rqaggd1rxg1"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson ansi-terminal array base binary bytestring Cabal-syntax + containers Diff directory dlist file-embed filepath ghc-lib-parser + megaparsec MemoTrie mtl syb text yaml + ]; + executableHaskellDepends = [ + base containers directory filepath ghc-lib-parser + optparse-applicative text th-env yaml + ]; + testHaskellDepends = [ + base Cabal-syntax containers Diff directory filepath ghc-lib-parser + hspec hspec-megaparsec path path-io pretty process QuickCheck + temporary text + ]; + testToolDepends = [ hspec-discover ]; + description = "A formatter for Haskell source code"; + license = lib.licenses.bsd3; + mainProgram = "fourmolu"; + }) {}; + + "fourmolu_0_13_1_0" = callPackage ({ mkDerivation, aeson, ansi-terminal, array, base, binary , bytestring, Cabal-syntax, containers, deepseq, Diff, directory , file-embed, filepath, ghc-lib-parser, hspec, hspec-discover @@ -105231,8 +104807,8 @@ self: { }: mkDerivation { pname = "fourmolu"; - version = "0.13.0.0"; - sha256 = "0mx2zmr8i9qvqajri1sc7hzl9swz9s7qswi8vqf90hcz2lfc80ji"; + version = "0.13.1.0"; + sha256 = "05vkqygrmgfgmsd8a4vxq8mq0c1z9cb3hja28aszd6llfv427dm1"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -105245,9 +104821,9 @@ self: { optparse-applicative text th-env yaml ]; testHaskellDepends = [ - base Cabal-syntax containers Diff directory filepath ghc-lib-parser - hspec hspec-megaparsec megaparsec path path-io pretty process - QuickCheck temporary text + base bytestring Cabal-syntax containers Diff directory filepath + ghc-lib-parser hspec hspec-megaparsec megaparsec path path-io + pretty process QuickCheck temporary text yaml ]; testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; @@ -105319,10 +104895,8 @@ self: { }: mkDerivation { pname = "fpe"; - version = "0.1.1"; - sha256 = "1rzd1g6zk98l5bz5d7pr66i10gd2kx6vrv9py06wcnz3b5svkx2l"; - revision = "1"; - editedCabalFile = "0qf0qsh3ig76s8inimcwr5yksyzpz3szn80qi599zhv66nflqilf"; + version = "0.1.2"; + sha256 = "13m6gskp3rsi96lw6c012g814lc9y5b0h56afrnmikn1ba24br6p"; libraryHaskellDepends = [ base bytestring integer-logarithms vector ]; @@ -105634,57 +105208,16 @@ self: { }) {}; "freckle-app" = callPackage - ({ mkDerivation, aeson, base, Blammo, bugsnag, bytestring - , case-insensitive, conduit, containers, datadog, directory, dlist - , doctest, ekg-core, envparse, errors, exceptions, filepath, Glob - , hashable, hspec, hspec-core, hspec-expectations-lifted - , hspec-junit-formatter, http-client, http-conduit - , http-link-header, http-types, immortal, lens, lens-aeson - , load-env, memcache, monad-control, monad-logger, MonadRandom, mtl - , network-uri, persistent, persistent-postgresql, postgresql-simple - , primitive, process, resource-pool, retry, safe, scientist - , semigroupoids, template-haskell, temporary, text, time - , transformers, transformers-base, typed-process, unliftio - , unliftio-core, unordered-containers, vector, wai, wai-extra, yaml - , yesod-core - }: - mkDerivation { - pname = "freckle-app"; - version = "1.3.0.0"; - sha256 = "1h2ckdjq4h7qv7r5dm28gbs5ja125wi2inzjg3436css9qn1s7v9"; - libraryHaskellDepends = [ - aeson base Blammo bugsnag bytestring case-insensitive conduit - containers datadog dlist doctest ekg-core envparse errors - exceptions filepath Glob hashable hspec hspec-core - hspec-expectations-lifted hspec-junit-formatter http-client - http-conduit http-link-header http-types immortal lens load-env - memcache monad-control monad-logger MonadRandom mtl network-uri - persistent persistent-postgresql postgresql-simple primitive - resource-pool retry safe scientist semigroupoids template-haskell - text time transformers transformers-base typed-process unliftio - unliftio-core unordered-containers vector wai wai-extra yaml - yesod-core - ]; - testHaskellDepends = [ - aeson base bytestring directory errors hspec http-types lens - lens-aeson memcache mtl postgresql-simple process temporary text - time wai wai-extra - ]; - description = "Haskell application toolkit used at Freckle"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - - "freckle-app_1_9_0_3" = callPackage ({ mkDerivation, aeson, aws-xray-client-persistent , aws-xray-client-wai, base, Blammo, bugsnag, bytestring , case-insensitive, cassava, conduit, conduit-extra, containers , datadog, doctest, dotenv, ekg-core, envparse, errors, exceptions , extra, filepath, Glob, hashable, hspec, hspec-core , hspec-expectations-lifted, hspec-junit-formatter, http-client - , http-conduit, http-link-header, http-types, immortal, lens - , lens-aeson, memcache, monad-control, monad-validate, MonadRandom - , mtl, network-uri, nonempty-containers, path-pieces, persistent + , http-conduit, http-link-header, http-types, hw-kafka-client + , immortal, lens, lens-aeson, memcache, monad-control + , monad-validate, MonadRandom, mtl, network-uri + , nonempty-containers, path-pieces, persistent , persistent-postgresql, postgresql-simple, primitive, QuickCheck , resource-pool, resourcet, retry, safe, scientist, semigroupoids , template-haskell, text, time, transformers, transformers-base @@ -105693,21 +105226,22 @@ self: { }: mkDerivation { pname = "freckle-app"; - version = "1.9.0.3"; - sha256 = "15fih8ky1cg9sn25hkwxi5iwy0zn76lbs308saaby6kkgifqm8yv"; + version = "1.9.1.1"; + sha256 = "1nzij1lbcclyfq8g9lv21yn6m3d3d0gws27gl7yjvc0il6fljg0a"; libraryHaskellDepends = [ aeson aws-xray-client-persistent aws-xray-client-wai base Blammo bugsnag bytestring case-insensitive cassava conduit conduit-extra containers datadog doctest dotenv ekg-core envparse errors exceptions extra filepath Glob hashable hspec hspec-core hspec-expectations-lifted hspec-junit-formatter http-client - http-conduit http-link-header http-types immortal lens memcache - monad-control monad-validate MonadRandom mtl network-uri - nonempty-containers path-pieces persistent persistent-postgresql - postgresql-simple primitive resource-pool resourcet retry safe - scientist semigroupoids template-haskell text time transformers - transformers-base typed-process unliftio unliftio-core - unordered-containers vector wai wai-extra yaml yesod-core + http-conduit http-link-header http-types hw-kafka-client immortal + lens memcache monad-control monad-validate MonadRandom mtl + network-uri nonempty-containers path-pieces persistent + persistent-postgresql postgresql-simple primitive resource-pool + resourcet retry safe scientist semigroupoids template-haskell text + time transformers transformers-base typed-process unliftio + unliftio-core unordered-containers vector wai wai-extra yaml + yesod-core ]; testHaskellDepends = [ aeson base Blammo bugsnag bytestring cassava conduit errors hspec @@ -106165,6 +105699,8 @@ self: { description = "Interface to the Kinect device"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) freenect; freenect_sync = null; libfreenect = null;}; @@ -106263,7 +105799,9 @@ self: { ]; description = "A friendly effect system for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "freer-simple-examples"; + broken = true; }) {}; "freer-simple-catching" = callPackage @@ -106417,6 +105955,21 @@ self: { license = lib.licenses.bsd3; }) {}; + "fregel" = callPackage + ({ mkDerivation, alex, array, base, groom, happy, mtl, process }: + mkDerivation { + pname = "fregel"; + version = "1.2.0"; + sha256 = "0l5zd7wpdln7wq024pw213xfijm8wwp5d5dfzkx8x7ak4xigz1y6"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ array base groom mtl process ]; + executableToolDepends = [ alex happy ]; + description = "A functional DSL for vertex-centric large-scale graph processing"; + license = lib.licenses.mit; + mainProgram = "fregel"; + }) {}; + "french-cards" = callPackage ({ mkDerivation, base, hspec, HUnit }: mkDerivation { @@ -106600,7 +106153,9 @@ self: { ]; description = "Attempt to pretty-print any input"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "friendly"; + broken = true; }) {}; "friendly-time" = callPackage @@ -106886,29 +106441,6 @@ self: { }) {}; "fsnotify" = callPackage - ({ mkDerivation, async, base, bytestring, containers, directory - , filepath, hinotify, random, shelly, tasty, tasty-hunit, temporary - , text, time, unix, unix-compat - }: - mkDerivation { - pname = "fsnotify"; - version = "0.3.0.1"; - sha256 = "19bdbz9wb9jvln6yg6qm0hz0w84bypvkxf0wjhgrgd52f9gidlny"; - revision = "2"; - editedCabalFile = "12m0y5583plk9pikvwqy1rc0yyvicxf8j5nz0nwxb4grsgfqrv7v"; - libraryHaskellDepends = [ - async base bytestring containers directory filepath hinotify shelly - text time unix unix-compat - ]; - testHaskellDepends = [ - async base directory filepath random tasty tasty-hunit temporary - unix-compat - ]; - description = "Cross platform library for file change notification"; - license = lib.licenses.bsd3; - }) {}; - - "fsnotify_0_4_1_0" = callPackage ({ mkDerivation, async, base, bytestring, containers, directory , exceptions, filepath, hinotify, monad-control, random, retry , safe-exceptions, sandwich, temporary, text, time, unix @@ -106928,7 +106460,6 @@ self: { ]; description = "Cross platform library for file change notification"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "fsnotify-conduit" = callPackage @@ -106948,6 +106479,8 @@ self: { ]; description = "Get filesystem notifications as a stream of events"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fst" = callPackage @@ -107046,7 +106579,9 @@ self: { ]; description = "Watch a file/directory and run a command when it's modified"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "fswatcher"; + broken = true; }) {}; "ft-generator" = callPackage @@ -107195,17 +106730,18 @@ self: { }) {}; "fudgets" = callPackage - ({ mkDerivation, array, base, containers, directory, libX11 - , libXext, old-time, parallel, process, random, time, unix + ({ mkDerivation, array, base, bytestring, containers, directory + , libX11, libXext, old-time, parallel, process, random, time, unix }: mkDerivation { pname = "fudgets"; - version = "0.18.3.2"; - sha256 = "0x8xw9n28fg1m207dfhwmy0cqhda3iayhifqxg4zd2zx7ngs3r0i"; + version = "0.18.4"; + sha256 = "0lzn5wvv8lsbsgpp1zka31pgc3m1hycvn0xj85159mbpbvywm1xl"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - array base containers directory old-time process time unix + array base bytestring containers directory old-time process time + unix ]; librarySystemDepends = [ libX11 libXext ]; executableHaskellDepends = [ array base old-time parallel random ]; @@ -107425,6 +106961,7 @@ self: { executableHaskellDepends = [ base funcons-tools funcons-values ]; description = "A modular interpreter for executing SIMPLE funcons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "runfct-SIMPLE"; }) {}; @@ -107451,6 +106988,7 @@ self: { ]; description = "A modular interpreter for executing funcons"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "funcons-values" = callPackage @@ -107466,6 +107004,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 @@ -107654,12 +107194,16 @@ self: { }) {}; "functor-products" = callPackage - ({ mkDerivation, base, microlens, singletons, text, vinyl }: + ({ mkDerivation, base, microlens, singletons, singletons-base, text + , vinyl + }: mkDerivation { pname = "functor-products"; - version = "0.1.1.0"; - sha256 = "12rybs7d7m38sfnh9vqs375mzc0k8y0g0dgmwn2c23k9dn5r55jv"; - libraryHaskellDepends = [ base microlens singletons text vinyl ]; + version = "0.1.2.0"; + sha256 = "0d3izxxrw8xdadwwgg0ybsml5n10xy2hs8c85vp7dsf1z0cvvhgm"; + libraryHaskellDepends = [ + base microlens singletons singletons-base text vinyl + ]; description = "General functor products for various Foldable instances"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -108027,6 +107571,8 @@ self: { ]; description = "Template Haskell helpers for fused-effects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fusion" = callPackage @@ -108079,19 +107625,17 @@ self: { , cryptohash-md5, Diff, directory, directory-tree, dlist, fgl , fgl-visualize, file-embed, filepath, free, futhark-data , futhark-manifest, futhark-server, githash, half, happy, haskeline - , language-c-quote, lens, lsp, mainland-pretty, megaparsec, mtl - , mwc-random, neat-interpolation, parallel, prettyprinter - , prettyprinter-ansi-terminal, process-extras, QuickCheck, random - , regex-tdfa, srcloc, statistics, tasty, tasty-hunit - , tasty-quickcheck, template-haskell, temporary, terminal-size - , text, time, transformers, vector, versions, zlib + , language-c-quote, lens, lsp, lsp-types, mainland-pretty + , megaparsec, mtl, mwc-random, neat-interpolation, parallel + , prettyprinter, prettyprinter-ansi-terminal, process-extras + , QuickCheck, random, regex-tdfa, srcloc, statistics, tasty + , tasty-hunit, tasty-quickcheck, template-haskell, temporary + , terminal-size, text, time, transformers, vector, versions, zlib }: mkDerivation { pname = "futhark"; - version = "0.24.3"; - sha256 = "0y83phng77asca4pk66w8grx8b4d1ip7xi77vrfjc04yjagrj1ba"; - revision = "2"; - editedCabalFile = "0pzhdg410mnxz0116lpr9ax8x0skg2gymhqhm730dn17sd7z6y56"; + version = "0.25.2"; + sha256 = "1mnpcagqvq37rlcf2a1pliajl7yjn0r6b3nq8n9fi3m95ngv11vq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -108100,8 +107644,8 @@ self: { containers cryptohash-md5 Diff directory directory-tree dlist fgl fgl-visualize file-embed filepath free futhark-data futhark-manifest futhark-server githash half haskeline - language-c-quote lens lsp mainland-pretty megaparsec mtl mwc-random - neat-interpolation parallel prettyprinter + language-c-quote lens lsp lsp-types mainland-pretty megaparsec mtl + mwc-random neat-interpolation parallel prettyprinter prettyprinter-ansi-terminal process-extras random regex-tdfa srcloc statistics template-haskell temporary terminal-size text time transformers vector versions zlib @@ -108109,7 +107653,7 @@ self: { libraryToolDepends = [ alex happy ]; executableHaskellDepends = [ base ]; testHaskellDepends = [ - base containers megaparsec QuickCheck tasty tasty-hunit + base containers free megaparsec QuickCheck tasty tasty-hunit tasty-quickcheck text ]; description = "An optimising compiler for a functional, array-oriented language"; @@ -108238,6 +107782,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Simple and fast implementation of Future"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fuzzcheck" = callPackage @@ -108398,6 +107944,8 @@ self: { ]; description = "Fuzzy set for approximate string matching"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "fuzzytime" = callPackage @@ -108851,6 +108399,8 @@ self: { ]; description = "Automatically spin up and spin down local daemons"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "gargoyle-postgresql" = callPackage @@ -108872,6 +108422,7 @@ self: { ]; description = "Manage PostgreSQL servers with gargoyle"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gargoyle-postgresql-connect" = callPackage @@ -109524,10 +109075,8 @@ self: { }: mkDerivation { pname = "gemini-router"; - version = "0.1.1.0"; - sha256 = "19aq9ri0ixkg0d5g4ickda75dvpq340lwkdxn0ndcbkis9xrvkv9"; - revision = "1"; - editedCabalFile = "07lnx99d3dkjhqcail31zkbmivclzxdj3qjbhijg1cs3fkl57q3q"; + version = "0.1.2.0"; + sha256 = "12b5zvs1npqc47jy04dbs2mqy2n7m0pn83ndz0wb4c1x1qygp7sj"; libraryHaskellDepends = [ base gemini-server HsOpenSSL network-uri transformers ]; @@ -109544,6 +109093,8 @@ self: { pname = "gemini-server"; version = "0.3.0.0"; sha256 = "0s9h0lzxz5yjvz8rzw9mx9dba21171960waaqikj2qbbja0iq3k3"; + revision = "1"; + editedCabalFile = "151ghd56sa5c95vxb7hacgmykg7y30086w84c61x5y18njnzyqw6"; libraryHaskellDepends = [ base bytestring hslogger HsOpenSSL network network-run network-uri text utf8-string @@ -109563,6 +109114,8 @@ self: { pname = "gemini-textboard"; version = "0.2.0.1"; sha256 = "1yvizcxafq943q9fbz08mq2x50dw9ykdz5vy6hr6ps2g47j4wfa0"; + revision = "1"; + editedCabalFile = "0ppmyz8a03ccdp97s3c1y6zmpvd1whzdjmn30qx8jw6iky8whwjs"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -109812,6 +109365,8 @@ self: { ]; description = "Derivation of Aeson instances using GHC generics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "generic-arbitrary" = callPackage @@ -109875,27 +109430,6 @@ self: { }) {}; "generic-data" = callPackage - ({ mkDerivation, ap-normalize, base, base-orphans, contravariant - , criterion, deepseq, generic-lens, ghc-boot-th, one-liner - , show-combinators, tasty, tasty-hunit - }: - mkDerivation { - pname = "generic-data"; - version = "1.0.0.1"; - sha256 = "0fz65k4sxn9c23rg5iv0vij2mksl5rkn6dl2f3i9d9d60b5wca9y"; - libraryHaskellDepends = [ - ap-normalize base base-orphans contravariant ghc-boot-th - show-combinators - ]; - testHaskellDepends = [ - base generic-lens one-liner show-combinators tasty tasty-hunit - ]; - benchmarkHaskellDepends = [ base criterion deepseq ]; - description = "Deriving instances with GHC.Generics and related utilities"; - license = lib.licenses.mit; - }) {}; - - "generic-data_1_1_0_0" = callPackage ({ mkDerivation, ap-normalize, base, base-orphans, contravariant , deepseq, generic-lens, ghc-boot-th, one-liner, show-combinators , tasty, tasty-bench, tasty-hunit @@ -109914,7 +109448,18 @@ self: { benchmarkHaskellDepends = [ base deepseq tasty-bench ]; description = "Deriving instances with GHC.Generics and related utilities"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; + }) {}; + + "generic-data-functions" = callPackage + ({ mkDerivation, base, text }: + mkDerivation { + pname = "generic-data-functions"; + version = "0.1.1"; + sha256 = "15qnz56p58vximfd1r1pd2hq5y2npkklinr3mb6r00jp19s9hxmb"; + libraryHaskellDepends = [ base text ]; + description = "Familiar functions lifted to generic data types"; + license = lib.licenses.mit; + maintainers = [ lib.maintainers.raehik ]; }) {}; "generic-data-surgery" = callPackage @@ -110405,14 +109950,14 @@ self: { }) {}; "generically" = callPackage - ({ mkDerivation, base }: + ({ mkDerivation, base, base-orphans }: mkDerivation { pname = "generically"; version = "0.1.1"; sha256 = "1ks3pi6mpma83xffplz8vmimyhvzpnhmcgvk3bvl3c64pqva9i84"; revision = "1"; editedCabalFile = "0pkyhym7q9v03pplpfjg80vmpk0cbgc56panfx9vcbzadvxmx6rb"; - libraryHaskellDepends = [ base ]; + libraryHaskellDepends = [ base base-orphans ]; description = "Generically newtype to use with DerivingVia"; license = lib.licenses.bsd3; }) {}; @@ -111727,6 +111272,8 @@ self: { ]; description = "A gerrit client library"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "getemx" = callPackage @@ -111809,18 +111356,18 @@ self: { }) {}; "gev-lib" = callPackage - ({ mkDerivation, base, gev-dist, HUnit, random }: + ({ mkDerivation, base, HUnit, random }: mkDerivation { pname = "gev-lib"; - version = "0.2.0.1"; - sha256 = "1ql1m2ywcma6dpchg255q9r2dq612kx03jwa6vgzinh8va51mc9l"; + version = "0.2.0.2"; + sha256 = "1y3gprss1a118icygml6r1qm81ad9diis51yp1vlqi9mnk5wx2wm"; libraryHaskellDepends = [ base random ]; - testHaskellDepends = [ base gev-dist HUnit ]; + testHaskellDepends = [ base HUnit ]; description = "The family of Extreme Value Distributions"; license = lib.licenses.isc; hydraPlatforms = lib.platforms.none; broken = true; - }) {gev-dist = null;}; + }) {}; "gf" = callPackage ({ mkDerivation, alex, array, base, bytestring, Cabal, cgi @@ -112000,6 +111547,8 @@ self: { libraryHaskellDepends = [ base ghc-bignum ]; description = "Backwards-compatible orphan instances for ghc-bignum"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-boot_9_6_1" = callPackage @@ -112100,8 +111649,8 @@ self: { pname = "ghc-compact"; version = "0.1.0.0"; sha256 = "03sf8ap1ncjsibp9z7k9xgcsj9s0q3q6l4shf8k7p8dkwpjl1g2h"; - revision = "4"; - editedCabalFile = "02dinasxkbrysdhl8w1c1a1ldiqna49zfbl9hgbk4xlnph0xw5wr"; + revision = "5"; + editedCabalFile = "0f1jbvfnw1c7q43bw952vskrsr6wg9ili30b44w2kdrk764h2idl"; libraryHaskellDepends = [ base bytestring ghc-prim ]; description = "In memory storage of deeply evaluated data structure"; license = lib.licenses.bsd3; @@ -112160,14 +111709,16 @@ self: { }) {}; "ghc-corroborate" = callPackage - ({ mkDerivation, base, ghc, ghc-tcplugins-extra }: + ({ mkDerivation, base, ghc-tcplugins-extra }: mkDerivation { pname = "ghc-corroborate"; version = "1.0.0"; sha256 = "0ai1xv3x8ls7cmgmd3bs7bnd5r3m10sys25gwwwaiimdgfhs3fd3"; - libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ]; + libraryHaskellDepends = [ base ghc-tcplugins-extra ]; description = "An flatter API for GHC typechecker plugins"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-datasize" = callPackage @@ -112281,6 +111832,8 @@ self: { libraryHaskellDepends = [ base constraints ghc template-haskell ]; description = "Automatically generate GHC API counterparts to Haskell declarations"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-dump-core" = callPackage @@ -112296,6 +111849,8 @@ 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 @@ -112347,6 +111902,7 @@ self: { ]; description = "Handy tools for working with ghc-dump dumps"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "ghc-dump"; }) {}; @@ -112364,26 +111920,6 @@ self: { }) {}; "ghc-events" = callPackage - ({ mkDerivation, array, base, binary, bytestring, containers, text - , vector - }: - mkDerivation { - pname = "ghc-events"; - version = "0.18.0"; - sha256 = "0kwml9dgbj0px4bc3d9kqmw2ijc3y7irs4n02nzm7ilgcvy7hv6h"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - array base binary bytestring containers text vector - ]; - executableHaskellDepends = [ base bytestring containers ]; - testHaskellDepends = [ base ]; - description = "Library and tool for parsing .eventlog files from GHC"; - license = lib.licenses.bsd3; - mainProgram = "ghc-events"; - }) {}; - - "ghc-events_0_19_0_1" = callPackage ({ mkDerivation, array, base, binary, bytestring, containers, text , vector }: @@ -112400,7 +111936,6 @@ self: { testHaskellDepends = [ base ]; description = "Library and tool for parsing .eventlog files from GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "ghc-events"; }) {}; @@ -112482,7 +112017,7 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "ghc-exactprint" = callPackage + "ghc-exactprint_1_5_0" = callPackage ({ mkDerivation, base, bytestring, containers, data-default, Diff , directory, fail, filemanip, filepath, free, ghc, ghc-boot , ghc-paths, HUnit, mtl, ordered-containers, silently, syb @@ -112506,29 +112041,51 @@ self: { ]; description = "ExactPrint for GHC"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; - "ghc-exactprint_1_6_1_3" = callPackage - ({ mkDerivation }: + "ghc-exactprint" = callPackage + ({ mkDerivation, base, bytestring, Cabal-syntax, containers + , data-default, Diff, directory, fail, filemanip, filepath, free + , ghc, ghc-boot, ghc-paths, HUnit, mtl, ordered-containers + , silently, syb + }: mkDerivation { pname = "ghc-exactprint"; version = "1.6.1.3"; sha256 = "1qsb799dr4hl0f5m1yhrk50nc29w3wiadkvlzgn2426zsg0ixfpy"; isLibrary = true; isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers data-default directory fail filepath + free ghc ghc-boot mtl ordered-containers syb + ]; + testHaskellDepends = [ + base bytestring Cabal-syntax containers data-default Diff directory + fail filemanip filepath ghc ghc-boot ghc-paths HUnit mtl + ordered-containers silently syb + ]; description = "ExactPrint for GHC"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-exactprint_1_7_0_1" = callPackage - ({ mkDerivation }: + ({ mkDerivation, base, bytestring, Cabal-syntax, containers + , data-default, Diff, directory, extra, fail, filepath, ghc + , ghc-boot, ghc-paths, HUnit, mtl, ordered-containers, silently + , syb + }: mkDerivation { pname = "ghc-exactprint"; version = "1.7.0.1"; sha256 = "0lf3grridkx5xb5zz8shx3vkzwqsc3y5rbgw7w6hbsgp7ac90jjz"; isLibrary = true; isExecutable = true; + testHaskellDepends = [ + base bytestring Cabal-syntax containers data-default Diff directory + extra fail filepath ghc ghc-boot ghc-paths HUnit mtl + ordered-containers silently syb + ]; description = "ExactPrint for GHC"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -112545,6 +112102,8 @@ self: { description = "GHC garbage collection hook"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-gc-tune" = callPackage @@ -112730,7 +112289,7 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "ghc-lib" = callPackage + "ghc-lib_9_2_7_20230228" = callPackage ({ mkDerivation, alex, array, base, binary, bytestring, containers , deepseq, directory, exceptions, filepath, ghc-lib-parser , ghc-prim, happy, hpc, parsec, pretty, process, rts, time @@ -112749,9 +112308,10 @@ self: { libraryToolDepends = [ alex happy ]; description = "The GHC API, decoupled from GHC versions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; - "ghc-lib_9_4_5_20230430" = callPackage + "ghc-lib" = callPackage ({ mkDerivation, alex, array, base, binary, bytestring, containers , deepseq, directory, exceptions, filepath, ghc-lib-parser , ghc-prim, happy, hpc, parsec, pretty, process, rts, stm, time @@ -112770,7 +112330,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "The GHC API, decoupled from GHC versions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-lib_9_6_2_20230523" = callPackage @@ -112815,7 +112374,7 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "ghc-lib-parser" = callPackage + "ghc-lib-parser_9_2_7_20230228" = callPackage ({ mkDerivation, alex, array, base, binary, bytestring, containers , deepseq, directory, exceptions, filepath, ghc-prim, happy, parsec , pretty, process, time, transformers, unix @@ -112833,9 +112392,10 @@ self: { libraryToolDepends = [ alex happy ]; description = "The GHC API, decoupled from GHC versions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; - "ghc-lib-parser_9_4_5_20230430" = callPackage + "ghc-lib-parser" = callPackage ({ mkDerivation, alex, array, base, binary, bytestring, containers , deepseq, directory, exceptions, filepath, ghc-prim, happy, parsec , pretty, process, time, transformers, unix @@ -112853,7 +112413,6 @@ self: { libraryToolDepends = [ alex happy ]; description = "The GHC API, decoupled from GHC versions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-lib-parser_9_6_2_20230523" = callPackage @@ -112897,26 +112456,6 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "ghc-lib-parser-ex" = callPackage - ({ mkDerivation, base, bytestring, containers, directory, extra - , filepath, ghc, ghc-boot, ghc-boot-th, tasty, tasty-hunit - , uniplate - }: - mkDerivation { - pname = "ghc-lib-parser-ex"; - version = "9.2.0.4"; - sha256 = "138wkpy7qpdkp07028flab3lwq4b3mns0qcrkfrhclixlz8pi74v"; - libraryHaskellDepends = [ - base bytestring containers ghc ghc-boot ghc-boot-th uniplate - ]; - testHaskellDepends = [ - base directory extra filepath ghc ghc-boot ghc-boot-th tasty - tasty-hunit uniplate - ]; - description = "Algorithms on GHC parse trees"; - license = lib.licenses.bsd3; - }) {}; - "ghc-lib-parser-ex_9_2_1_1" = callPackage ({ mkDerivation, base, bytestring, containers, directory, extra , filepath, ghc-lib-parser, tasty, tasty-hunit, uniplate @@ -112937,7 +112476,7 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "ghc-lib-parser-ex_9_4_0_0" = callPackage + "ghc-lib-parser-ex" = callPackage ({ mkDerivation, base, bytestring, containers, directory, extra , filepath, ghc-lib-parser, tasty, tasty-hunit, uniplate }: @@ -112954,7 +112493,6 @@ self: { ]; description = "Algorithms on GHC parse trees"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-lib-parser-ex_9_6_0_0" = callPackage @@ -113129,8 +112667,8 @@ self: { ({ mkDerivation, base, ghc }: mkDerivation { pname = "ghc-parser"; - version = "0.2.4.0"; - sha256 = "1s7y7npv37x1jxgq6ryl1ijcb7izmz07ab5pmqj4prng6g3majc9"; + version = "0.2.5.0"; + sha256 = "17ms9zyh5mczqpxhs2p2y3sa4zda39lzl66dkb18a79c5p36id0r"; libraryHaskellDepends = [ base ghc ]; description = "Haskell source parser from GHC"; license = lib.licenses.mit; @@ -113378,6 +112916,8 @@ self: { ]; description = "Constructs Haskell syntax trees for the GHC API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ghc-srcspan-plugin" = callPackage @@ -113453,8 +112993,10 @@ self: { }: mkDerivation { pname = "ghc-syntax-highlighter"; - version = "0.0.8.0"; - sha256 = "1s6bq90s75qfiv54qsskawv3ihwjhdml4fxq56ww01p54mnrwr27"; + version = "0.0.9.0"; + sha256 = "0dan000fg9ipfh8knhrdscnr8lvcf6p2djl9b4bgqd4nc65pcf8a"; + revision = "2"; + editedCabalFile = "1l1w8jn4sn0l9358xqinifm70zy0dsgdkm9kzlaj782abwvlz5rm"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base ghc-lib-parser text ]; testHaskellDepends = [ base hspec text ]; @@ -113480,6 +113022,29 @@ self: { }) {}; "ghc-tags_1_5" = callPackage + ({ mkDerivation, aeson, async, attoparsec, base, bytestring + , containers, deepseq, directory, filepath, ghc-lib, ghc-paths + , optparse-applicative, process, stm, temporary, text, time, vector + , yaml + }: + mkDerivation { + pname = "ghc-tags"; + version = "1.5"; + sha256 = "0hscl49qq3lx2a5g6g7g1wa4rl52piizqsykicy1kvi4di7qnyqk"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + aeson async attoparsec base bytestring containers deepseq directory + filepath ghc-lib ghc-paths optparse-applicative process stm + temporary text time vector yaml + ]; + description = "Utility for generating ctags and etags with GHC API"; + license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + mainProgram = "ghc-tags"; + }) {}; + + "ghc-tags_1_6" = callPackage ({ mkDerivation, aeson, async, attoparsec, base, bytestring , containers, deepseq, directory, filepath, ghc, ghc-boot , ghc-paths, optparse-applicative, process, stm, temporary, text @@ -113487,8 +113052,8 @@ self: { }: mkDerivation { pname = "ghc-tags"; - version = "1.5"; - sha256 = "0hscl49qq3lx2a5g6g7g1wa4rl52piizqsykicy1kvi4di7qnyqk"; + version = "1.6"; + sha256 = "0iiqapx4v4jz4d7ni4dcvpfl948ydx2a7kxvjsk2irdcknzymblw"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -113510,8 +113075,8 @@ self: { }: mkDerivation { pname = "ghc-tags"; - version = "1.6"; - sha256 = "0iiqapx4v4jz4d7ni4dcvpfl948ydx2a7kxvjsk2irdcknzymblw"; + version = "1.7"; + sha256 = "17189yi1zffgcdwx0nb6n4pbv3jhfajhfnag84fnqwy4kbvl5ma4"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -113690,7 +113255,7 @@ self: { }) {}; "ghc-typelits-natnormalise" = callPackage - ({ mkDerivation, base, containers, ghc, ghc-bignum + ({ mkDerivation, base, containers, ghc, ghc-bignum, ghc-prim , ghc-tcplugins-extra, tasty, tasty-hunit, template-haskell , transformers }: @@ -113701,37 +113266,14 @@ self: { libraryHaskellDepends = [ base containers ghc ghc-bignum ghc-tcplugins-extra transformers ]; - testHaskellDepends = [ base tasty tasty-hunit template-haskell ]; + testHaskellDepends = [ + base ghc-prim tasty tasty-hunit template-haskell + ]; description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat"; license = lib.licenses.bsd2; }) {}; "ghc-typelits-presburger" = callPackage - ({ mkDerivation, base, containers, equational-reasoning, ghc - , ghc-tcplugins-extra, mtl, pretty, reflection, syb, tasty - , tasty-discover, tasty-expected-failure, tasty-hunit, text - , transformers - }: - mkDerivation { - pname = "ghc-typelits-presburger"; - version = "0.6.2.0"; - sha256 = "11rzfvs2kvknz8892bii2ljh6hbaa1zy0hnwi6pi1xghvwp1fckq"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base containers ghc ghc-tcplugins-extra mtl pretty reflection syb - transformers - ]; - testHaskellDepends = [ - base equational-reasoning tasty tasty-discover - tasty-expected-failure tasty-hunit text - ]; - testToolDepends = [ tasty-discover ]; - description = "Presburger Arithmetic Solver for GHC Type-level natural numbers"; - license = lib.licenses.bsd3; - }) {}; - - "ghc-typelits-presburger_0_7_2_0" = callPackage ({ mkDerivation, base, containers, equational-reasoning, ghc , ghc-tcplugins-extra, mtl, pretty, reflection, syb, tasty , tasty-discover, tasty-expected-failure, tasty-hunit, text @@ -113754,7 +113296,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Presburger Arithmetic Solver for GHC Type-level natural numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "ghc-usage" = callPackage @@ -113984,10 +113525,8 @@ self: { }: mkDerivation { pname = "ghcid"; - version = "0.8.7"; - sha256 = "0yqc1pkfajnr56gnh43sbj50r7c3r41b2jfz07ivgl6phi4frjbq"; - revision = "1"; - editedCabalFile = "0s4z20cbap0bymljkdbw6lr3dchi34yvy9j27f4xjwx93dhnrmkk"; + version = "0.8.9"; + sha256 = "1dq8lc0dwzib8y21279q4j54cmm7lvx64b3hw2yiym1kzi9rrhj4"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -114007,35 +113546,6 @@ self: { maintainers = [ lib.maintainers.maralorn ]; }) {}; - "ghcid_0_8_8" = callPackage - ({ mkDerivation, ansi-terminal, base, cmdargs, containers - , directory, extra, filepath, fsnotify, process, tasty, tasty-hunit - , terminal-size, time, unix - }: - mkDerivation { - pname = "ghcid"; - version = "0.8.8"; - sha256 = "1y2qr1g0jy1jd8lh6bqwhzad15jgz0psq5qx31hbgq6ikm1nxjcj"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - ansi-terminal base cmdargs directory extra filepath process time - ]; - executableHaskellDepends = [ - ansi-terminal base cmdargs containers directory extra filepath - fsnotify process terminal-size time unix - ]; - testHaskellDepends = [ - ansi-terminal base cmdargs containers directory extra filepath - fsnotify process tasty tasty-hunit terminal-size time unix - ]; - description = "GHCi based bare bones IDE"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - mainProgram = "ghcid"; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - "ghcide" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, async, base , base16-bytestring, binary, bytestring, case-insensitive @@ -114043,10 +113553,10 @@ self: { , dependent-map, dependent-sum, Diff, directory, dlist, enummapset , exceptions, extra, filepath, fingertree, focus, fuzzy, ghc , ghc-boot, ghc-boot-th, ghc-check, ghc-paths, ghc-trace-events - , ghc-typelits-knownnat, gitrev, Glob, haddock-library, hashable - , hie-bios, hie-compat, hiedb, hls-graph, hls-plugin-api - , implicit-hie, implicit-hie-cradle, lens, list-t, lsp, lsp-test - , lsp-types, monoid-subclasses, mtl, network-uri, opentelemetry + , gitrev, Glob, haddock-library, hashable, hie-bios, hie-compat + , hiedb, hls-graph, hls-plugin-api, implicit-hie + , implicit-hie-cradle, lens, list-t, lsp, lsp-test, lsp-types + , monoid-subclasses, mtl, network-uri, opentelemetry , optparse-applicative, parallel, prettyprinter , prettyprinter-ansi-terminal, QuickCheck, random, regex-tdfa , safe-exceptions, shake, sorted-list, sqlite-simple, stm @@ -114057,8 +113567,8 @@ self: { }: mkDerivation { pname = "ghcide"; - version = "2.0.0.0"; - sha256 = "0dxd0p6bb982a5x1nf23ds7i46k79c3jy861rb4cmbfni19vqyla"; + version = "2.0.0.1"; + sha256 = "1yjsrnwriga1zfwygbr1301prijmi9wavniwlincdmf622aglzwj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -114081,11 +113591,11 @@ self: { ]; testHaskellDepends = [ aeson async base containers data-default directory extra filepath - fuzzy ghc ghc-typelits-knownnat hls-plugin-api lens list-t lsp - lsp-test lsp-types monoid-subclasses network-uri QuickCheck random - regex-tdfa shake sqlite-simple stm stm-containers tasty - tasty-expected-failure tasty-hunit tasty-quickcheck tasty-rerun - text text-rope unordered-containers + fuzzy ghc hls-plugin-api lens list-t lsp lsp-test lsp-types + monoid-subclasses network-uri QuickCheck random regex-tdfa shake + sqlite-simple stm stm-containers tasty tasty-expected-failure + tasty-hunit tasty-quickcheck tasty-rerun text text-rope + unordered-containers ]; testToolDepends = [ implicit-hie ]; description = "The core of an IDE"; @@ -114102,8 +113612,8 @@ self: { }: mkDerivation { pname = "ghcide-bench"; - version = "2.0.0.0"; - sha256 = "1f5bry8j8af3gd8hndsys7i4z40d202mn1zs4h2rsr2aky8rgb2c"; + version = "2.0.0.1"; + sha256 = "10si4phkbds83x8br6cnq0ysp832yshf7k4p4p9a8fi9cmb3lczl"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -115421,13 +114931,13 @@ self: { "gi-gtksource" = callPackage ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk , gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject - , gi-gtk, gi-pango, gtksourceview3, haskell-gi, haskell-gi-base + , gi-gtk, gi-pango, gtksourceview, haskell-gi, haskell-gi-base , haskell-gi-overloading, text, transformers }: mkDerivation { pname = "gi-gtksource"; - version = "3.0.28"; - sha256 = "1047fgqj2avy34fd9y5m4ipv0vmpizw4lwnwdbrnhvs2fc89g0lh"; + version = "5.0.0"; + sha256 = "0yfwms2qzb994q8c48nnm0gfxz315jk0yvd45ss3p1j5idq4b5pp"; setupHaskellDepends = [ base Cabal gi-atk gi-cairo gi-gdk gi-gdkpixbuf gi-gio gi-glib gi-gobject gi-gtk gi-pango haskell-gi @@ -115437,10 +114947,12 @@ self: { gi-gio gi-glib gi-gobject gi-gtk gi-pango haskell-gi haskell-gi-base haskell-gi-overloading text transformers ]; - libraryPkgconfigDepends = [ gtksourceview3 ]; + libraryPkgconfigDepends = [ gtksourceview ]; description = "GtkSource bindings"; license = lib.licenses.lgpl21Only; - }) {inherit (pkgs) gtksourceview3;}; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {inherit (pkgs) gtksourceview;}; "gi-handy" = callPackage ({ mkDerivation, base, bytestring, Cabal, containers, gi-atk @@ -115509,6 +115021,8 @@ self: { description = "IBus bindings"; license = lib.licenses.lgpl21Only; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) ibus;}; "gi-javascriptcore" = callPackage @@ -115734,7 +115248,7 @@ self: { license = lib.licenses.lgpl21Only; }) {inherit (pkgs) libsecret;}; - "gi-soup_2_4_28" = callPackage + "gi-soup" = callPackage ({ mkDerivation, base, bytestring, Cabal, containers, gi-gio , gi-glib, gi-gobject, haskell-gi, haskell-gi-base , haskell-gi-overloading, libsoup, text, transformers @@ -115753,10 +115267,9 @@ self: { libraryPkgconfigDepends = [ libsoup ]; description = "Libsoup bindings"; license = lib.licenses.lgpl21Only; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libsoup;}; - "gi-soup" = callPackage + "gi-soup_3_0_2" = callPackage ({ mkDerivation, base, bytestring, Cabal, containers, gi-gio , gi-glib, gi-gobject, haskell-gi, haskell-gi-base , haskell-gi-overloading, libsoup, text, transformers @@ -115775,6 +115288,7 @@ self: { libraryPkgconfigDepends = [ libsoup ]; description = "Libsoup bindings"; license = lib.licenses.lgpl21Only; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libsoup;}; "gi-vips" = callPackage @@ -116256,8 +115770,8 @@ self: { }: mkDerivation { pname = "git-annex"; - version = "10.20230407"; - sha256 = "19500i3xcmxbh990kmdqimknlpk55z5iz9lnm3w35g8hmrpfh0d0"; + version = "10.20230626"; + sha256 = "1z16alb5193y4m70rq0bcxx1rn6lnlgswigdnv5lqybjq1fw1z99"; configureFlags = [ "-fassistant" "-f-benchmark" "-fdbus" "-f-debuglocks" "-fmagicmime" "-fnetworkbsd" "-fpairing" "-fproduction" "-fs3" "-ftorrentparser" @@ -116330,7 +115844,9 @@ self: { ]; description = "git checkout command-line tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "git-brunch"; + broken = true; }) {}; "git-checklist" = callPackage @@ -116526,8 +116042,8 @@ self: { }: mkDerivation { pname = "git-lfs"; - version = "1.2.0"; - sha256 = "1iv3s1c7gwmsima9z3rsphjligpnf7h3vc5c96zgq9b71cx81lba"; + version = "1.2.1"; + sha256 = "0bbgkyfaz6psxqha68w3s1pgp1kc58p47zi5qvh877hhmdn25l9q"; libraryHaskellDepends = [ aeson base bytestring case-insensitive containers http-client http-types network-uri text @@ -116729,7 +116245,9 @@ self: { ]; description = "More efficient replacement to the great git-radar"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "gitHUD"; + broken = true; }) {}; "gitcache" = callPackage @@ -116777,8 +116295,8 @@ self: { }: mkDerivation { pname = "githash"; - version = "0.1.6.3"; - sha256 = "06zg1rif1rcxni1vacmr2bh1nbm6i62rjbikfr4xsyzq1sv7kfpw"; + version = "0.1.7.0"; + sha256 = "1m1hyfahvvsf46fy69zj27z4af0m9dlhc8i3qgjc9jfrdg1fgm8s"; libraryHaskellDepends = [ base bytestring directory filepath process template-haskell th-compat @@ -116822,6 +116340,38 @@ self: { license = lib.licenses.bsd3; }) {}; + "github_0_29" = callPackage + ({ mkDerivation, aeson, base, base-compat, base16-bytestring + , binary, binary-instances, bytestring, containers, cryptohash-sha1 + , deepseq, deepseq-generics, exceptions, file-embed, hashable + , hspec, hspec-discover, http-client, http-client-tls + , http-link-header, http-types, iso8601-time, mtl, network-uri + , tagged, text, time-compat, tls, transformers, transformers-compat + , unordered-containers, vector + }: + mkDerivation { + pname = "github"; + version = "0.29"; + sha256 = "1hki9lvf5vcq980ky98vwc7rh86rgf3z8pvqfgpb6jinc7jylcpx"; + revision = "2"; + editedCabalFile = "1g3b2ppx2n5nxpn00sk6i413w99vmb95sz1v9g3anh9g9x6mgv21"; + libraryHaskellDepends = [ + aeson base base-compat base16-bytestring binary binary-instances + bytestring containers cryptohash-sha1 deepseq deepseq-generics + exceptions hashable http-client http-client-tls http-link-header + http-types iso8601-time mtl network-uri tagged text time-compat tls + transformers transformers-compat unordered-containers vector + ]; + testHaskellDepends = [ + aeson base base-compat bytestring file-embed hspec tagged text + unordered-containers vector + ]; + testToolDepends = [ hspec-discover ]; + description = "Access to the GitHub API, v3"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "github-backup" = callPackage ({ mkDerivation, base, bytestring, Cabal, containers, directory , exceptions, filepath, git, github, hslogger, IfElse, mtl, network @@ -116903,8 +116453,8 @@ self: { }: mkDerivation { pname = "github-release"; - version = "2.0.0.6"; - sha256 = "0ydsms0gwz9m7645p9jw7xcn9ri7pzjjwfm10lpwmazjd71hvz4s"; + version = "2.0.0.8"; + sha256 = "1ajx225n0shixh0q0zm5qh9rb254yvs1f393mc8x6j0mry7jp9v3"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -116928,8 +116478,8 @@ self: { }: mkDerivation { pname = "github-rest"; - version = "1.1.3"; - sha256 = "0na4kfwlxfqd7d99vc1hkqrp9nlp21a3xpiwhlm3vzcgzrmk2f0v"; + version = "1.1.4"; + sha256 = "156mqc9748ypinwm8xb46b40ysqpgyb5p2jaiyc34jpxd74g3148"; libraryHaskellDepends = [ aeson base bytestring http-client http-client-tls http-types jwt mtl scientific text time transformers unliftio unliftio-core @@ -117034,24 +116584,6 @@ self: { }) {}; "github-webhooks" = callPackage - ({ mkDerivation, aeson, base, base16-bytestring, bytestring - , cryptonite, deepseq, deepseq-generics, hspec, memory, text, time - , vector - }: - mkDerivation { - pname = "github-webhooks"; - version = "0.16.0"; - sha256 = "1h0l4p0wyy4d6k43gxjfjx2fv0a59xd900dr14ydxdjn75yhc7g0"; - libraryHaskellDepends = [ - aeson base base16-bytestring bytestring cryptonite deepseq - deepseq-generics memory text time vector - ]; - testHaskellDepends = [ aeson base bytestring hspec text vector ]; - description = "Aeson instances for GitHub Webhook payloads"; - license = lib.licenses.mit; - }) {}; - - "github-webhooks_0_17_0" = callPackage ({ mkDerivation, aeson, base, base16-bytestring, bytestring , cryptonite, deepseq, deepseq-generics, hspec, memory, text, time , vector @@ -117067,7 +116599,6 @@ self: { testHaskellDepends = [ aeson base bytestring hspec text vector ]; description = "Aeson instances for GitHub Webhook payloads"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "githud" = callPackage @@ -117131,8 +116662,8 @@ self: { }: mkDerivation { pname = "gitit"; - version = "0.15.1.0"; - sha256 = "1mnyk7gpi6hxvyh9cmc7mzlvx5m0kj102b0fq5xzljzb0bvh7wp2"; + version = "0.15.1.1"; + sha256 = "0pfm0bd6xqa5x9wlqsk4l1yk5045fdipkrm6wh8hzsbb70q0vg4h"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -117491,8 +117022,8 @@ self: { pname = "gl"; version = "0.9"; sha256 = "1kb1igc9cyjavf3f3ccv9xhhsfn46pcrsw47qd9m5793nnmg13ii"; - revision = "1"; - editedCabalFile = "19qyb9m2fy9qyirmhhayg51scas42n3i2rx7jcw6v3ra8c8r9rwr"; + revision = "2"; + editedCabalFile = "1lcqk3hb4s7qq4mxp0cykzinpgk8s1lbn05ay7i92q2h75jyhvk6"; libraryHaskellDepends = [ base containers fixed half transformers ]; @@ -117547,8 +117078,8 @@ self: { }: mkDerivation { pname = "glabrous"; - version = "2.0.6.1"; - sha256 = "1y6hkih8qc7ld6sxfarcjd1yyqvgv7s4d2fch62m0gzcq77f9gsg"; + version = "2.0.6.2"; + sha256 = "0xviafnaw2pap3x3813zikvsg7j0mgwpsly2czgszsxszqvcxpx4"; libraryHaskellDepends = [ aeson aeson-pretty attoparsec base bytestring cereal cereal-text either text unordered-containers @@ -117883,6 +117414,7 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Console IRC client"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; mainProgram = "glirc"; maintainers = [ lib.maintainers.kiwi ]; }) {}; @@ -118096,6 +117628,7 @@ self: { ]; description = "Examples using the gloss library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gloss-export" = callPackage @@ -118168,6 +117701,7 @@ self: { ]; description = "Parallel rendering of raster images"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "gloss-raster-accelerate" = callPackage @@ -118267,7 +117801,9 @@ self: { testToolDepends = [ hspec-discover ]; description = "Parser and optimizer for a small subset of GLSL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "optshader"; + broken = true; }) {}; "gltf-codec" = callPackage @@ -118325,12 +117861,13 @@ self: { "glualint" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, deepseq , directory, effectful, filemanip, filepath, optparse-applicative - , parsec, pretty, signal, uu-parsinglib, uuagc, uuagc-cabal + , parsec, pretty, signal, tasty, tasty-golden, uu-parsinglib, uuagc + , uuagc-cabal }: mkDerivation { pname = "glualint"; - version = "1.24.6"; - sha256 = "0br2732xikwcv2q2x1xk5d1ly71khfxy7d23hz2f66h0sl7vsl3w"; + version = "1.25.0"; + sha256 = "042j1dpndzxdmskvnc8hsna6hnws1xk0klyxnkn5c5ammva4hhgv"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -118341,6 +117878,9 @@ self: { aeson base bytestring containers deepseq directory effectful filemanip filepath optparse-applicative signal ]; + testHaskellDepends = [ + base bytestring filepath tasty tasty-golden + ]; description = "Attempts to fix your syntax erroring Lua files"; license = lib.licenses.lgpl21Plus; mainProgram = "glualint"; @@ -118942,7 +118482,9 @@ self: { executableHaskellDepends = [ base criterion megaparsec text ]; description = "Megaparsec parser for Godot `tscn` and `gdextension` files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "bench"; + broken = true; }) {}; "gofer-prelude" = callPackage @@ -121227,8 +120769,8 @@ self: { pname = "goldplate"; version = "0.2.1.1"; sha256 = "1cisak5ng6v0iq24djyg4jp87diay02m0k2saac49saxmk29jsr6"; - revision = "1"; - editedCabalFile = "1sw4rvcfkq56dq5pmd4qh5r9nsz5f0kcsszwn4y2wdbpjplpqm0i"; + revision = "2"; + editedCabalFile = "1gcdgybp6dgdr46p22cm84i9b1p1p0afil616ni7kqrsb7vgssjy"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -121916,7 +121458,9 @@ self: { ]; description = "A type definition compiler supporting multiple output languages"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; mainProgram = "gotyno-hs"; + broken = true; }) {}; "gpah" = callPackage @@ -121984,8 +121528,8 @@ self: { }: mkDerivation { pname = "gpmf"; - version = "0.1.2.0"; - sha256 = "0z0l1jl7am48lc8c92jb6l12r5khgil9d5n2rrp53n7ncsljbh1n"; + version = "0.2.1.0"; + sha256 = "06hgvffqqglvyvhwrcij31cnzm37r2nq4vxi3v802rfqbp4g01x3"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -122237,8 +121781,8 @@ self: { }: mkDerivation { pname = "grammatical-parsers"; - version = "0.7.0.1"; - sha256 = "0m6mj3r1253lswzlg1v33diysqfkz4872fp7yj7azga3abi0k59h"; + version = "0.7.1"; + sha256 = "1h4y3gb35ixhwgyw9p1s9fihbm1xfcbrqnassqh11kvcapsfj94x"; isLibrary = true; isExecutable = true; setupHaskellDepends = [ base Cabal cabal-doctest ]; @@ -122966,18 +122510,19 @@ self: { "graphql-spice" = callPackage ({ mkDerivation, aeson, base, conduit, containers, exceptions , graphql, hspec, hspec-expectations, megaparsec, scientific, text - , transformers, unordered-containers, vector + , time, transformers, unordered-containers, vector }: mkDerivation { pname = "graphql-spice"; - version = "1.0.1.0"; - sha256 = "0h04x6w5w1g6jxr52zndpixv4k3sxciqq044jhv7iiq33hj54gkf"; + version = "1.0.2.0"; + sha256 = "0pqi7pc5nyn87ci07pdv0x2f8j43rzmyksbcrkd2iy1zw89r82qz"; libraryHaskellDepends = [ aeson base conduit containers exceptions graphql hspec-expectations - megaparsec scientific text transformers unordered-containers vector + megaparsec scientific text time transformers unordered-containers + vector ]; testHaskellDepends = [ - aeson base graphql hspec scientific text unordered-containers + aeson base graphql hspec scientific text time unordered-containers ]; description = "GraphQL with batteries"; license = lib.licenses.mpl20; @@ -123419,6 +122964,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell binding for Gremlin graph query language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "greskell-core" = callPackage @@ -123441,6 +122987,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell binding for Gremlin graph query language - core data types and tools"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "greskell-websocket" = callPackage @@ -123464,6 +123012,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Haskell client for Gremlin Server using WebSocket serializer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "grid" = callPackage @@ -123592,24 +123141,6 @@ self: { }) {}; "gridtables" = callPackage - ({ mkDerivation, array, base, containers, doclayout, parsec, tasty - , tasty-hunit, text - }: - mkDerivation { - pname = "gridtables"; - version = "0.0.3.0"; - sha256 = "1akix9flnax6dx3s9c7yyzb19nw13y8rmh0kz7y3hpjlkaz659xy"; - revision = "1"; - editedCabalFile = "0m2651z81n8s6hb8id7y6k2kprsgwnj7pcd6p8lmdpkzzz3wwd0c"; - libraryHaskellDepends = [ - array base containers doclayout parsec text - ]; - testHaskellDepends = [ array base parsec tasty tasty-hunit text ]; - description = "Parser for reStructuredText-style grid tables"; - license = lib.licenses.mit; - }) {}; - - "gridtables_0_1_0_0" = callPackage ({ mkDerivation, array, base, containers, doclayout, parsec, tasty , tasty-hunit, text }: @@ -123623,30 +123154,32 @@ self: { testHaskellDepends = [ array base parsec tasty tasty-hunit text ]; description = "Parser for reStructuredText-style grid tables"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "grisette" = callPackage ({ mkDerivation, array, base, bytestring, call-stack, deepseq , doctest, generic-deriving, Glob, hashable, hashtables, intern - , loch-th, mtl, once, parallel, sbv, tasty, tasty-hunit - , tasty-quickcheck, tasty-test-reporter, template-haskell - , th-compat, transformers, unordered-containers, vector + , loch-th, mtl, parallel, prettyprinter, QuickCheck, sbv, tasty + , tasty-hunit, tasty-quickcheck, tasty-test-reporter + , template-haskell, text, th-compat, transformers + , unordered-containers, vector }: mkDerivation { pname = "grisette"; - version = "0.2.0.0"; - sha256 = "0l7aal879xb5zlfa78rsijiw68h6q4qkfcqp5gnwajf3lcymy8gx"; + version = "0.3.1.0"; + sha256 = "0cph7bid3qx6zqnyhr8vaixr0mjf6hkfp0pi3h47rzrj0mm2ph3v"; libraryHaskellDepends = [ array base bytestring call-stack deepseq generic-deriving hashable - hashtables intern loch-th mtl once parallel sbv template-haskell - th-compat transformers unordered-containers vector + hashtables intern loch-th mtl parallel prettyprinter QuickCheck sbv + template-haskell text th-compat transformers unordered-containers + vector ]; testHaskellDepends = [ array base bytestring call-stack deepseq doctest generic-deriving - Glob hashable hashtables intern loch-th mtl once parallel sbv tasty - tasty-hunit tasty-quickcheck tasty-test-reporter template-haskell - th-compat transformers unordered-containers vector + Glob hashable hashtables intern loch-th mtl parallel prettyprinter + QuickCheck sbv tasty tasty-hunit tasty-quickcheck + tasty-test-reporter template-haskell text th-compat transformers + unordered-containers vector ]; description = "Symbolic evaluation as a library"; license = lib.licenses.bsd3; @@ -124001,6 +123534,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 @@ -124038,12 +123573,12 @@ self: { }) {}; "groups-generic" = callPackage - ({ mkDerivation, base, generic-data, groups }: + ({ mkDerivation, base, groups }: mkDerivation { pname = "groups-generic"; version = "0.3.1.0"; sha256 = "1v9mw478x6kfv38m13kypfmz9w8vn3xkvff3gy9g7x29aq5bvjfy"; - libraryHaskellDepends = [ base generic-data groups ]; + libraryHaskellDepends = [ base groups ]; description = "Generically derive Group instances"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -124251,6 +123786,7 @@ self: { libraryHaskellDepends = [ base hierarchical-clustering ]; description = "Generic implementation of Gerstein/Sonnhammer/Chothia weighting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "gscholar-rss" = callPackage @@ -125178,16 +124714,16 @@ self: { }) {}; "h-raylib" = callPackage - ({ mkDerivation, base, c, containers, lens, libGL, libX11 - , libXcursor, libXext, libXi, libXinerama, libXrandr + ({ mkDerivation, base, c, containers, exceptions, lens, libGL + , libX11, libXcursor, libXext, libXi, libXinerama, libXrandr }: mkDerivation { pname = "h-raylib"; - version = "4.6.0.4"; - sha256 = "1x9fz0ilvzj75nh4lcwz6w2fjmmbxymd7bfqivc04zz6d4wscli3"; + version = "4.6.0.6"; + sha256 = "0hq60qb10izjgc8d44762cj5fvnb93qs4ajaqcmjn11kj01z8a8q"; isLibrary = true; isExecutable = true; - libraryHaskellDepends = [ base containers lens ]; + libraryHaskellDepends = [ base containers exceptions lens ]; librarySystemDepends = [ c libGL libX11 libXcursor libXext libXi libXinerama libXrandr ]; @@ -125281,6 +124817,7 @@ self: { ]; description = "Control your Arduino board from Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hBDD" = callPackage @@ -125523,6 +125060,7 @@ self: { ]; description = "native Haskell implementation of OpenPGP (RFC4880)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "hPDB" = callPackage @@ -126279,40 +125817,6 @@ self: { }) {}; "hackage-cli" = callPackage - ({ mkDerivation, aeson, base, bytestring, Cabal, containers - , deepseq, directory, filepath, http-io-streams, io-streams - , microlens, microlens-mtl, microlens-th, mtl, netrc - , optparse-applicative, pretty, process-extras, semigroups - , stringsearch, tagsoup, tar, tasty, tasty-golden, text, time - , unordered-containers, zlib - }: - mkDerivation { - pname = "hackage-cli"; - version = "0.0.3.6"; - sha256 = "1wnh3571mgwyl9c5bfkwvr4rvsnw41qb9mlz1nda1ya53qfdjl4p"; - revision = "1"; - editedCabalFile = "06225nrw6icdlkcxp0wnh006fxsnyfpl55i9qm7pgybxb3qgf8l0"; - isLibrary = false; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring Cabal containers mtl pretty - ]; - executableHaskellDepends = [ - aeson base bytestring Cabal containers deepseq directory filepath - http-io-streams io-streams microlens microlens-mtl microlens-th mtl - netrc optparse-applicative process-extras semigroups stringsearch - tagsoup tar text time unordered-containers zlib - ]; - testHaskellDepends = [ - base bytestring Cabal filepath tasty tasty-golden - ]; - doHaddock = false; - description = "CLI tool for Hackage"; - license = lib.licenses.gpl3Plus; - mainProgram = "hackage-cli"; - }) {}; - - "hackage-cli_0_1_0_1" = callPackage ({ mkDerivation, aeson, base, bytestring, Cabal, containers , deepseq, directory, filepath, http-io-streams, io-streams , microlens, microlens-mtl, microlens-th, mtl, netrc @@ -126324,8 +125828,8 @@ self: { pname = "hackage-cli"; version = "0.1.0.1"; sha256 = "023gnhdxwn36k3pd74j5jcykqbrj7nvp131mg761h8913h9ldw1r"; - revision = "1"; - editedCabalFile = "02cipwmyj1vwmy21ldsf6ix5qi73vk6mzx9db88rs29ys090b2cw"; + revision = "3"; + editedCabalFile = "10sy9bf7kqibqmpjdhh6lbbqs7yyzlpim7za76v8pkm638hvn56x"; isLibrary = false; isExecutable = true; libraryHaskellDepends = [ @@ -126343,7 +125847,6 @@ self: { doHaddock = false; description = "CLI tool for Hackage"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; mainProgram = "hackage-cli"; }) {}; @@ -126492,8 +125995,8 @@ self: { pname = "hackage-repo-tool"; version = "0.1.1.3"; sha256 = "13q81gi3xmkzwfrbyk5dwxws3c92vnrlslksi021iasmjwhw2h6l"; - revision = "2"; - editedCabalFile = "10zh1wwn3n0kbybdacd3sg0izvw6xa6aadxdc0bzm9mf0g8m9ff7"; + revision = "3"; + editedCabalFile = "0kiqfglppvwb718z05chwpl50bv5yfvrfx67w5qhx4kpi4bsxcvs"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -126518,8 +126021,8 @@ self: { pname = "hackage-security"; version = "0.6.2.3"; sha256 = "0rm0avcc1k247qbrajhzi3vz92cgcc4nr3kbhhfmfm8rjxv0bvjj"; - revision = "3"; - editedCabalFile = "1vdmpklil8a6r03ixzch5d36ngimmq5q8931i8bg9f7hh8nmq8jv"; + revision = "5"; + editedCabalFile = "031x30yn0wbbniy4ykfnxcxyha0v6d9lk8290fcpm5p89qrr6n1f"; libraryHaskellDepends = [ base base16-bytestring base64-bytestring bytestring Cabal Cabal-syntax containers cryptohash-sha256 directory ed25519 @@ -126543,8 +126046,8 @@ self: { pname = "hackage-security-HTTP"; version = "0.1.1.1"; sha256 = "14hp7gssf80b9937j7m56w8sxrv3hrzjf2s9kgfk76v6llgx79k2"; - revision = "5"; - editedCabalFile = "0rbn1dp6vahxcjavksbwdw8v8mx31inhyn4mx3mx2x4f9rb7y6kw"; + revision = "6"; + editedCabalFile = "10y3yd4nlk71xwhkrwnw4bcnpp2wf2mkvf9ahx3n6qdcqjh1gk4s"; libraryHaskellDepends = [ base bytestring hackage-security HTTP mtl network network-uri zlib ]; @@ -126672,6 +126175,8 @@ self: { pname = "hackager"; version = "1.3.0.1"; sha256 = "0p7bwd8vcmsxd8mxvl2wdc7n4dmvh5rm230gzimrnkqi9kkl75k9"; + revision = "1"; + editedCabalFile = "1yzmqg2l3c2flvr8scgd5cgr0cvhphrrvvj4cc8hwc2phsv53qmj"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -126972,30 +126477,6 @@ self: { }) {}; "haddock-library" = callPackage - ({ mkDerivation, base, base-compat, bytestring, containers, deepseq - , directory, filepath, hspec, hspec-discover, optparse-applicative - , parsec, QuickCheck, text, transformers, tree-diff - }: - mkDerivation { - pname = "haddock-library"; - version = "1.10.0"; - sha256 = "15ak06q8yp11xz1hwr0sg2jqi3r78p1n89ik05hicqvxl3awf1pq"; - revision = "3"; - editedCabalFile = "1fnfcr3gvdjrya0czr3k2sqv4xmmvyv66yni2mckfppra93mcglg"; - libraryHaskellDepends = [ - base bytestring containers parsec text transformers - ]; - testHaskellDepends = [ - base base-compat bytestring containers deepseq directory filepath - hspec optparse-applicative parsec QuickCheck text transformers - tree-diff - ]; - testToolDepends = [ hspec-discover ]; - description = "Library exposing some functionality of Haddock"; - license = lib.licenses.bsd2; - }) {}; - - "haddock-library_1_11_0" = callPackage ({ mkDerivation, base, base-compat, containers, deepseq, directory , filepath, hspec, hspec-discover, optparse-applicative, parsec , QuickCheck, text, tree-diff @@ -127014,7 +126495,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Library exposing some functionality of Haddock"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "haddock-test" = callPackage @@ -127091,6 +126571,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Dockerfile Linter JavaScript API"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "hadolint"; }) {}; @@ -127261,6 +126742,8 @@ self: { ]; description = "A graph library offering mutable, immutable, and inductive graphs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haha" = callPackage @@ -127299,10 +126782,10 @@ self: { }) {}; "haiji" = callPackage - ({ mkDerivation, aeson, attoparsec, base, data-default, mtl - , process-extras, scientific, tagged, tasty, tasty-hunit, tasty-th - , template-haskell, text, transformers, unordered-containers - , vector + ({ mkDerivation, aeson, attoparsec, base, data-default, doctest + , filepath, mtl, process-extras, scientific, tagged, tasty + , tasty-hunit, tasty-th, template-haskell, text, transformers + , unordered-containers, vector }: mkDerivation { pname = "haiji"; @@ -127313,8 +126796,8 @@ self: { template-haskell text transformers unordered-containers vector ]; testHaskellDepends = [ - aeson base data-default process-extras tasty tasty-hunit tasty-th - text + aeson base data-default doctest filepath process-extras tasty + tasty-hunit tasty-th text ]; description = "A typed template engine, subset of jinja2"; license = lib.licenses.bsd3; @@ -127590,48 +127073,6 @@ self: { }) {}; "hakyll" = callPackage - ({ mkDerivation, aeson, base, binary, blaze-html, blaze-markup - , bytestring, containers, data-default, deepseq, directory - , file-embed, filepath, fsnotify, hashable, http-conduit - , http-types, lifted-async, lrucache, mtl, network-uri - , optparse-applicative, pandoc, parsec, process, QuickCheck, random - , regex-tdfa, resourcet, scientific, tagsoup, tasty, tasty-golden - , tasty-hunit, tasty-quickcheck, template-haskell, text, time - , time-locale-compat, unordered-containers, util-linux, vector, wai - , wai-app-static, warp, yaml - }: - mkDerivation { - pname = "hakyll"; - version = "4.15.1.1"; - sha256 = "0b3bw275q1xbx8qs9a6gzzs3c9z3qdj7skqhpp09jkchi5kdvhvi"; - revision = "9"; - editedCabalFile = "11zdqxmmykw2nbd8isc638cj03vrz8nkicyv35sn7jdw2p690ybh"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson base binary blaze-html blaze-markup bytestring containers - data-default deepseq directory file-embed filepath fsnotify - hashable http-conduit http-types lifted-async lrucache mtl - network-uri optparse-applicative pandoc parsec process random - regex-tdfa resourcet scientific tagsoup template-haskell text time - time-locale-compat unordered-containers vector wai wai-app-static - warp yaml - ]; - executableHaskellDepends = [ base directory filepath ]; - testHaskellDepends = [ - aeson base bytestring containers filepath QuickCheck tagsoup tasty - tasty-golden tasty-hunit tasty-quickcheck text unordered-containers - yaml - ]; - testToolDepends = [ util-linux ]; - description = "A static website compiler library"; - license = lib.licenses.bsd3; - mainProgram = "hakyll-init"; - maintainers = [ lib.maintainers.erictapen ]; - }) {inherit (pkgs) util-linux;}; - - "hakyll_4_16_0_0" = callPackage ({ mkDerivation, aeson, base, binary, blaze-html, blaze-markup , bytestring, containers, data-default, deepseq, directory , file-embed, filepath, fsnotify, hashable, http-conduit @@ -127667,7 +127108,6 @@ self: { testToolDepends = [ util-linux ]; description = "A static website compiler library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "hakyll-init"; maintainers = [ lib.maintainers.erictapen ]; }) {inherit (pkgs) util-linux;}; @@ -127879,7 +127319,9 @@ self: { ]; description = "Convert from other blog engines to Hakyll"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "hakyll-convert"; + broken = true; }) {}; "hakyll-dhall" = callPackage @@ -127956,8 +127398,8 @@ self: { }: mkDerivation { pname = "hakyll-filestore"; - version = "0.1.10"; - sha256 = "1wj2qb32ys2czmj0f2jp2fqd0khma4nrdgb2d76vrm8j77bsm7vm"; + version = "0.1.11"; + sha256 = "1gfyibnazvanrywl9bcb3y2frpp4n1cvx0c8m6cx8vmdwslwmrnv"; libraryHaskellDepends = [ base filestore hakyll time time-locale-compat ]; @@ -127972,8 +127414,8 @@ self: { }: mkDerivation { pname = "hakyll-images"; - version = "1.2.0"; - sha256 = "0y15saxicm3i7ix8nzhhzcr4v9kpsgm22w2sv46107iabfhwna46"; + version = "1.2.1"; + sha256 = "08vbkjf3nnl7dwz5r4vzgbylpql0b3xgnw7ivhxmc2k2sqzgs2rp"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base binary bytestring hakyll JuicyPixels JuicyPixels-extra @@ -128123,6 +127565,8 @@ self: { pname = "hal"; version = "1.0.0.1"; sha256 = "1gdd0nbwm6hma57nw1y1gd0cc6z9zhhmim6l5miql2j6dk909mdv"; + revision = "1"; + editedCabalFile = "0gcgy18sdhvxb9akzz4akljjhbxkxdk0vihdnnkyq6ilr740cxqd"; libraryHaskellDepends = [ aeson base base64-bytestring bytestring case-insensitive conduit conduit-extra containers exceptions hashable http-client http-types @@ -128135,6 +127579,8 @@ self: { ]; description = "A runtime environment for Haskell applications running on AWS Lambda"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "halberd" = callPackage @@ -128230,8 +127676,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "halfsplit"; - version = "0.1.0.0"; - sha256 = "1idrik8w0z913n4jdba7m58i63krzxf4kv35rm5k8yr8w30xxr7i"; + version = "0.2.0.0"; + sha256 = "1z434f5zw6riqa6b5k0ism80j6wcx6sgvicz6wl9winz0mxzg9gv"; libraryHaskellDepends = [ base ]; description = "A library to provide special kind of two-column terminal output for Phladiprelio"; license = lib.licenses.mit; @@ -128249,6 +127695,7 @@ self: { description = "Integration between Halide and JuicyPixels"; license = lib.licenses.bsd3; platforms = lib.platforms.linux; + hydraPlatforms = lib.platforms.none; }) {}; "halide-arrayfire" = callPackage @@ -128287,6 +127734,8 @@ self: { description = "Haskell bindings to Halide"; license = lib.licenses.bsd3; platforms = lib.platforms.linux; + hydraPlatforms = lib.platforms.none; + broken = true; }) {Halide = null;}; "halipeto" = callPackage @@ -129206,6 +128655,7 @@ self: { ]; description = "Happstack Authentication Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-clientsession" = callPackage @@ -129222,6 +128672,8 @@ self: { ]; description = "client-side session data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-contrib" = callPackage @@ -129375,6 +128827,7 @@ self: { ]; description = "Glue code for using Happstack with acid-state, web-routes, reform, and HSP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "happstack-hamlet" = callPackage @@ -129512,6 +128965,8 @@ self: { ]; description = "Happstack minus the useless stuff"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "happstack-monad-peel" = callPackage @@ -129548,34 +129003,6 @@ self: { }) {}; "happstack-server" = callPackage - ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring - , containers, directory, exceptions, extensible-exceptions - , filepath, hslogger, html, HUnit, monad-control, mtl, network - , network-uri, old-locale, parsec, process, semigroups, sendfile - , syb, system-filepath, text, threads, time, transformers - , transformers-base, transformers-compat, unix, utf8-string, xhtml - , zlib - }: - mkDerivation { - pname = "happstack-server"; - version = "7.7.2"; - sha256 = "175aal1l4g558y89skck3s04db0bjblkxp77bijf1s9iyc07n669"; - libraryHaskellDepends = [ - base base64-bytestring blaze-html bytestring containers directory - exceptions extensible-exceptions filepath hslogger html - monad-control mtl network network-uri old-locale parsec process - semigroups sendfile syb system-filepath text threads time - transformers transformers-base transformers-compat unix utf8-string - xhtml zlib - ]; - testHaskellDepends = [ - base bytestring containers HUnit parsec zlib - ]; - description = "Web related tools and services"; - license = lib.licenses.bsd3; - }) {}; - - "happstack-server_7_8_0_2" = callPackage ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring , containers, directory, exceptions, extensible-exceptions , filepath, hslogger, html, HUnit, monad-control, mtl, network @@ -129600,7 +129027,6 @@ self: { ]; description = "Web related tools and services"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "happstack-server-tls" = callPackage @@ -130530,10 +129956,9 @@ self: { }) {}; "hashable" = callPackage - ({ mkDerivation, base, bytestring, containers, data-array-byte - , deepseq, filepath, ghc-bignum, ghc-prim, HUnit, QuickCheck - , random, test-framework, test-framework-hunit - , test-framework-quickcheck2, text, unix + ({ mkDerivation, base, bytestring, containers, deepseq, filepath + , ghc-bignum, ghc-prim, HUnit, QuickCheck, random, test-framework + , test-framework-hunit, test-framework-quickcheck2, text, unix }: mkDerivation { pname = "hashable"; @@ -130542,8 +129967,8 @@ self: { revision = "1"; editedCabalFile = "12nmnmm2kyjalkvmz0l1l895ikc938lwppx8iykxnhamblrr4msq"; libraryHaskellDepends = [ - base bytestring containers data-array-byte deepseq filepath - ghc-bignum ghc-prim text + base bytestring containers deepseq filepath ghc-bignum ghc-prim + text ]; testHaskellDepends = [ base bytestring ghc-prim HUnit QuickCheck random test-framework @@ -130669,6 +130094,33 @@ self: { broken = true; }) {}; + "hasherize" = callPackage + ({ mkDerivation, base, base16-bytestring, bytestring, cassava + , containers, cryptohash-sha256, directory, envparse, file-io + , filepath, ki, mtl, qsem, quaalude, safe-exceptions, stm, text + , unfork, vector + }: + mkDerivation { + pname = "hasherize"; + version = "0.0.0.0"; + sha256 = "0253ycr4x8bl6qgzr14wrzkl170l8xfjajmjgrnd1dlrbwi9hfbn"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers cryptohash-sha256 directory file-io + filepath mtl quaalude text + ]; + executableHaskellDepends = [ + base base16-bytestring bytestring cassava containers + cryptohash-sha256 directory envparse file-io filepath ki mtl qsem + quaalude safe-exceptions stm text unfork vector + ]; + description = "Hash digests for files and directories"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + mainProgram = "hasherize"; + }) {}; + "hashes" = callPackage ({ mkDerivation, base, bytestring, criterion, openssl, QuickCheck , sha-validation, sydtest, vector @@ -130707,8 +130159,8 @@ self: { ({ mkDerivation, base, bytestring, containers, hedgehog, split }: mkDerivation { pname = "hashids"; - version = "1.0.2.7"; - sha256 = "1zl43g73czc4253a235vnnsv64m5rf7337q7qjgfrfb0pjyxsj55"; + version = "1.1.0.1"; + sha256 = "0h4bvcg1aaprd4xkn8la4pmp4yjpdniam0yqf4akyrznspn76a6f"; libraryHaskellDepends = [ base bytestring containers split ]; testHaskellDepends = [ base bytestring containers hedgehog split ]; description = "Hashids generates short, unique, non-sequential ids from numbers"; @@ -131996,7 +131448,8 @@ self: { , hls-explicit-fixity-plugin, hls-explicit-imports-plugin , hls-explicit-record-fields-plugin, hls-floskell-plugin , hls-fourmolu-plugin, hls-gadt-plugin, hls-graph, hls-hlint-plugin - , hls-module-name-plugin, hls-ormolu-plugin, hls-plugin-api + , hls-module-name-plugin, hls-ormolu-plugin + , hls-overloaded-record-dot-plugin, hls-plugin-api , hls-pragmas-plugin, hls-qualify-imported-names-plugin , hls-refactor-plugin, hls-refine-imports-plugin, hls-rename-plugin , hls-retrie-plugin, hls-splice-plugin, hls-stylish-haskell-plugin @@ -132009,8 +131462,8 @@ self: { }: mkDerivation { pname = "haskell-language-server"; - version = "2.0.0.0"; - sha256 = "08jw3wlr9kq8jwd23gh5gnals7rks189aypjxavq898y3wdlkgyh"; + version = "2.0.0.1"; + sha256 = "1d3cgsr842czd92ay30yf9xm6bm1q6yvi6yjxsmb42mncdgh3wqr"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -132023,9 +131476,10 @@ self: { hls-explicit-imports-plugin hls-explicit-record-fields-plugin hls-floskell-plugin hls-fourmolu-plugin hls-gadt-plugin hls-graph hls-hlint-plugin hls-module-name-plugin hls-ormolu-plugin - hls-plugin-api hls-pragmas-plugin hls-qualify-imported-names-plugin - hls-refactor-plugin hls-refine-imports-plugin hls-rename-plugin - hls-retrie-plugin hls-splice-plugin hls-stylish-haskell-plugin lsp + hls-overloaded-record-dot-plugin hls-plugin-api hls-pragmas-plugin + hls-qualify-imported-names-plugin hls-refactor-plugin + hls-refine-imports-plugin hls-rename-plugin hls-retrie-plugin + hls-splice-plugin hls-stylish-haskell-plugin lsp optparse-applicative optparse-simple prettyprinter process safe-exceptions sqlite-simple text unordered-containers ]; @@ -133950,6 +133404,8 @@ self: { ]; description = "B+-tree implementation in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "haskey-mtl" = callPackage @@ -134042,7 +133498,9 @@ self: { executableHaskellDepends = [ base ]; description = "Haskell Evaluation inside of LaTeX code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "haskintex"; + broken = true; }) {}; "hasklepias" = callPackage @@ -134174,6 +133632,38 @@ self: { license = lib.licenses.mit; }) {}; + "haskoin-core_0_22_0" = callPackage + ({ mkDerivation, aeson, array, base, base16, base64, binary, bytes + , bytestring, cereal, conduit, containers, cryptonite, deepseq + , entropy, hashable, hspec, hspec-discover, HUnit, lens, lens-aeson + , memory, mtl, murmur3, network, QuickCheck, safe, scientific + , secp256k1-haskell, split, string-conversions, text, time + , transformers, unordered-containers, vector + }: + mkDerivation { + pname = "haskoin-core"; + version = "0.22.0"; + sha256 = "1a8gzlpx7cgdsdsxxqmp7girm19aliszna08cpkk70jigkv2bmm9"; + libraryHaskellDepends = [ + aeson array base base16 binary bytes bytestring cereal conduit + containers cryptonite deepseq entropy hashable hspec memory mtl + murmur3 network QuickCheck safe scientific secp256k1-haskell split + string-conversions text time transformers unordered-containers + vector + ]; + testHaskellDepends = [ + aeson array base base16 base64 binary bytes bytestring cereal + conduit containers cryptonite deepseq entropy hashable hspec HUnit + lens lens-aeson memory mtl murmur3 network QuickCheck safe + scientific secp256k1-haskell split string-conversions text time + transformers unordered-containers vector + ]; + testToolDepends = [ hspec-discover ]; + description = "Bitcoin & Bitcoin Cash library for Haskell"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "haskoin-crypto" = callPackage ({ mkDerivation, base, binary, byteable, bytestring, containers , cryptohash, haskoin-util, HUnit, mtl, QuickCheck, test-framework @@ -134228,6 +133718,38 @@ self: { license = lib.licenses.mit; }) {}; + "haskoin-node_0_19_0" = callPackage + ({ mkDerivation, base, base64, bytestring, cereal, conduit + , conduit-extra, containers, data-default, hashable, haskoin-core + , hspec, hspec-discover, HUnit, monad-logger, mtl, network, nqe + , random, resourcet, rocksdb-haskell-jprupp, rocksdb-query, safe + , string-conversions, text, time, transformers, unliftio + , unordered-containers + }: + mkDerivation { + pname = "haskoin-node"; + version = "0.19.0"; + sha256 = "1r6kr7jysqm9rzmckd51v50q8z2vn5ygl9xxfgr02r4xvs8phvxh"; + libraryHaskellDepends = [ + base bytestring cereal conduit conduit-extra containers + data-default hashable haskoin-core monad-logger mtl network nqe + random resourcet rocksdb-haskell-jprupp rocksdb-query + string-conversions text time transformers unliftio + unordered-containers + ]; + testHaskellDepends = [ + base base64 bytestring cereal conduit conduit-extra containers + data-default hashable haskoin-core hspec HUnit monad-logger mtl + network nqe random resourcet rocksdb-haskell-jprupp rocksdb-query + safe string-conversions text time transformers unliftio + unordered-containers + ]; + testToolDepends = [ hspec-discover ]; + description = "P2P library for Bitcoin and Bitcoin Cash"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "haskoin-protocol" = callPackage ({ mkDerivation, base, binary, bytestring, haskoin-crypto , haskoin-util, HUnit, QuickCheck, test-framework @@ -135408,8 +134930,8 @@ self: { pname = "hasql-interpolate"; version = "0.1.0.4"; sha256 = "1b3q21m25wxjxrprfr24b2ay94yjjaqs0p2x6s1d9cqagmznh9v0"; - revision = "1"; - editedCabalFile = "17ayrlqrf0hy2val7c4hbh7zfxq5i6d5x2pa09nkbdbhh6acas6g"; + revision = "2"; + editedCabalFile = "1iz6mr5pnfysbflcbrxlk1h4cw9ipw8k3jplyhw41lip1yvblnjy"; libraryHaskellDepends = [ aeson array base bytestring containers haskell-src-meta hasql megaparsec mtl scientific template-haskell text time transformers @@ -135482,15 +135004,16 @@ self: { }) {}; "hasql-optparse-applicative" = callPackage - ({ mkDerivation, base-prelude, hasql, hasql-pool - , optparse-applicative + ({ mkDerivation, attoparsec, attoparsec-time, base, hasql + , hasql-pool, optparse-applicative }: mkDerivation { pname = "hasql-optparse-applicative"; - version = "0.5"; - sha256 = "1bc7vknc6kq8ljbzf0hpqaps6jp1wrggx2kx4fvvqmw90z83vz28"; + version = "0.7"; + sha256 = "0kngkykspy20by86psdjf40m4lm7v1bs5f5w1lqn98dmlnvpqxd9"; libraryHaskellDepends = [ - base-prelude hasql hasql-pool optparse-applicative + attoparsec attoparsec-time base hasql hasql-pool + optparse-applicative ]; description = "\"optparse-applicative\" parsers for \"hasql\""; license = lib.licenses.mit; @@ -135529,15 +135052,15 @@ self: { }) {}; "hasql-pool" = callPackage - ({ mkDerivation, async, base, hasql, hspec, rerebase, stm - , transformers + ({ mkDerivation, async, base, hasql, hspec, random, rerebase, stm + , time }: mkDerivation { pname = "hasql-pool"; - version = "0.8.0.7"; - sha256 = "16s0k60ffa7bflj0n6diprs3rbm5ywfbfvv1qwv45zwhxlyd622x"; - libraryHaskellDepends = [ base hasql stm transformers ]; - testHaskellDepends = [ async hasql hspec rerebase stm ]; + version = "0.9.0.1"; + sha256 = "00p06yjyasdcv9f7wn29c9il08drcym65k0xnh7kzyma871wv7yq"; + libraryHaskellDepends = [ base hasql stm time ]; + testHaskellDepends = [ async hasql hspec random rerebase ]; description = "Pool of connections for Hasql"; license = lib.licenses.mit; }) {}; @@ -135836,6 +135359,8 @@ self: { ]; description = "Perform IO actions during transactions for Hasql"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hasql-url" = callPackage @@ -135864,8 +135389,8 @@ self: { }: mkDerivation { pname = "hasqlator-mysql"; - version = "0.1.0"; - sha256 = "0pkgnx54f4487rc9i5286g3xm9kb6g8fhgbqn4p2yddl8mwzpdby"; + version = "0.2.0"; + sha256 = "1dl72axgr6jaz9m243krys9x2svsrc7rnanc4pfvjx9w5648j3mq"; libraryHaskellDepends = [ aeson base binary bytestring containers dlist io-streams megaparsec mtl mysql-haskell optics-core pretty-simple prettyprinter @@ -136678,7 +136203,6 @@ self: { libraryHaskellDepends = [ base bytestring Decimal digits split ]; description = "Packed binary-coded decimal (BCD) serialization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hbeanstalk" = callPackage @@ -137207,8 +136731,8 @@ self: { }: mkDerivation { pname = "hdaemonize"; - version = "0.5.6"; - sha256 = "097fgjgskigy3grnd3ijzyhdq34vjmd9bjk2rscixi59j8j30vxd"; + version = "0.5.7"; + sha256 = "06zh4z3xg98badbg91lf3kwy88n39ww7c1f06lija8zciql2723l"; libraryHaskellDepends = [ base bytestring extensible-exceptions filepath hsyslog mtl unix ]; @@ -137709,21 +137233,6 @@ self: { }) {}; "headed-megaparsec" = callPackage - ({ mkDerivation, base, case-insensitive, megaparsec - , parser-combinators, selective - }: - mkDerivation { - pname = "headed-megaparsec"; - version = "0.2.1.1"; - sha256 = "1fzvzggw09kbd75rwdb5qfc2fc497yzwkxrmqa1xjwcdspnmrxrl"; - libraryHaskellDepends = [ - base case-insensitive megaparsec parser-combinators selective - ]; - description = "More informative parser"; - license = lib.licenses.mit; - }) {}; - - "headed-megaparsec_0_2_1_2" = callPackage ({ mkDerivation, base, case-insensitive, megaparsec , parser-combinators, selective }: @@ -137736,7 +137245,6 @@ self: { ]; description = "More informative parser"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "headergen" = callPackage @@ -137918,6 +137426,8 @@ self: { libraryHaskellDepends = [ async base io-streams time ]; description = "Heartbeats for io-streams"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "heatitup" = callPackage @@ -137972,7 +137482,9 @@ self: { ]; description = "Find and annotate ITDs with assembly or read pair joining"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "heatitup-complete"; + broken = true; }) {}; "heatshrink" = callPackage @@ -138170,8 +137682,10 @@ self: { }: mkDerivation { pname = "hedgehog"; - version = "1.1.2"; - sha256 = "0dbk75hk6hqpzkjdlpw3s63qhm42kqigij33p321by6xndb59jg1"; + version = "1.2"; + sha256 = "0zlfmzzancsglzqmdr40kdfk3ih7anssfkb196r0n9b5lvdcfn98"; + revision = "1"; + editedCabalFile = "1am5x5y2zzfii2zk6w8kbw6rv8c4y272vsl5213f99ypvbqv086b"; libraryHaskellDepends = [ ansi-terminal async barbies base bytestring concurrent-output containers deepseq directory erf exceptions lifted-async mmorph @@ -138187,25 +137701,24 @@ self: { maintainers = [ lib.maintainers.maralorn ]; }) {}; - "hedgehog_1_2" = callPackage + "hedgehog_1_3" = callPackage ({ mkDerivation, ansi-terminal, async, barbies, base, bytestring , concurrent-output, containers, deepseq, directory, erf , exceptions, lifted-async, mmorph, monad-control, mtl, pretty-show - , primitive, random, resourcet, stm, template-haskell, text, time - , transformers, transformers-base, wl-pprint-annotated + , primitive, random, resourcet, safe-exceptions, stm + , template-haskell, text, time, transformers, transformers-base + , wl-pprint-annotated }: mkDerivation { pname = "hedgehog"; - version = "1.2"; - sha256 = "0zlfmzzancsglzqmdr40kdfk3ih7anssfkb196r0n9b5lvdcfn98"; - revision = "1"; - editedCabalFile = "1am5x5y2zzfii2zk6w8kbw6rv8c4y272vsl5213f99ypvbqv086b"; + version = "1.3"; + sha256 = "1lkxmccjghdr7s02gwbzlhhwndpcrgi5a4a3yy2qq73xkcr3nqsg"; libraryHaskellDepends = [ ansi-terminal async barbies base bytestring concurrent-output containers deepseq directory erf exceptions lifted-async mmorph - monad-control mtl pretty-show primitive random resourcet stm - template-haskell text time transformers transformers-base - wl-pprint-annotated + monad-control mtl pretty-show primitive random resourcet + safe-exceptions stm template-haskell text time transformers + transformers-base wl-pprint-annotated ]; testHaskellDepends = [ base containers mmorph mtl pretty-show text transformers @@ -138287,8 +137800,8 @@ self: { }: mkDerivation { pname = "hedgehog-extras"; - version = "0.4.5.2"; - sha256 = "1kdgjxdf9irk7sd8nlqxzppvppp9q6fcffhwpw3n62rf5rnsb6g3"; + version = "0.4.7.0"; + sha256 = "08144dhnnbbl7mmlypx4ji6hsifjf4ssvqh3zhyjk6zwnj5jng13"; libraryHaskellDepends = [ aeson aeson-pretty async base bytestring deepseq Diff directory exceptions filepath hedgehog http-conduit hw-aeson mmorph mtl @@ -138411,14 +137924,16 @@ self: { libraryHaskellDepends = [ base hedgehog lens ]; description = "Hedgehog properties for lens laws"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hedgehog-optics" = callPackage ({ mkDerivation, base, hedgehog, optics-core }: mkDerivation { pname = "hedgehog-optics"; - version = "1.0.0.2"; - sha256 = "0i39s3ajrfdf87qy8i2k5v4dh42snc3jw4ar49c9hc76gzhxw2qj"; + version = "1.0.0.3"; + sha256 = "0nvl8bqnry16irnqcsp03q7mxf21idydg3wzcyp0s1i99l9y26kx"; libraryHaskellDepends = [ base hedgehog optics-core ]; description = "Hedgehog properties for optics laws"; license = lib.licenses.mit; @@ -138430,8 +137945,8 @@ self: { pname = "hedgehog-quickcheck"; version = "0.1.1"; sha256 = "1z2ja63wqz83qhwzh0zs98k502v8fjdpnsnhqk3srypx2nw5vdlp"; - revision = "4"; - editedCabalFile = "1838hm2p22n8qrps17zjzf9k0jwvrw9g99r0crii3igfbi22m8nf"; + revision = "5"; + editedCabalFile = "0l5fn4z4n80h99baxhsqsq3dqxli9hl0xwjgxbs12kz59w667ml1"; libraryHaskellDepends = [ base hedgehog QuickCheck transformers ]; description = "Use QuickCheck generators in Hedgehog and vice versa"; license = lib.licenses.bsd3; @@ -138661,20 +138176,19 @@ self: { }) {}; "hegg" = callPackage - ({ mkDerivation, base, containers, deriving-compat, tasty - , tasty-bench, tasty-hunit, tasty-quickcheck, transformers + ({ mkDerivation, base, containers, tasty, tasty-bench, tasty-hunit + , tasty-quickcheck, transformers }: mkDerivation { pname = "hegg"; - version = "0.3.0.0"; - sha256 = "08hprlz70vxv759fr15hb95p7fj6qmnahjxvalj3db9rw5xqs4ia"; + version = "0.4.0.0"; + sha256 = "1nhxmf90965752skn3wcyjavi2amfxhlyrh60lmslm08w2wk14sk"; libraryHaskellDepends = [ base containers transformers ]; testHaskellDepends = [ - base containers deriving-compat tasty tasty-hunit tasty-quickcheck + base containers tasty tasty-hunit tasty-quickcheck ]; benchmarkHaskellDepends = [ - base containers deriving-compat tasty tasty-bench tasty-hunit - tasty-quickcheck + base containers tasty tasty-bench tasty-hunit tasty-quickcheck ]; description = "Fast equality saturation in Haskell"; license = lib.licenses.bsd3; @@ -138742,8 +138256,8 @@ self: { pname = "heist"; version = "1.1.1.1"; sha256 = "0s6ydncib0g4mdmx4vzwmp1cnbvxrb2pngvkd5jc5kn5vb3g929l"; - revision = "1"; - editedCabalFile = "0xc29737ms9qvvbw9n1xgd5c73lxm7hjwgigaabml9sy6s8i1fi5"; + revision = "2"; + editedCabalFile = "0xgigspz2wbszs1vmx8ykp6b7j87j2r346pay0wdrpx8hqyzzjfl"; libraryHaskellDepends = [ aeson attoparsec base blaze-builder blaze-html bytestring containers directory directory-tree dlist filepath hashable @@ -138861,6 +138375,8 @@ self: { ]; description = "Extra heist functionality"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "helf" = callPackage @@ -138884,38 +138400,35 @@ self: { }) {}; "helic" = callPackage - ({ mkDerivation, aeson, base, chronos, containers, exon - , fast-logger, gi-gdk, gi-glib, gi-gtk, hostname, http-client - , http-client-tls, incipit, optparse-applicative, path, path-io - , polysemy, polysemy-chronos, polysemy-conc, polysemy-http + ({ mkDerivation, base, chronos, containers, exon, fast-logger + , gi-gdk, gi-glib, gi-gtk, hostname, optparse-applicative, path + , path-io, polysemy, polysemy-chronos, polysemy-conc, polysemy-http , polysemy-log, polysemy-plugin, polysemy-process, polysemy-test - , polysemy-time, servant, servant-client, servant-client-core - , servant-server, table-layout, tasty, template-haskell - , terminal-size, torsor, transformers, typed-process, unix - , wai-extra, warp, yaml + , polysemy-time, prelate, random, servant-client, servant-server + , table-layout, tasty, terminal-size, torsor, transformers + , typed-process, wai-extra, warp, yaml, zeugma }: mkDerivation { pname = "helic"; - version = "0.5.3.0"; - sha256 = "1pfsa9g13d79byyr703jlfs57a18a7ybi46z8dx6gavhl53z32j7"; + version = "0.6.1.0"; + sha256 = "0zwgnhgm571a62bxgvc7gwrbi1klydby0gb6j21y28h3cx12m1a5"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson base chronos exon fast-logger gi-gdk gi-glib gi-gtk hostname - http-client http-client-tls incipit optparse-applicative path - path-io polysemy polysemy-chronos polysemy-conc polysemy-http - polysemy-log polysemy-plugin polysemy-process polysemy-time servant - servant-client servant-client-core servant-server table-layout - template-haskell terminal-size transformers typed-process unix - wai-extra warp yaml + base chronos exon fast-logger gi-gdk gi-glib gi-gtk hostname + optparse-applicative path path-io polysemy polysemy-chronos + polysemy-conc polysemy-http polysemy-log polysemy-plugin + polysemy-process polysemy-time prelate servant-client + servant-server table-layout terminal-size transformers + typed-process wai-extra warp yaml ]; executableHaskellDepends = [ - base incipit polysemy polysemy-plugin + base polysemy polysemy-plugin prelate ]; testHaskellDepends = [ - base chronos containers exon incipit path polysemy polysemy-chronos - polysemy-conc polysemy-log polysemy-plugin polysemy-test - polysemy-time tasty torsor + base chronos containers exon path polysemy polysemy-chronos + polysemy-log polysemy-plugin polysemy-test prelate random tasty + torsor zeugma ]; description = "Clipboard Manager"; license = "BSD-2-Clause-Patent"; @@ -139335,9 +138848,9 @@ self: { , conduit-extra, containers, directory, dlist, exceptions, filepath , hercules-ci-api, hercules-ci-api-agent, hercules-ci-api-core , hercules-ci-cnix-expr, hercules-ci-cnix-store, hostname, hspec - , http-client, http-client-tls, http-conduit, inline-c - , inline-c-cpp, katip, lens, lens-aeson, lifted-async, lifted-base - , monad-control, mtl, network, network-uri, nix + , hspec-discover, http-client, http-client-tls, http-conduit + , inline-c, inline-c-cpp, katip, lens, lens-aeson, lifted-async + , lifted-base, monad-control, mtl, network, network-uri, nix , optparse-applicative, process, process-extras, protolude , safe-exceptions, scientific, servant, servant-auth-client , servant-client, servant-client-core, stm, tagged, temporary, text @@ -139347,8 +138860,8 @@ self: { }: mkDerivation { pname = "hercules-ci-agent"; - version = "0.9.11"; - sha256 = "1y0n4vfxf84r5jw02vciwks6snj35zhy789nsixxv8jba6scnf66"; + version = "0.9.12"; + sha256 = "0fs5ycnig0s7wwrshpx2fhi7iib59bnnddsjvb5s06y9gvla6xq0"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -139385,8 +138898,9 @@ self: { hercules-ci-api-core hercules-ci-cnix-store hspec katip lifted-async lifted-base monad-control mtl process protolude safe-exceptions stm tagged temporary text transformers-base - unliftio-core + unliftio-core vector ]; + testToolDepends = [ hspec-discover ]; description = "Runs Continuous Integration tasks on your machines"; license = lib.licenses.asl20; maintainers = [ lib.maintainers.roberth ]; @@ -139402,8 +138916,8 @@ self: { }: mkDerivation { pname = "hercules-ci-api"; - version = "0.8.0.0"; - sha256 = "1ivlh6gxjdrrzgyafwglv145wz8ss77ayjv6lwfanaiq26x25vqk"; + version = "0.8.1.0"; + sha256 = "13zvw78mwx78sv858hz4bw65dck0v2kxwqv6skpfgzbyvg4h5f6i"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -139441,8 +138955,8 @@ self: { }: mkDerivation { pname = "hercules-ci-api-agent"; - version = "0.5.0.0"; - sha256 = "0j1yb091i4whlf8brj2n0x0dnqm01p56i2ns4p59xsx6k0z7hprv"; + version = "0.5.0.1"; + sha256 = "0d9cmf1amy4hdzlkmwaqyp469fmgh09a5090143sar9ss309r0sg"; libraryHaskellDepends = [ aeson base base64-bytestring-type bytestring containers cookie deepseq exceptions hashable hercules-ci-api-core http-api-data @@ -139469,8 +138983,8 @@ self: { }: mkDerivation { pname = "hercules-ci-api-core"; - version = "0.1.5.0"; - sha256 = "1f5fxivyy5fkchr5b8na2fxrmp4p7av61a28grsp7n0ndik1lfgd"; + version = "0.1.5.1"; + sha256 = "0mlas84ndkp9269qapzfqcc86mcr0nw5vfpc2l0a6ymk1z05nrq4"; libraryHaskellDepends = [ aeson base bytestring containers cookie deepseq exceptions hashable http-api-data http-media katip lens lifted-base memory @@ -139539,8 +139053,8 @@ self: { }: mkDerivation { pname = "hercules-ci-cnix-expr"; - version = "0.3.5.1"; - sha256 = "0l4267n0h272snfrbw6phhlrdn8vmiv363b33iv0yh9mnp0d3ya2"; + version = "0.3.6.0"; + sha256 = "15lyhj26zr9r3nqn3d7gwn4rppix8g4lanxs52wliq7jxxaga28i"; enableSeparateDataOutput = true; setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ]; libraryHaskellDepends = [ @@ -139569,8 +139083,8 @@ self: { }: mkDerivation { pname = "hercules-ci-cnix-store"; - version = "0.3.3.5"; - sha256 = "0mzpa1apijap1mbfshrw7dan897kikhdp5hpb2r0p1p5w7qxrl9l"; + version = "0.3.4.0"; + sha256 = "0f8vav9jj4251ym2xyj7wna3wc6dgsqdlpm7byhjdnwzqkw0pxw4"; setupHaskellDepends = [ base Cabal cabal-pkg-config-version-hook ]; libraryHaskellDepends = [ base bytestring conduit containers inline-c inline-c-cpp protolude @@ -139644,35 +139158,11 @@ self: { license = lib.licenses.bsd3; }) {}; - "hermes-json_0_2_0_1" = callPackage - ({ mkDerivation, aeson, attoparsec, attoparsec-iso8601, base - , bytestring, containers, deepseq, dlist, hedgehog, mtl, scientific - , tasty, tasty-hedgehog, text, time, time-compat, transformers - , unliftio, unliftio-core - }: - mkDerivation { - pname = "hermes-json"; - version = "0.2.0.1"; - sha256 = "1i10nmblh6zxbqpqk5z5r97334j6x37kgw459i4icm6c4hi55k4l"; - libraryHaskellDepends = [ - attoparsec attoparsec-iso8601 base bytestring deepseq dlist mtl - scientific text time time-compat transformers unliftio - unliftio-core - ]; - testHaskellDepends = [ - aeson base bytestring containers hedgehog scientific tasty - tasty-hedgehog text time - ]; - description = "Fast JSON decoding via simdjson C++ bindings"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "hermes-json" = callPackage ({ mkDerivation, aeson, attoparsec, attoparsec-iso8601, base , bytestring, containers, deepseq, dlist, hedgehog, primitive - , scientific, tasty, tasty-hedgehog, text, time, time-compat - , transformers, vector + , scientific, system-cxx-std-lib, tasty, tasty-hedgehog, text, time + , time-compat, transformers, vector }: mkDerivation { pname = "hermes-json"; @@ -139680,8 +139170,8 @@ self: { sha256 = "0d0vy74z0m9vcs5rngigsqd6642dfx40a8bzh5finwrwgjb9k2dk"; libraryHaskellDepends = [ attoparsec attoparsec-iso8601 base bytestring containers deepseq - dlist primitive scientific text time time-compat transformers - vector + dlist primitive scientific system-cxx-std-lib text time time-compat + transformers vector ]; testHaskellDepends = [ aeson base bytestring containers hedgehog scientific tasty @@ -139802,6 +139292,8 @@ self: { testHaskellDepends = [ base hspec persistent-postgresql ]; description = "Parse DATABASE_URL into configuration types for Persistent"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "herringbone" = callPackage @@ -140024,6 +139516,7 @@ self: { testHaskellDepends = [ base ]; description = "Hetzner Cloud and DNS library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "heukarya" = callPackage @@ -140046,21 +139539,21 @@ self: { ({ mkDerivation, abstract-par, aeson, aeson-optics, ansi-wl-pprint , array, async, base, base16, binary, brick, bytestring, cereal , containers, cryptonite, data-dword, Decimal, deepseq, directory - , filemanip, filepath, filepattern, free, gmp, haskeline, here - , HUnit, libff, megaparsec, memory, monad-par, mtl, multiset + , filemanip, filepath, filepattern, free, githash, gmp, haskeline + , here, HUnit, libff, megaparsec, memory, monad-par, mtl, multiset , operational, optics-core, optics-extra, optics-th , optparse-generic, process, QuickCheck, quickcheck-instances , quickcheck-text, regex, regex-tdfa, restless-git, rosezipper , scientific, secp256k1, smt2-parser, spawn, spool, stm, tasty , tasty-bench, tasty-expected-failure, tasty-hunit , tasty-quickcheck, temporary, text, time, transformers, tree-view - , tuple, unordered-containers, vector, vty, witherable, word-wrap - , wreq + , tuple, unordered-containers, vector, vty, witch, witherable + , word-wrap, wreq }: mkDerivation { pname = "hevm"; - version = "0.51.1"; - sha256 = "1q9yxkp8zvi31gi38snny6n906sdwnfbrxiammrh18gj2h0f1jxq"; + version = "0.51.3"; + sha256 = "0cfy72vxihyw12a2b8nqzpqxcwc1r1ssja4j5qk0c68cq6n7djqb"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -140073,15 +139566,15 @@ self: { regex-tdfa restless-git rosezipper scientific smt2-parser spawn spool stm tasty tasty-bench tasty-expected-failure tasty-hunit tasty-quickcheck temporary text time transformers tree-view tuple - unordered-containers vector vty witherable word-wrap wreq + unordered-containers vector vty witch witherable word-wrap wreq ]; librarySystemDepends = [ gmp libff secp256k1 ]; executableHaskellDepends = [ aeson ansi-wl-pprint async base base16 binary brick bytestring containers cryptonite data-dword deepseq directory filepath free - memory mtl operational optics-core optparse-generic process + githash memory mtl operational optics-core optparse-generic process QuickCheck quickcheck-text regex-tdfa spawn stm temporary text - unordered-containers vector vty + unordered-containers vector vty witch ]; testHaskellDepends = [ aeson array base base16 binary bytestring containers data-dword @@ -140089,7 +139582,7 @@ self: { optics-extra process QuickCheck quickcheck-instances regex regex-tdfa smt2-parser spawn stm tasty tasty-bench tasty-expected-failure tasty-hunit tasty-quickcheck temporary text - time vector witherable + time vector witch witherable ]; testSystemDepends = [ secp256k1 ]; benchmarkHaskellDepends = [ @@ -140158,10 +139651,8 @@ self: { }: mkDerivation { pname = "hex-text"; - version = "0.1.0.8"; - sha256 = "06zp9hwvds9fss2206c34q1zv80pklhbxcyrirz1xnwl3ml28fb5"; - revision = "1"; - editedCabalFile = "1w1hwzfhaphdbrnbqwn48v2jh7my280nisn7z98asidq77gi0lsl"; + version = "0.1.0.9"; + sha256 = "1dzv1jpjga4nsrxbwrh5nhnzv5f0mnl5i8da0blqc73vavsjhny5"; libraryHaskellDepends = [ base base16-bytestring bytestring text ]; testHaskellDepends = [ base base16-bytestring bytestring hspec text @@ -140568,6 +140059,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell bindings for the Keystone assembler framework"; license = lib.licenses.gpl2Only; + maintainers = [ lib.maintainers.raehik ]; }) {inherit (pkgs) keystone;}; "heyting-algebras" = callPackage @@ -140860,6 +140352,7 @@ self: { libraryPkgconfigDepends = [ gdal ]; description = "Haskell binding to the GDAL library"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gdal;}; "hgdbmi" = callPackage @@ -140946,6 +140439,8 @@ self: { pname = "hgeometry"; version = "0.14"; sha256 = "0bqn0qmi4r23wn2bmz4nnxp7cainsvi0zfxh71swn3a6labapkwk"; + revision = "1"; + editedCabalFile = "0gax66jc9nbf3afm3n47c7pakldnk0kg49wdn75rl699gf12h8ws"; libraryHaskellDepends = [ aeson base bifunctors bytestring containers data-clist deepseq dlist fingertree fixed-vector hashable hgeometry-combinatorial @@ -140965,6 +140460,7 @@ self: { ]; description = "Geometric Algorithms, Data structures, and Data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hgeometry-combinatorial" = callPackage @@ -140999,6 +140495,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Data structures, and Data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hgeometry-ipe" = callPackage @@ -141236,6 +140733,8 @@ self: { libraryHaskellDepends = [ aeson base bytestring cpu hosc network ]; description = "Haskell module to interact with the greetd daemon trough it's IPC protocol"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hgrep" = callPackage @@ -141690,6 +141189,8 @@ self: { testHaskellDepends = [ base hspec HUnit QuickCheck ]; description = "Fast algorithms for single, average/UPGMA and complete linkage clustering"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hierarchical-clustering-diagrams" = callPackage @@ -141709,6 +141210,7 @@ self: { ]; description = "Draw diagrams of dendrograms made by hierarchical-clustering"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hierarchical-env" = callPackage @@ -141838,7 +141340,9 @@ self: { testHaskellDepends = [ base ]; description = "WiFi connection script generator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "hifi"; + broken = true; }) {}; "higgledy" = callPackage @@ -142180,36 +141684,43 @@ self: { "hindent" = callPackage ({ mkDerivation, base, bytestring, Cabal, containers, criterion - , deepseq, Diff, directory, exceptions, filepath, ghc-prim - , haskell-src-exts, hspec, monad-loops, mtl, optparse-applicative - , path, path-io, text, transformers, unix-compat, utf8-string, yaml + , deepseq, Diff, directory, exceptions, filepath, ghc-lib-parser + , ghc-lib-parser-ex, hspec, monad-loops, mtl, optparse-applicative + , path, path-io, regex-tdfa, split, syb, text, transformers + , unicode-show, utf8-string, yaml }: mkDerivation { pname = "hindent"; - version = "5.3.4"; - sha256 = "1pc20iza3v0ljzbx6cycm1j1kbmz8h95xwfq47fd6zfmsrx9w6vn"; - revision = "1"; - editedCabalFile = "0rs5pk858dnc8jw1h9w8zk94jl3n79j5ci3jcq9gyghpwy6bfn6p"; + version = "6.0.0"; + sha256 = "17pkbjb4zqnzv3bnw3zwisf9j2m9lw5irq7i12bgwrzpv15fpabz"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; libraryHaskellDepends = [ - base bytestring Cabal containers directory exceptions filepath - haskell-src-exts monad-loops mtl text transformers utf8-string yaml + base bytestring Cabal containers deepseq directory exceptions + filepath ghc-lib-parser ghc-lib-parser-ex monad-loops mtl path + path-io regex-tdfa split syb text transformers unicode-show + utf8-string yaml ]; executableHaskellDepends = [ - base bytestring deepseq directory exceptions ghc-prim - haskell-src-exts optparse-applicative path path-io text - transformers unix-compat utf8-string yaml + base bytestring Cabal containers directory exceptions filepath + ghc-lib-parser ghc-lib-parser-ex monad-loops mtl + optparse-applicative path path-io regex-tdfa split syb text + transformers unicode-show utf8-string yaml ]; testHaskellDepends = [ - base bytestring deepseq Diff directory exceptions haskell-src-exts - hspec monad-loops mtl utf8-string + base bytestring Cabal containers Diff directory exceptions filepath + ghc-lib-parser ghc-lib-parser-ex hspec monad-loops mtl path path-io + regex-tdfa split syb text transformers unicode-show utf8-string + yaml ]; benchmarkHaskellDepends = [ - base bytestring criterion deepseq directory exceptions ghc-prim - haskell-src-exts mtl utf8-string + base bytestring Cabal containers criterion deepseq directory + exceptions filepath ghc-lib-parser ghc-lib-parser-ex monad-loops + mtl path path-io regex-tdfa split syb text transformers + unicode-show utf8-string yaml ]; + doHaddock = false; description = "Extensible Haskell pretty printer"; license = lib.licenses.bsd3; mainProgram = "hindent"; @@ -142678,6 +142189,7 @@ self: { ]; description = "Haskell Image Processing (HIP) Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hipbot" = callPackage @@ -143147,8 +142659,8 @@ self: { }: mkDerivation { pname = "hix"; - version = "0.5.3"; - sha256 = "02dmsmn3ijf4z6105xralcim3my9as9hxk43kwx92z20n7lma0yj"; + version = "0.5.8"; + sha256 = "0x1yaj99ss7wmzfad51zj36n9qahqap970pkbxxc72s295y0prbx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -143218,32 +142730,6 @@ self: { }) {}; "hjsmin" = callPackage - ({ mkDerivation, base, bytestring, directory, extra, filepath - , language-javascript, optparse-applicative, process, text, unix - }: - mkDerivation { - pname = "hjsmin"; - version = "0.2.0.4"; - sha256 = "1r2p5rjdjr25j3w4s57q5hxw2c3ymw12x7ms18yvglnq2ivr9fc1"; - revision = "2"; - editedCabalFile = "184g49wsj2sfm8d75kgr7ylfw29gbyrqbqp4syyz30ch047jd0af"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring language-javascript text - ]; - executableHaskellDepends = [ - base bytestring language-javascript optparse-applicative text - ]; - testHaskellDepends = [ - base directory extra filepath process unix - ]; - description = "Haskell implementation of a javascript minifier"; - license = lib.licenses.bsd3; - mainProgram = "hjsmin"; - }) {}; - - "hjsmin_0_2_1" = callPackage ({ mkDerivation, base, bytestring, directory, extra, filepath , language-javascript, optparse-applicative, process, text, unix }: @@ -143264,7 +142750,6 @@ self: { ]; description = "Haskell implementation of a javascript minifier"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "hjsmin"; }) {}; @@ -143502,34 +142987,14 @@ self: { }) {}; "hkgr" = callPackage - ({ mkDerivation, base, bytestring, directory, extra, filepath - , simple-cabal, simple-cmd-args, typed-process, xdg-basedir - }: - mkDerivation { - pname = "hkgr"; - version = "0.4.2"; - sha256 = "0ssh8wylalmgicpcixilvx3p46jf8miqx2q0gz9yjhxa54c721ab"; - isLibrary = false; - isExecutable = true; - enableSeparateDataOutput = true; - executableHaskellDepends = [ - base bytestring directory extra filepath simple-cabal - simple-cmd-args typed-process xdg-basedir - ]; - description = "Simple Hackage release workflow for package maintainers"; - license = lib.licenses.gpl3Only; - mainProgram = "hkgr"; - }) {}; - - "hkgr_0_4_3" = callPackage ({ mkDerivation, base, bytestring, directory, extra, filepath , simple-cabal, simple-cmd-args, simple-prompt, typed-process , xdg-basedir }: mkDerivation { pname = "hkgr"; - version = "0.4.3"; - sha256 = "0w9409hqjh8cl540dp60a0n2ci97qvq3iygvz9ys5v5j1jpj78rn"; + version = "0.4.3.1"; + sha256 = "0ls5g6xm8kyqk9yrwkbxqck8l14ij0zsmkscl6h7cicq3b0ar5vj"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -143539,7 +143004,6 @@ self: { ]; description = "Simple Hackage release workflow for package maintainers"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "hkgr"; }) {}; @@ -143647,53 +143111,6 @@ self: { }) {}; "hledger" = callPackage - ({ mkDerivation, aeson, ansi-terminal, base, breakpoint, bytestring - , cmdargs, containers, data-default, Decimal, Diff, directory - , extra, filepath, githash, hashable, haskeline, hledger-lib, lucid - , math-functions, megaparsec, microlens, mtl, process, regex-tdfa - , safe, shakespeare, split, tabular, tasty, temporary, terminfo - , text, time, timeit, transformers, unordered-containers - , utf8-string, utility-ht, wizards - }: - mkDerivation { - pname = "hledger"; - version = "1.27.1"; - sha256 = "0qdg87m7ys2ykqqq32p7h7aw827w4f5bcqx4dspxxq6zqlvzddqb"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson ansi-terminal base breakpoint bytestring cmdargs containers - data-default Decimal Diff directory extra filepath githash hashable - haskeline hledger-lib lucid math-functions megaparsec microlens mtl - process regex-tdfa safe shakespeare split tabular tasty temporary - terminfo text time timeit transformers unordered-containers - utf8-string utility-ht wizards - ]; - executableHaskellDepends = [ - aeson ansi-terminal base breakpoint bytestring cmdargs containers - data-default Decimal directory extra filepath githash haskeline - hledger-lib math-functions megaparsec microlens mtl process - regex-tdfa safe shakespeare split tabular tasty temporary terminfo - text time timeit transformers unordered-containers utf8-string - utility-ht wizards - ]; - testHaskellDepends = [ - aeson ansi-terminal base breakpoint bytestring cmdargs containers - data-default Decimal directory extra filepath githash haskeline - hledger-lib math-functions megaparsec microlens mtl process - regex-tdfa safe shakespeare split tabular tasty temporary terminfo - text time timeit transformers unordered-containers utf8-string - utility-ht wizards - ]; - description = "Command-line interface for the hledger accounting system"; - license = lib.licenses.gpl3Only; - mainProgram = "hledger"; - maintainers = [ - lib.maintainers.maralorn lib.maintainers.sternenseemann - ]; - }) {}; - - "hledger_1_30_1" = callPackage ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs , containers, data-default, Decimal, Diff, directory, extra , filepath, githash, hashable, haskeline, hledger-lib, lucid @@ -143706,8 +143123,8 @@ self: { pname = "hledger"; version = "1.30.1"; sha256 = "0ri8zg1pq011cbry5cxj2rc5g19vgl3rjcl5b2qk4bhdgxy7na98"; - revision = "1"; - editedCabalFile = "1pw204xcv71873rfv0xrnfsbhqnpjb5azr4jqiak6b21w31ky26q"; + revision = "2"; + editedCabalFile = "10r6ywfipsahxdbpnpg9cki5i201wglvdga3snhf7218wpr8rbrp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -143736,7 +143153,6 @@ self: { ]; description = "Command-line interface for the hledger accounting system"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "hledger"; maintainers = [ lib.maintainers.maralorn lib.maintainers.sternenseemann @@ -143829,7 +143245,9 @@ self: { ]; description = "An hledger workflow focusing on automated statement import and classification"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "hledger-flow"; + broken = true; }) {}; "hledger-iadd" = callPackage @@ -143910,42 +143328,6 @@ self: { }) {}; "hledger-lib" = callPackage - ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base - , blaze-markup, breakpoint, bytestring, call-stack, cassava - , cassava-megaparsec, cmdargs, containers, data-default, Decimal - , deepseq, directory, doclayout, doctest, extra, file-embed - , filepath, Glob, hashtables, megaparsec, microlens, microlens-th - , mtl, parser-combinators, pretty-simple, regex-tdfa, safe, tabular - , tasty, tasty-hunit, template-haskell, text, time, timeit - , transformers, uglymemo, unordered-containers, utf8-string - }: - mkDerivation { - pname = "hledger-lib"; - version = "1.27.1"; - sha256 = "0w2jnpyfc6pp3n5fzdjd78hdh9vv9w98xwd2j6dw98rm6hlapwhb"; - libraryHaskellDepends = [ - aeson aeson-pretty ansi-terminal array base blaze-markup breakpoint - bytestring call-stack cassava cassava-megaparsec cmdargs containers - data-default Decimal deepseq directory doclayout extra file-embed - filepath Glob hashtables megaparsec microlens microlens-th mtl - parser-combinators pretty-simple regex-tdfa safe tabular tasty - tasty-hunit template-haskell text time timeit transformers uglymemo - unordered-containers utf8-string - ]; - testHaskellDepends = [ - aeson aeson-pretty ansi-terminal array base blaze-markup breakpoint - bytestring call-stack cassava cassava-megaparsec cmdargs containers - data-default Decimal deepseq directory doclayout doctest extra - file-embed filepath Glob hashtables megaparsec microlens - microlens-th mtl parser-combinators pretty-simple regex-tdfa safe - tabular tasty tasty-hunit template-haskell text time timeit - transformers uglymemo unordered-containers utf8-string - ]; - description = "A reusable library providing the core functionality of hledger"; - license = lib.licenses.gpl3Only; - }) {}; - - "hledger-lib_1_30" = callPackage ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array, base , base-compat, blaze-markup, bytestring, call-stack, cassava , cassava-megaparsec, cmdargs, colour, containers, data-default @@ -143960,8 +143342,8 @@ self: { pname = "hledger-lib"; version = "1.30"; sha256 = "0qyhkx1bhrmnwwxqbqa4pqghg7j2vn63829j5s2zdn8ys2mm8s64"; - revision = "1"; - editedCabalFile = "09b8liifim9rj6l1s0jwfnnfigjhy3cwaadx017m97igm1mpc7f0"; + revision = "2"; + editedCabalFile = "136j2f4wyqcaihkpisxnw3afn2v953zl4fx9w2hdvavqpv99yj0m"; libraryHaskellDepends = [ aeson aeson-pretty ansi-terminal array base base-compat blaze-markup bytestring call-stack cassava cassava-megaparsec @@ -143984,7 +143366,6 @@ self: { ]; description = "A reusable library providing the core functionality of hledger"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "hledger-makeitso" = callPackage @@ -144006,7 +143387,9 @@ self: { ]; description = "An hledger workflow focusing on automated statement import and classification"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "hledger-makeitso"; + broken = true; }) {}; "hledger-stockquotes" = callPackage @@ -144040,31 +143423,6 @@ self: { }) {}; "hledger-ui" = callPackage - ({ mkDerivation, ansi-terminal, async, base, breakpoint, brick - , cmdargs, containers, data-default, directory, doclayout, extra - , filepath, fsnotify, hledger, hledger-lib, megaparsec, microlens - , microlens-platform, mtl, process, safe, split, text, text-zipper - , time, transformers, unix, vector, vty - }: - mkDerivation { - pname = "hledger-ui"; - version = "1.27.1"; - sha256 = "1srzlz0mdcp0259k0vsc8xkisd9l59s30j1k1x9bnsn179n8bi22"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - ansi-terminal async base breakpoint brick cmdargs containers - data-default directory doclayout extra filepath fsnotify hledger - hledger-lib megaparsec microlens microlens-platform mtl process - safe split text text-zipper time transformers unix vector vty - ]; - description = "Curses-style terminal interface for the hledger accounting system"; - license = lib.licenses.gpl3Only; - mainProgram = "hledger-ui"; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "hledger-ui_1_30" = callPackage ({ mkDerivation, ansi-terminal, async, base, brick, cmdargs , containers, data-default, directory, doclayout, extra, filepath , fsnotify, hledger, hledger-lib, megaparsec, microlens @@ -144087,7 +143445,6 @@ self: { ]; description = "Curses-style terminal interface for the hledger accounting system"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "hledger-ui"; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -144113,43 +143470,6 @@ self: { }) {}; "hledger-web" = callPackage - ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup - , breakpoint, bytestring, case-insensitive, clientsession, cmdargs - , conduit, conduit-extra, containers, data-default, Decimal - , directory, extra, filepath, hjsmin, hledger, hledger-lib, hspec - , http-client, http-conduit, http-types, megaparsec, mtl, network - , shakespeare, template-haskell, text, time, transformers - , unix-compat, unordered-containers, utf8-string, wai, wai-cors - , wai-extra, wai-handler-launch, warp, yaml, yesod, yesod-core - , yesod-form, yesod-static, yesod-test - }: - mkDerivation { - pname = "hledger-web"; - version = "1.27.1"; - sha256 = "151dxci7dld8626dzw823sr3d9iaac92wfzbfcbdz4jh9f7n07wa"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base base64 blaze-html blaze-markup breakpoint bytestring - case-insensitive clientsession cmdargs conduit conduit-extra - containers data-default Decimal directory extra filepath hjsmin - hledger hledger-lib hspec http-client http-conduit http-types - megaparsec mtl network shakespeare template-haskell text time - transformers unix-compat unordered-containers utf8-string wai - wai-cors wai-extra wai-handler-launch warp yaml yesod yesod-core - yesod-form yesod-static yesod-test - ]; - executableHaskellDepends = [ base breakpoint ]; - testHaskellDepends = [ - base breakpoint hledger hledger-lib hspec text yesod yesod-test - ]; - description = "Web-based user interface for the hledger accounting system"; - license = lib.licenses.gpl3Only; - mainProgram = "hledger-web"; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "hledger-web_1_30" = callPackage ({ mkDerivation, aeson, base, base64, blaze-html, blaze-markup , bytestring, case-insensitive, clientsession, cmdargs, conduit , conduit-extra, containers, data-default, Decimal, directory @@ -144164,8 +143484,8 @@ self: { pname = "hledger-web"; version = "1.30"; sha256 = "0lcw8qigh1507hn287zwmp00vsccsm6lw6r87c5rp0ikxsxmwbds"; - revision = "1"; - editedCabalFile = "11id6v6h86zmvqbkx45kdr1q1c5maka6iackk6b2jw9icyv9g6hb"; + revision = "2"; + editedCabalFile = "0cixs5p93f2dx82w7krki4znsgdkl6hi2rqqdj0yx2xlp5m4jzq5"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -144184,7 +143504,6 @@ self: { ]; description = "Web-based user interface for the hledger accounting system"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; mainProgram = "hledger-web"; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -144193,8 +143512,8 @@ self: { ({ mkDerivation, base, HUnit, regex-tdfa }: mkDerivation { pname = "hlex"; - version = "0.1.0"; - sha256 = "0nmd4sjm74k7a2nm1638ri27slr457zfg86wzqgprkzd9jbqilsa"; + version = "1.0.0"; + sha256 = "1qanm8n368ps64hfr19j43hrkbwlgmfdyf4xldx25lzrgn56qaxk"; libraryHaskellDepends = [ base regex-tdfa ]; testHaskellDepends = [ base HUnit regex-tdfa ]; description = "Simple Lexer Creation"; @@ -144318,10 +143637,10 @@ self: { maintainers = [ lib.maintainers.maralorn ]; }) {}; - "hlint" = callPackage + "hlint_3_4_1" = callPackage ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs , containers, cpphs, data-default, deriving-aeson, directory, extra - , file-embed, filepath, filepattern, ghc, ghc-boot, ghc-boot-th + , file-embed, filepath, filepattern, ghc-lib-parser , ghc-lib-parser-ex, hscolour, process, refact, text, transformers , uniplate, unordered-containers, utf8-string, vector, yaml }: @@ -144337,18 +143656,19 @@ self: { libraryHaskellDepends = [ aeson ansi-terminal base bytestring cmdargs containers cpphs data-default deriving-aeson directory extra file-embed filepath - filepattern ghc ghc-boot ghc-boot-th ghc-lib-parser-ex hscolour - process refact text transformers uniplate unordered-containers - utf8-string vector yaml + filepattern ghc-lib-parser ghc-lib-parser-ex hscolour process + refact text transformers uniplate unordered-containers utf8-string + vector yaml ]; executableHaskellDepends = [ base ]; description = "Source code suggestions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "hlint"; maintainers = [ lib.maintainers.maralorn ]; }) {}; - "hlint_3_5" = callPackage + "hlint" = callPackage ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs , containers, cpphs, data-default, deriving-aeson, directory, extra , file-embed, filepath, filepattern, ghc-lib-parser @@ -144372,6 +143692,34 @@ self: { executableHaskellDepends = [ base ]; description = "Source code suggestions"; license = lib.licenses.bsd3; + mainProgram = "hlint"; + maintainers = [ lib.maintainers.maralorn ]; + }) {}; + + "hlint_3_6_1" = callPackage + ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs + , containers, cpphs, data-default, deriving-aeson, directory, extra + , file-embed, filepath, filepattern, ghc-lib-parser + , ghc-lib-parser-ex, hscolour, process, refact, text, transformers + , uniplate, unordered-containers, utf8-string, vector, yaml + }: + mkDerivation { + pname = "hlint"; + version = "3.6.1"; + sha256 = "1za1cykiajyfl8ks59jdj6228qnlg5s96slc9jm9zcy1ncmi701j"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson ansi-terminal base bytestring cmdargs containers cpphs + data-default deriving-aeson directory extra file-embed filepath + filepattern ghc-lib-parser ghc-lib-parser-ex hscolour process + refact text transformers uniplate unordered-containers utf8-string + vector yaml + ]; + executableHaskellDepends = [ base ]; + description = "Source code suggestions"; + license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; mainProgram = "hlint"; maintainers = [ lib.maintainers.maralorn ]; @@ -144516,8 +143864,8 @@ self: { }: mkDerivation { pname = "hls-alternate-number-format-plugin"; - version = "2.0.0.0"; - sha256 = "12di8zpzrmlhj6i14zhjj7y79gihc3whm30qvlikfy52dkblhx4g"; + version = "2.0.0.1"; + sha256 = "1vszwiy8jgs8a2ggz04kn0d0y59fx6ji110j8pj1z5k40yx1a26a"; libraryHaskellDepends = [ aeson base containers extra ghc-boot-th ghcide hie-compat hls-graph hls-plugin-api lens lsp mtl regex-tdfa syb text @@ -144549,8 +143897,8 @@ self: { }: mkDerivation { pname = "hls-cabal-fmt-plugin"; - version = "2.0.0.0"; - sha256 = "0j2c22whp9d7wvwfb20f0ij2nz443vziz9m27y3di45yjwacdj46"; + version = "2.0.0.1"; + sha256 = "1nmwnx2j1cnqsgw3bsdkdw8rp4dnf4fdclsr56viaz2qm4hqjc8k"; libraryHaskellDepends = [ base directory filepath ghcide hls-plugin-api lens lsp-types process text transformers @@ -144568,8 +143916,8 @@ self: { }: mkDerivation { pname = "hls-cabal-plugin"; - version = "2.0.0.0"; - sha256 = "1cmnyjx8mfhj8q0srvnx0wf4pc1gin1cshnvfqcwikyimpsjivsm"; + version = "2.0.0.1"; + sha256 = "17zccd6c16xq44al5iaj9zfp0gzjb03bclvyyr739ikh8vjb2j7b"; libraryHaskellDepends = [ base bytestring Cabal deepseq directory extra ghcide hashable hls-graph hls-plugin-api lsp lsp-types regex-tdfa stm text @@ -144590,8 +143938,8 @@ self: { }: mkDerivation { pname = "hls-call-hierarchy-plugin"; - version = "2.0.0.0"; - sha256 = "1sshrk144ndp8dr1kfg9sy3riyx1malhpdj9afnz8nmibg0gicxs"; + version = "2.0.0.1"; + sha256 = "1bc3mwvj9k7bnhpf69ikzz206hr4sqp7k57mlqs1bpillai9sk1c"; libraryHaskellDepends = [ aeson base containers extra ghcide hiedb hls-plugin-api lens lsp sqlite-simple text unordered-containers @@ -144611,8 +143959,8 @@ self: { }: mkDerivation { pname = "hls-change-type-signature-plugin"; - version = "2.0.0.0"; - sha256 = "0ccprd27vr2rj18rgad0855h8w1krf0rwlm1bxsdx85ilcgym4q3"; + version = "2.0.0.1"; + sha256 = "1mjckkjsl8r3mln9lbw4f59fwkss0p8lz9n73nppadrf61x4fkm5"; libraryHaskellDepends = [ base ghcide hls-plugin-api lsp-types regex-tdfa syb text transformers unordered-containers @@ -144632,8 +143980,8 @@ self: { }: mkDerivation { pname = "hls-class-plugin"; - version = "2.0.0.0"; - sha256 = "1hpgq2c9702iixami1kgl1kb00h15p4sl5ajlza69y42wad2s4r0"; + version = "2.0.0.1"; + sha256 = "1hmp4apq1azds6bc2ri7i6q4d6aa52sz0c24pdwnzmb59blvgia4"; libraryHaskellDepends = [ aeson base containers deepseq extra ghc ghc-boot-th ghc-exactprint ghcide hls-graph hls-plugin-api lens lsp text transformers @@ -144654,8 +144002,8 @@ self: { }: mkDerivation { pname = "hls-code-range-plugin"; - version = "2.0.0.0"; - sha256 = "1cwb4r1b35c9szcxq9nzy6yqfwg8ssxirpfxkc8vbrmza59wqn29"; + version = "2.0.0.1"; + sha256 = "19vwzjkl2ihpc2c6dwnfnb6vi0jafbpqwhq24hi61pgiciqvvm7i"; libraryHaskellDepends = [ aeson base containers deepseq extra ghcide hashable hls-plugin-api lens lsp mtl semigroupoids text transformers vector @@ -144678,8 +144026,8 @@ self: { }: mkDerivation { pname = "hls-eval-plugin"; - version = "2.0.0.0"; - sha256 = "1agjw6mxdin4mpwna1lgzzhscbva32z02v9x3rzqirnf47pfnl2w"; + version = "2.0.0.1"; + sha256 = "0955f7zgd13c9nyx1s800aqk3fpysdfmhks9smlnaqg97b56yrzh"; libraryHaskellDepends = [ aeson base containers data-default deepseq Diff directory dlist extra filepath ghc ghc-boot-th ghc-paths ghcide hashable hls-graph @@ -144720,8 +144068,8 @@ self: { }: mkDerivation { pname = "hls-explicit-fixity-plugin"; - version = "2.0.0.0"; - sha256 = "094bih984f44zxkzli8zn5779g4l3n47p0n60i3ys0p2awpvwnn7"; + version = "2.0.0.1"; + sha256 = "1mrmh8g5zws4aa222k4sfwgh8whvmh94lljnhhiylk65zd5ib7mm"; libraryHaskellDepends = [ base containers deepseq extra ghc ghcide hashable hls-plugin-api lsp text transformers @@ -144738,8 +144086,8 @@ self: { }: mkDerivation { pname = "hls-explicit-imports-plugin"; - version = "2.0.0.0"; - sha256 = "1lz620w5z3ly3iivg653csa4rdz6f3mln7mh983xkhrrvnf05w7a"; + version = "2.0.0.1"; + sha256 = "0h76wg03lqsas0dmpvk2kcccrrj07qn3kxxr1fwxs137m73pfn1x"; libraryHaskellDepends = [ aeson base containers deepseq ghc ghcide hls-graph hls-plugin-api lsp text unordered-containers @@ -144756,8 +144104,8 @@ self: { }: mkDerivation { pname = "hls-explicit-record-fields-plugin"; - version = "2.0.0.0"; - sha256 = "0nw35qpd170860dn3lcdxmc47whbhsi8a89m8kka1arzkagp8p5p"; + version = "2.0.0.1"; + sha256 = "1543dvl9i1508f7fhl15skbnfcrs5vnpli0wixsckgn6297vz2g1"; libraryHaskellDepends = [ base containers ghc-boot-th ghcide hls-graph hls-plugin-api lens lsp syb text transformers unordered-containers @@ -144775,8 +144123,8 @@ self: { }: mkDerivation { pname = "hls-floskell-plugin"; - version = "2.0.0.0"; - sha256 = "13idpjnd10m4y4yr94hyanv7p5s0zjjlhn7pc55xd418gi08ykn7"; + version = "2.0.0.1"; + sha256 = "1mm9qavr3qlrjv13m7a982faya13qnh0ddpcgckaydy3pr8hsqrm"; libraryHaskellDepends = [ base floskell ghcide hls-plugin-api lsp-types text transformers ]; @@ -144792,8 +144140,8 @@ self: { }: mkDerivation { pname = "hls-fourmolu-plugin"; - version = "2.0.0.0"; - sha256 = "0w1h5d380b6mk9k91047gwnmag92kwsmbing58hfx3cfq3nrdvzs"; + version = "2.0.0.1"; + sha256 = "199kk08kzyfpxqv02j1q56fkqbbyn40v1dj8ijazv90an97qw8y8"; libraryHaskellDepends = [ base filepath fourmolu ghc ghc-boot-th ghcide hls-plugin-api lens lsp process-extras text @@ -144815,8 +144163,8 @@ self: { }: mkDerivation { pname = "hls-gadt-plugin"; - version = "2.0.0.0"; - sha256 = "0ad45yz9x2lcf4b7pwfn4a7mbba2j3svgp4kpkfb46qdv70jcm13"; + version = "2.0.0.1"; + sha256 = "1pabnzwh9zjyjidyri0mhn87dy2xhk7c88fj6r096riisj6wzp5g"; libraryHaskellDepends = [ aeson base containers extra ghc ghc-boot-th ghc-exactprint ghcide hls-plugin-api hls-refactor-plugin lens lsp mtl text transformers @@ -144838,8 +144186,8 @@ self: { }: mkDerivation { pname = "hls-graph"; - version = "2.0.0.0"; - sha256 = "0dij91crndh4l98vgjgv5jrms8lvc40qnr5ynmlhb07wpim5j3yh"; + version = "2.0.0.1"; + sha256 = "0kbhhnbjka5xlsa5vq0vlxg210fz4j7w524a11g6375br3vjfqnc"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson async base bytestring containers deepseq directory exceptions @@ -144860,8 +144208,8 @@ self: { ({ mkDerivation }: mkDerivation { pname = "hls-haddock-comments-plugin"; - version = "2.0.0.0"; - sha256 = "099xvvbyd9zi8y48q7dg7fk7kj34nn39gdyhkdff7832q6p7892i"; + version = "2.0.0.1"; + sha256 = "1w80jkb4n61v1lvbkpimdwvxi4w9h72zi8lr6p7f8r9fd7l41x35"; description = "Haddock comments plugin for Haskell Language Server"; license = lib.licenses.asl20; hydraPlatforms = lib.platforms.none; @@ -144878,8 +144226,8 @@ self: { }: mkDerivation { pname = "hls-hlint-plugin"; - version = "2.0.0.0"; - sha256 = "19py74k9ff9pidwpvv4qbhl72dv78lh5m1wvfhv4dzmr3mfn8ry6"; + version = "2.0.0.1"; + sha256 = "0nrcr2xavq5fvq72mhl46y98w28hn64237z1kcx7i69svncwfpk0"; libraryHaskellDepends = [ aeson apply-refact base binary bytestring containers data-default deepseq Diff directory extra filepath ghc-exactprint ghc-lib-parser @@ -144902,8 +144250,8 @@ self: { }: mkDerivation { pname = "hls-module-name-plugin"; - version = "2.0.0.0"; - sha256 = "0y9wkc7zw9cw7gm8d4z58sj1q2w3gvzzqb349g2f73hdm28ydwsk"; + version = "2.0.0.1"; + sha256 = "0y4x27mna7adjvk6scnmz28m1ks6nz7lkbp29x1k7k5nj42kzcph"; libraryHaskellDepends = [ aeson base directory filepath ghcide hls-plugin-api lsp text transformers unordered-containers @@ -144920,8 +144268,8 @@ self: { }: mkDerivation { pname = "hls-ormolu-plugin"; - version = "2.0.0.0"; - sha256 = "1wv31qjhgpcwf7cvq3phr1dgw1a2spgs7hhg94zinqkwsjjgdswi"; + version = "2.0.0.1"; + sha256 = "0bdcaqcd2k8ha6wvp7w5wda1nsczcawc8n74i11s40r68qq3j0xq"; libraryHaskellDepends = [ base filepath ghc ghc-boot-th ghcide hls-plugin-api lens lsp ormolu text @@ -144933,6 +144281,26 @@ self: { license = lib.licenses.asl20; }) {}; + "hls-overloaded-record-dot-plugin" = callPackage + ({ mkDerivation, base, containers, deepseq, filepath, ghc-boot-th + , ghcide, hls-graph, hls-plugin-api, hls-test-utils, lens, lsp + , lsp-test, syb, text, transformers, unordered-containers + }: + mkDerivation { + pname = "hls-overloaded-record-dot-plugin"; + version = "2.0.0.1"; + sha256 = "1ilmiw0lrd8rkmplwfm6lf5hckjg2ak7x2payr2x90bhhbjzg9fa"; + libraryHaskellDepends = [ + base containers deepseq ghc-boot-th ghcide hls-graph hls-plugin-api + lens lsp syb text transformers unordered-containers + ]; + testHaskellDepends = [ + base filepath hls-test-utils lsp-test text + ]; + description = "Overloaded record dot plugin for Haskell Language Server"; + license = lib.licenses.bsd3; + }) {}; + "hls-plugin-api" = callPackage ({ mkDerivation, aeson, base, containers, criterion, data-default , deepseq, dependent-map, dependent-sum, Diff, dlist, extra @@ -144944,8 +144312,8 @@ self: { }: mkDerivation { pname = "hls-plugin-api"; - version = "2.0.0.0"; - sha256 = "1h0vycqsnh7j0ygiizbkc30n29bmdzch0l045jlsy3306inalq0z"; + version = "2.0.0.1"; + sha256 = "1rahsz7yl8vd7wcwag76dmmvnysagn6s6iabijlpp2v7z6kkr5y9"; libraryHaskellDepends = [ aeson base containers data-default dependent-map dependent-sum Diff dlist extra filepath ghc hashable hls-graph hw-fingertree lens @@ -144970,8 +144338,8 @@ self: { }: mkDerivation { pname = "hls-pragmas-plugin"; - version = "2.0.0.0"; - sha256 = "0gd58h1y0ky5wy0j959rcrwkjwqsn1mlwc56rp28mhx4wyl4ilrr"; + version = "2.0.0.1"; + sha256 = "1mgq746zz4v348218qn4cifjcxm85a6zxzizhzanpv3xg15g30m4"; libraryHaskellDepends = [ base containers extra fuzzy ghc ghcide hls-plugin-api lens lsp text transformers unordered-containers @@ -144990,8 +144358,8 @@ self: { }: mkDerivation { pname = "hls-qualify-imported-names-plugin"; - version = "2.0.0.0"; - sha256 = "1w9a9xgsphhj8slbq9138xlsv1fzn004iigkq8zp4pgf2hdqcbhh"; + version = "2.0.0.1"; + sha256 = "0ra3r31b0f5g38fwxm1j7bljwph00c7r963fn1py7g9ib2rv476k"; libraryHaskellDepends = [ aeson base containers deepseq dlist ghc ghcide hls-graph hls-plugin-api lsp text transformers unordered-containers @@ -145012,8 +144380,8 @@ self: { }: mkDerivation { pname = "hls-refactor-plugin"; - version = "2.0.0.0"; - sha256 = "004j4m6mzb2mb7q7gvdyqc42kn51psx2kx6h6j8nfq917h1njdhf"; + version = "2.0.0.1"; + sha256 = "0ww7ijagiy4lyhsp5ljph09s6mixc0jyh7794cgmbxvwgc4nv89p"; libraryHaskellDepends = [ aeson base bytestring containers data-default deepseq dlist extra ghc ghc-boot ghc-exactprint ghcide hls-graph hls-plugin-api lens @@ -145037,8 +144405,8 @@ self: { }: mkDerivation { pname = "hls-refine-imports-plugin"; - version = "2.0.0.0"; - sha256 = "0jsqy005mbk3hqdz90gfs5xa0cm9bhd5py5f0sb8hvpk78wgbr40"; + version = "2.0.0.1"; + sha256 = "0hvjzq4g02zvvzw0wmb3c8f903gnjfvcmggw6j8fypi51zvjvglf"; libraryHaskellDepends = [ aeson base containers deepseq ghc ghcide hls-explicit-imports-plugin hls-graph hls-plugin-api lsp text @@ -145057,8 +144425,8 @@ self: { }: mkDerivation { pname = "hls-rename-plugin"; - version = "2.0.0.0"; - sha256 = "11j67d031a2vvsb0crl702467088z0x14gkw425crr544gwjd7x6"; + version = "2.0.0.1"; + sha256 = "0b3c7h151rn9awkjc0iq2fnir3g9kvj79b4mdigrarzi8g695agn"; libraryHaskellDepends = [ base containers extra ghc ghc-exactprint ghcide hashable hie-compat hiedb hls-plugin-api hls-refactor-plugin lsp lsp-types mod syb text @@ -145079,8 +144447,8 @@ self: { }: mkDerivation { pname = "hls-retrie-plugin"; - version = "2.0.0.0"; - sha256 = "02mm4zwv99qj0ldhyps4yn3j48xs1njxb3drxpid5kkdvpiv1spx"; + version = "2.0.0.1"; + sha256 = "0rq49n8ryp8x1jk9lwm2lcih0kx8lc0snlmclp6jky503n33vkf8"; libraryHaskellDepends = [ aeson base bytestring containers deepseq directory extra ghc ghcide hashable hls-plugin-api hls-refactor-plugin lsp lsp-types retrie @@ -145127,8 +144495,8 @@ self: { }: mkDerivation { pname = "hls-splice-plugin"; - version = "2.0.0.0"; - sha256 = "0q8yjq2r97p0pnxbcs2wxzhyjqx69zp3vrgbz4q8hmy3d3v05a9x"; + version = "2.0.0.1"; + sha256 = "0scjc5rd01ns8ifyscvzlxsb6r307j9p2cv8d77vh0akm6jrjiq3"; libraryHaskellDepends = [ aeson base containers dlist extra foldl ghc ghc-exactprint ghcide hls-plugin-api hls-refactor-plugin lens lsp retrie syb text @@ -145143,8 +144511,8 @@ self: { ({ mkDerivation }: mkDerivation { pname = "hls-stan-plugin"; - version = "2.0.0.0"; - sha256 = "1qcck8a58bqim5x7vq0mmsak0742xjy7g525mn6c6rbshv3vdxd4"; + version = "2.0.0.1"; + sha256 = "12100gj5hiqsjx71syww45nv4pnrhq0a1zhpmh2ac1kslgdajij1"; description = "Stan integration plugin with Haskell Language Server"; license = lib.licenses.asl20; hydraPlatforms = lib.platforms.none; @@ -145158,8 +144526,8 @@ self: { }: mkDerivation { pname = "hls-stylish-haskell-plugin"; - version = "2.0.0.0"; - sha256 = "1441pswwmxh1c7zl7r4jl5ylpkg2v6xvwyvgmziyhgx9jy29j72r"; + version = "2.0.0.1"; + sha256 = "0g2gpldgd9g9mpxnzbi5amsl9v277n2wdn1yd4bammq5dc80prvz"; libraryHaskellDepends = [ base directory filepath ghc ghc-boot-th ghcide hls-plugin-api lsp-types stylish-haskell text @@ -145173,8 +144541,8 @@ self: { ({ mkDerivation }: mkDerivation { pname = "hls-tactics-plugin"; - version = "2.0.0.0"; - sha256 = "0ai0drpakkijamkd5d7smdhv4kwgld9xwvkh2l9avjzljqwragqy"; + version = "2.0.0.1"; + sha256 = "0kzyjsgc4j03ayjq79nd3kkv8x3nf0c9wk12m0fix0ik9fr35idh"; description = "Wingman plugin for Haskell Language Server"; license = lib.licenses.asl20; hydraPlatforms = lib.platforms.none; @@ -145190,8 +144558,8 @@ self: { }: mkDerivation { pname = "hls-test-utils"; - version = "2.0.0.0"; - sha256 = "1xvfkj9xscf1cx3va6v6vblhsnimvkwkladvdbw5mxabicpwjy2m"; + version = "2.0.0.1"; + sha256 = "0s2418lv3kg5zs8zr4a1j90503c6alcpr6q5d7cs6ravdq6s0qvi"; libraryHaskellDepends = [ aeson async base blaze-markup bytestring containers data-default directory extra filepath ghcide hls-graph hls-plugin-api lens lsp @@ -145466,6 +144834,7 @@ self: { libraryHaskellDepends = [ base hmatrix repa vector ]; description = "Adaptors for interoperability between hmatrix and repa"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "hmatrix-sparse" = callPackage @@ -145824,8 +145193,8 @@ self: { }: mkDerivation { pname = "hmp3-ng"; - version = "2.14.2"; - sha256 = "1qx8gy63m0q2wb4q6aifrfqmdh0vnanvxxwa47jpwv641sxbp1ck"; + version = "2.14.3"; + sha256 = "02bcxzpmjm6kqcvx7036055chbyfyhi6pl4xrrxwwmkp85fh0apb"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -146163,7 +145532,9 @@ self: { testHaskellDepends = [ base ]; description = "A Nock interpreter"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "hnock"; + broken = true; }) {}; "hnop" = callPackage @@ -146260,19 +145631,21 @@ self: { "hoauth2" = callPackage ({ mkDerivation, aeson, base, base64, binary, bytestring - , containers, cryptonite, data-default, exceptions, http-conduit - , http-types, memory, microlens, text, transformers, uri-bytestring - , uri-bytestring-aeson + , containers, cryptonite, data-default, exceptions, hspec + , hspec-discover, http-conduit, http-types, memory, microlens, text + , transformers, uri-bytestring, uri-bytestring-aeson }: mkDerivation { pname = "hoauth2"; - version = "2.6.0"; - sha256 = "1iag8dwza1cg8m436f2a3ar2281xjflslqfffgi9kz81jnvgs95i"; + version = "2.8.0"; + sha256 = "1xndl9cl0j1mn18lgjrp7crys9vlz0gznp7fijazawa5x84xjfpp"; libraryHaskellDepends = [ aeson base base64 binary bytestring containers cryptonite data-default exceptions http-conduit http-types memory microlens text transformers uri-bytestring uri-bytestring-aeson ]; + testHaskellDepends = [ aeson base hspec ]; + testToolDepends = [ hspec-discover ]; description = "Haskell OAuth2 authentication client"; license = lib.licenses.mit; }) {}; @@ -146720,8 +146093,8 @@ self: { pname = "hoist-error"; version = "0.2.1.0"; sha256 = "028lczd80nhj3yj5dq9qixzdzkyisl34qpi6bb28r8b9nj2i2nss"; - revision = "5"; - editedCabalFile = "173vmbviw39ivb1cg2c0w35m0dd32n0ki82nd6h3j8yww0pzgk5p"; + revision = "6"; + editedCabalFile = "0wlicjvc2w2vjbnxr3fc417hp1bb4iqvq7pww8wn8b1j8mij60yp"; libraryHaskellDepends = [ base either mtl ]; description = "Some convenience facilities for hoisting errors into a monad"; license = lib.licenses.mit; @@ -147825,26 +147198,6 @@ self: { }) {}; "horizontal-rule" = callPackage - ({ mkDerivation, ansi-wl-pprint, base, HMock, optparse-applicative - , tasty, tasty-hunit, terminal-size, text, time - }: - mkDerivation { - pname = "horizontal-rule"; - version = "0.5.0.0"; - sha256 = "1anpf8qgiyvx1fvycr01sz9ak8zxdrarqw32m0kybxs3xhw15myy"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base terminal-size text ]; - executableHaskellDepends = [ - ansi-wl-pprint base optparse-applicative text time - ]; - testHaskellDepends = [ base HMock tasty tasty-hunit ]; - description = "horizontal rule for the terminal"; - license = lib.licenses.mit; - mainProgram = "hr"; - }) {}; - - "horizontal-rule_0_6_0_0" = callPackage ({ mkDerivation, ansi-wl-pprint, base, HMock, optparse-applicative , tasty, tasty-hunit, terminal-size, text, time }: @@ -147887,23 +147240,6 @@ self: { }) {}; "hosc" = callPackage - ({ mkDerivation, base, binary, blaze-builder, bytestring - , data-binary-ieee754, network, time, transformers - }: - mkDerivation { - pname = "hosc"; - version = "0.19.1"; - sha256 = "08q218p1skqxwa7f55nsgmv9z8digf1c0f1wi6p562q6d4i044z7"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - base binary blaze-builder bytestring data-binary-ieee754 network - time transformers - ]; - description = "Haskell Open Sound Control"; - license = lib.licenses.gpl3Only; - }) {}; - - "hosc_0_20" = callPackage ({ mkDerivation, base, binary, blaze-builder, bytestring , data-binary-ieee754, network, parsec, time, transformers }: @@ -147918,7 +147254,6 @@ self: { ]; description = "Haskell Open Sound Control"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "hosc-json" = callPackage @@ -148243,48 +147578,6 @@ self: { mainProgram = "hp2pretty"; }) {}; - "hpack_0_35_0" = callPackage - ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal - , containers, cryptonite, deepseq, directory, filepath, Glob, hspec - , hspec-discover, http-client, http-client-tls, http-types, HUnit - , infer-license, interpolate, mockery, pretty, QuickCheck - , scientific, template-haskell, temporary, text, transformers - , unordered-containers, vector, yaml - }: - mkDerivation { - pname = "hpack"; - version = "0.35.0"; - sha256 = "1cii4bdn4rm2l3yw9vsv4ygn61zmalaa282iqg9rihys90nvrgf6"; - revision = "1"; - editedCabalFile = "1x0rmra2fpfzmhhw090iila2drfdmb1y28ybypmgbi0asa1zl751"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base bifunctors bytestring Cabal containers cryptonite - deepseq directory filepath Glob http-client http-client-tls - http-types infer-license pretty scientific text transformers - unordered-containers vector yaml - ]; - executableHaskellDepends = [ - aeson base bifunctors bytestring Cabal containers cryptonite - deepseq directory filepath Glob http-client http-client-tls - http-types infer-license pretty scientific text transformers - unordered-containers vector yaml - ]; - testHaskellDepends = [ - aeson base bifunctors bytestring Cabal containers cryptonite - deepseq directory filepath Glob hspec http-client http-client-tls - http-types HUnit infer-license interpolate mockery pretty - QuickCheck scientific template-haskell temporary text transformers - unordered-containers vector yaml - ]; - testToolDepends = [ hspec-discover ]; - description = "A modern format for Haskell packages"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - mainProgram = "hpack"; - }) {}; - "hpack" = callPackage ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal , containers, cryptonite, deepseq, directory, filepath, Glob, hspec @@ -148297,8 +147590,8 @@ self: { pname = "hpack"; version = "0.35.2"; sha256 = "1v4h5dkbfwx8wlmbaq76av22ald9iyk80k8k7pz808nw30yh3dq3"; - revision = "1"; - editedCabalFile = "19vz0drrg9bgxaszr1d3xlarddmibly68bcrkj05niaw35gsdzpq"; + revision = "2"; + editedCabalFile = "0vwxfg5ixlr18q8gb1x8vz3grp339cbnhm51hfp7rk6vc0bd61k5"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -148326,6 +147619,46 @@ self: { mainProgram = "hpack"; }) {}; + "hpack_0_35_3" = callPackage + ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal + , containers, crypton, deepseq, directory, filepath, Glob, hspec + , hspec-discover, http-client, http-client-tls, http-types, HUnit + , infer-license, interpolate, mockery, pretty, QuickCheck + , scientific, template-haskell, temporary, text, transformers + , unordered-containers, vector, yaml + }: + mkDerivation { + pname = "hpack"; + version = "0.35.3"; + sha256 = "1kh5v2hj4y3f73hjcqxr4q60cbva4lmi43iahrrnhj789h5b5k94"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bifunctors bytestring Cabal containers crypton deepseq + directory filepath Glob http-client http-client-tls http-types + infer-license pretty scientific text transformers + unordered-containers vector yaml + ]; + executableHaskellDepends = [ + aeson base bifunctors bytestring Cabal containers crypton deepseq + directory filepath Glob http-client http-client-tls http-types + infer-license pretty scientific text transformers + unordered-containers vector yaml + ]; + testHaskellDepends = [ + aeson base bifunctors bytestring Cabal containers crypton deepseq + directory filepath Glob hspec http-client http-client-tls + http-types HUnit infer-license interpolate mockery pretty + QuickCheck scientific template-haskell temporary text transformers + unordered-containers vector yaml + ]; + testToolDepends = [ hspec-discover ]; + description = "A modern format for Haskell packages"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + mainProgram = "hpack"; + }) {}; + "hpack-convert" = callPackage ({ mkDerivation, aeson, aeson-qq, base, base-compat, bytestring , Cabal, containers, deepseq, directory, filepath, Glob, hspec @@ -148638,6 +147971,29 @@ self: { mainProgram = "hpc-codecov"; }) {}; + "hpc-codecov_0_4_0_0" = callPackage + ({ mkDerivation, array, base, bytestring, containers, directory + , filepath, hpc, process, tasty, tasty-hunit, time + }: + mkDerivation { + pname = "hpc-codecov"; + version = "0.4.0.0"; + sha256 = "0y545jm79p5jzvid27nqfyv5814iykk5wxdixv25mar49w5zd494"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + array base bytestring containers directory filepath hpc time + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ + base directory filepath process tasty tasty-hunit + ]; + description = "Generate codecov report from hpc data"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "hpc-codecov"; + }) {}; + "hpc-coveralls" = callPackage ({ mkDerivation, aeson, async, base, bytestring, Cabal, cmdargs , containers, curl, directory, directory-tree, hpc, HUnit, process @@ -148893,39 +148249,6 @@ self: { }) {}; "hpqtypes" = callPackage - ({ mkDerivation, aeson, async, base, bytestring, Cabal, containers - , directory, exceptions, filepath, HUnit, lifted-base - , monad-control, mtl, postgresql, QuickCheck, random, resource-pool - , scientific, semigroups, test-framework, test-framework-hunit - , text, text-show, time, transformers, transformers-base - , unordered-containers, uuid-types, vector - }: - mkDerivation { - pname = "hpqtypes"; - version = "1.9.4.0"; - sha256 = "0m0jpv0d2zynhn53gbjb50sb91lxss71qnzhcy30agxvf29qpi0w"; - revision = "2"; - editedCabalFile = "1xpbb5js710rd7kbdgx6hl10dl7n95yp6pidqrh8f9ifwx076k3g"; - setupHaskellDepends = [ base Cabal directory filepath ]; - libraryHaskellDepends = [ - aeson async base bytestring containers exceptions lifted-base - monad-control mtl resource-pool semigroups text text-show time - transformers transformers-base uuid-types vector - ]; - librarySystemDepends = [ postgresql ]; - testHaskellDepends = [ - aeson base bytestring exceptions HUnit lifted-base monad-control - mtl QuickCheck random scientific test-framework - test-framework-hunit text text-show time transformers-base - unordered-containers uuid-types vector - ]; - description = "Haskell bindings to libpqtypes"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {inherit (pkgs) postgresql;}; - - "hpqtypes_1_11_1_1" = callPackage ({ mkDerivation, aeson, async, base, bytestring, containers , exceptions, HUnit, libpq, lifted-base, monad-control, mtl , QuickCheck, random, resource-pool, scientific, semigroups @@ -151257,6 +150580,8 @@ self: { pname = "hsblst"; version = "0.0.2"; sha256 = "08sj5r714rzkdbvx8bzhk3lvim7jiaxbpj4xpz58bxx13ds2dxni"; + revision = "1"; + editedCabalFile = "14bj4m38786x7mjddfxyyjv218jmnqhd7ipinq03hbwa2drx3jij"; libraryHaskellDepends = [ base deepseq memory ]; libraryToolDepends = [ c2hs ]; testHaskellDepends = [ @@ -151946,19 +151271,21 @@ self: { }) {}; "hscrtmpl" = callPackage - ({ mkDerivation, base, directory, filepath, process, time }: + ({ mkDerivation, ansi-wl-pprint, base, directory, filepath, heredoc + , optparse-applicative, process, time + }: mkDerivation { pname = "hscrtmpl"; - version = "1.6"; - sha256 = "166xp46bxi079h9bpr8xfnlzzivwkhnykv7g7kg7rnp35cmwxshm"; + version = "2.0"; + sha256 = "1pqqgwiany0i5pzmyzyn7j4xakads4phinzzfvmyanlj0n8i88rw"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ - base directory filepath process time + ansi-wl-pprint base directory filepath heredoc optparse-applicative + process time ]; - description = "Haskell shell script template"; + description = "Haskell shell script templates"; license = lib.licenses.isc; - mainProgram = "hscrtmpl"; }) {}; "hscuid" = callPackage @@ -152195,6 +151522,7 @@ self: { ]; description = "sendxmpp clone, sending XMPP messages via CLI"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "hsendxmpp"; }) {}; @@ -152495,6 +151823,25 @@ self: { broken = true; }) {}; + "hsini_0_5_2" = callPackage + ({ mkDerivation, base, bytestring, containers, mtl, parsec, tasty + , tasty-hunit, tasty-quickcheck, tasty-th + }: + mkDerivation { + pname = "hsini"; + version = "0.5.2"; + sha256 = "14mybpf6qkcwrji9j2bvajqfb4p3ybi3n8rvblggpxd9fvm5gak2"; + libraryHaskellDepends = [ base bytestring containers mtl parsec ]; + testHaskellDepends = [ + base bytestring containers mtl parsec tasty tasty-hunit + tasty-quickcheck tasty-th + ]; + description = "ini configuration files"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "hsinspect" = callPackage ({ mkDerivation, base, containers, directory, filepath, ghc , ghc-boot, text, time, transformers @@ -152553,28 +151900,6 @@ self: { }) {}; "hsinstall" = callPackage - ({ mkDerivation, ansi-wl-pprint, base, Cabal, directory, exceptions - , filepath, heredoc, newtype-generics, optparse-applicative - , process, safe-exceptions, transformers - }: - mkDerivation { - pname = "hsinstall"; - version = "2.7"; - sha256 = "142gdcdka2i61hv9pxpqfi25h5nzz8k7nxlnymfmn4inpayvdr29"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base directory filepath ]; - executableHaskellDepends = [ - ansi-wl-pprint base Cabal directory exceptions filepath heredoc - newtype-generics optparse-applicative process safe-exceptions - transformers - ]; - description = "Install Haskell software"; - license = lib.licenses.isc; - mainProgram = "hsinstall"; - }) {}; - - "hsinstall_2_8" = callPackage ({ mkDerivation, ansi-wl-pprint, base, Cabal, directory, exceptions , filepath, heredoc, newtype-generics, optparse-applicative , process, safe-exceptions, transformers @@ -152593,7 +151918,6 @@ self: { ]; description = "Install Haskell software"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; mainProgram = "hsinstall"; }) {}; @@ -152754,32 +152078,6 @@ self: { }) {}; "hslua" = callPackage - ({ mkDerivation, base, bytestring, containers, exceptions - , hslua-aeson, hslua-classes, hslua-core, hslua-marshalling - , hslua-objectorientation, hslua-packaging, lua, lua-arbitrary, mtl - , QuickCheck, quickcheck-instances, tasty, tasty-hslua, tasty-hunit - , text - }: - mkDerivation { - pname = "hslua"; - version = "2.2.1"; - sha256 = "1q587cjwb29jsf71hhmra6djr2sycbx2hr0rhwlgvb8ax699vkv3"; - libraryHaskellDepends = [ - base bytestring containers exceptions hslua-aeson hslua-classes - hslua-core hslua-marshalling hslua-objectorientation - hslua-packaging mtl text - ]; - testHaskellDepends = [ - base bytestring containers exceptions hslua-aeson hslua-classes - hslua-core hslua-marshalling hslua-objectorientation - hslua-packaging lua lua-arbitrary mtl QuickCheck - quickcheck-instances tasty tasty-hslua tasty-hunit text - ]; - description = "Bindings to Lua, an embeddable scripting language"; - license = lib.licenses.mit; - }) {}; - - "hslua_2_3_0" = callPackage ({ mkDerivation, base, bytestring, containers, exceptions , hslua-aeson, hslua-classes, hslua-core, hslua-marshalling , hslua-objectorientation, hslua-packaging, hslua-typing, lua @@ -152803,33 +152101,9 @@ self: { ]; description = "Bindings to Lua, an embeddable scripting language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-aeson" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, hashable - , hslua-core, hslua-marshalling, mtl, QuickCheck - , quickcheck-instances, scientific, tasty, tasty-quickcheck, text - , unordered-containers, vector - }: - mkDerivation { - pname = "hslua-aeson"; - version = "2.2.1"; - sha256 = "0igmkay5bf3wg1n6rqm20kjv1xq36x552lgdvr1vlpwikgsiq8mb"; - libraryHaskellDepends = [ - aeson base bytestring containers hashable hslua-core - hslua-marshalling mtl scientific text unordered-containers vector - ]; - testHaskellDepends = [ - aeson base bytestring containers hashable hslua-core - hslua-marshalling mtl QuickCheck quickcheck-instances scientific - tasty tasty-quickcheck text unordered-containers vector - ]; - description = "Allow aeson data types to be used with Lua"; - license = lib.licenses.mit; - }) {}; - - "hslua-aeson_2_3_0_1" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, hashable , hslua-core, hslua-marshalling, mtl, QuickCheck , quickcheck-instances, scientific, tasty, tasty-hunit @@ -152850,33 +152124,9 @@ self: { ]; description = "Allow aeson data types to be used with Lua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-classes" = callPackage - ({ mkDerivation, base, bytestring, containers, exceptions - , hslua-core, hslua-marshalling, lua-arbitrary, QuickCheck - , quickcheck-instances, tasty, tasty-hslua, tasty-hunit - , tasty-quickcheck, text - }: - mkDerivation { - pname = "hslua-classes"; - version = "2.2.0"; - sha256 = "1z7ym3whcq16k2cm9jf7sf0vwmp52iv1f0iicvv4jk6xks9d6ia1"; - libraryHaskellDepends = [ - base bytestring containers exceptions hslua-core hslua-marshalling - text - ]; - testHaskellDepends = [ - base bytestring containers exceptions hslua-core hslua-marshalling - lua-arbitrary QuickCheck quickcheck-instances tasty tasty-hslua - tasty-hunit tasty-quickcheck text - ]; - description = "Type classes for HsLua"; - license = lib.licenses.mit; - }) {}; - - "hslua-classes_2_3_0" = callPackage ({ mkDerivation, base, bytestring, containers, exceptions , hslua-core, hslua-marshalling, lua-arbitrary, QuickCheck , quickcheck-instances, tasty, tasty-hslua, tasty-hunit @@ -152897,7 +152147,6 @@ self: { ]; description = "Type classes for HsLua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-cli" = callPackage @@ -152916,30 +152165,9 @@ self: { ]; description = "Command-line interface for Lua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-core" = callPackage - ({ mkDerivation, base, bytestring, exceptions, lua, lua-arbitrary - , mtl, QuickCheck, quickcheck-instances, tasty, tasty-hunit - , tasty-quickcheck, text - }: - mkDerivation { - pname = "hslua-core"; - version = "2.2.1"; - sha256 = "0hy3a7rn940bcj0shxyk75dndwl23wwmmvbnwnay36py60hy3rbq"; - libraryHaskellDepends = [ - base bytestring exceptions lua mtl text - ]; - testHaskellDepends = [ - base bytestring exceptions lua lua-arbitrary mtl QuickCheck - quickcheck-instances tasty tasty-hunit tasty-quickcheck text - ]; - description = "Bindings to Lua, an embeddable scripting language"; - license = lib.licenses.mit; - }) {}; - - "hslua-core_2_3_1" = callPackage ({ mkDerivation, base, bytestring, exceptions, lua, lua-arbitrary , mtl, QuickCheck, quickcheck-instances, tasty, tasty-hunit , tasty-quickcheck, text @@ -152957,7 +152185,6 @@ self: { ]; description = "Bindings to Lua, an embeddable scripting language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-examples" = callPackage @@ -152988,27 +152215,6 @@ self: { }) {}; "hslua-marshalling" = callPackage - ({ mkDerivation, base, bytestring, containers, hslua-core - , lua-arbitrary, mtl, QuickCheck, quickcheck-instances, tasty - , tasty-hslua, tasty-hunit, tasty-quickcheck, text - }: - mkDerivation { - pname = "hslua-marshalling"; - version = "2.2.1"; - sha256 = "1xmix1frfcyv4p51rnshrg02gba7di7nrrc6chsq71d3mbwhyask"; - libraryHaskellDepends = [ - base bytestring containers hslua-core mtl text - ]; - testHaskellDepends = [ - base bytestring containers hslua-core lua-arbitrary mtl QuickCheck - quickcheck-instances tasty tasty-hslua tasty-hunit tasty-quickcheck - text - ]; - description = "Marshalling of values between Haskell and Lua"; - license = lib.licenses.mit; - }) {}; - - "hslua-marshalling_2_3_0" = callPackage ({ mkDerivation, base, bytestring, containers, hslua-core , lua-arbitrary, mtl, QuickCheck, quickcheck-instances, tasty , tasty-hslua, tasty-hunit, tasty-quickcheck, text @@ -153027,26 +152233,9 @@ self: { ]; description = "Marshalling of values between Haskell and Lua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-module-doclayout" = callPackage - ({ mkDerivation, base, doclayout, hslua, tasty, tasty-hunit - , tasty-lua, text - }: - mkDerivation { - pname = "hslua-module-doclayout"; - version = "1.0.4"; - sha256 = "14sqffgcrhhrv7k4j8b1l41mn5gqlp8yzggd727746kjl0n56hqq"; - libraryHaskellDepends = [ base doclayout hslua text ]; - testHaskellDepends = [ - base doclayout hslua tasty tasty-hunit tasty-lua text - ]; - description = "Lua module wrapping Text.DocLayout."; - license = lib.licenses.mit; - }) {}; - - "hslua-module-doclayout_1_1_0" = callPackage ({ mkDerivation, base, doclayout, hslua, tasty, tasty-hunit , tasty-lua, text }: @@ -153060,29 +152249,9 @@ self: { ]; description = "Lua module wrapping Text.DocLayout."; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-module-path" = callPackage - ({ mkDerivation, base, filepath, hslua-core, hslua-marshalling - , hslua-packaging, tasty, tasty-hunit, tasty-lua, text - }: - mkDerivation { - pname = "hslua-module-path"; - version = "1.0.3"; - sha256 = "1sy2k4mb263kg85vkf39ja84xz5kvm6z61xn62jy1swhrvvd96sr"; - libraryHaskellDepends = [ - base filepath hslua-core hslua-marshalling hslua-packaging text - ]; - testHaskellDepends = [ - base filepath hslua-core hslua-marshalling hslua-packaging tasty - tasty-hunit tasty-lua text - ]; - description = "Lua module to work with file paths"; - license = lib.licenses.mit; - }) {}; - - "hslua-module-path_1_1_0" = callPackage ({ mkDerivation, base, filepath, hslua-core, hslua-marshalling , hslua-packaging, tasty, tasty-hunit, tasty-lua, text }: @@ -153099,30 +152268,9 @@ self: { ]; description = "Lua module to work with file paths"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-module-system" = callPackage - ({ mkDerivation, base, directory, exceptions, hslua-core - , hslua-marshalling, hslua-packaging, tasty, tasty-hunit, tasty-lua - , temporary, text - }: - mkDerivation { - pname = "hslua-module-system"; - version = "1.0.3"; - sha256 = "08rajlihgsg843sgvlvh7qx43s5yiqqccvnxa336hw06ppfycyf9"; - libraryHaskellDepends = [ - base directory exceptions hslua-core hslua-marshalling - hslua-packaging temporary text - ]; - testHaskellDepends = [ - base hslua-core hslua-packaging tasty tasty-hunit tasty-lua text - ]; - description = "Lua module wrapper around Haskell's System module"; - license = lib.licenses.mit; - }) {}; - - "hslua-module-system_1_1_0_1" = callPackage ({ mkDerivation, base, directory, exceptions, hslua-core , hslua-marshalling, hslua-packaging, tasty, tasty-hunit, tasty-lua , temporary, text @@ -153140,28 +152288,9 @@ self: { ]; description = "Lua module wrapper around Haskell's System module"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-module-text" = callPackage - ({ mkDerivation, base, hslua-core, hslua-marshalling - , hslua-packaging, tasty, tasty-hunit, tasty-lua, text - }: - mkDerivation { - pname = "hslua-module-text"; - version = "1.0.3.1"; - sha256 = "025n8vmaq22bl1x60hpg57ih44g6z71jc1qnlxfsi06hram1wcqc"; - libraryHaskellDepends = [ - base hslua-core hslua-marshalling hslua-packaging text - ]; - testHaskellDepends = [ - base hslua-core hslua-packaging tasty tasty-hunit tasty-lua text - ]; - description = "Lua module for text"; - license = lib.licenses.mit; - }) {}; - - "hslua-module-text_1_1_0_1" = callPackage ({ mkDerivation, base, hslua-core, hslua-marshalling , hslua-packaging, tasty, tasty-hunit, tasty-lua, text }: @@ -153177,29 +152306,9 @@ self: { ]; description = "Lua module for text"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-module-version" = callPackage - ({ mkDerivation, base, filepath, hslua-core, hslua-marshalling - , hslua-packaging, tasty, tasty-hunit, tasty-lua, text - }: - mkDerivation { - pname = "hslua-module-version"; - version = "1.0.3"; - sha256 = "1v24lbbagvaz0hacq4525snp6smz8yc5ifrxg89z1y5bbn7v46f5"; - libraryHaskellDepends = [ - base filepath hslua-core hslua-marshalling hslua-packaging text - ]; - testHaskellDepends = [ - base filepath hslua-core hslua-marshalling hslua-packaging tasty - tasty-hunit tasty-lua text - ]; - description = "Lua module to work with version specifiers"; - license = lib.licenses.mit; - }) {}; - - "hslua-module-version_1_1_0" = callPackage ({ mkDerivation, base, filepath, hslua-core, hslua-marshalling , hslua-packaging, tasty, tasty-hunit, tasty-lua, text }: @@ -153216,7 +152325,6 @@ self: { ]; description = "Lua module to work with version specifiers"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-module-zip" = callPackage @@ -153240,33 +152348,9 @@ self: { ]; description = "Lua module to work with file zips"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-objectorientation" = callPackage - ({ mkDerivation, base, bytestring, containers, exceptions - , hslua-core, hslua-marshalling, lua-arbitrary, mtl, QuickCheck - , quickcheck-instances, tasty, tasty-hslua, tasty-hunit - , tasty-quickcheck, text - }: - mkDerivation { - pname = "hslua-objectorientation"; - version = "2.2.1"; - sha256 = "13011yzz6lrgl2gasn9w5ggdqgrdz49hhqk1h259qd9gq29jnq3y"; - libraryHaskellDepends = [ - base bytestring containers exceptions hslua-core hslua-marshalling - mtl text - ]; - testHaskellDepends = [ - base bytestring containers exceptions hslua-core hslua-marshalling - lua-arbitrary mtl QuickCheck quickcheck-instances tasty tasty-hslua - tasty-hunit tasty-quickcheck text - ]; - description = "Object orientation tools for HsLua"; - license = lib.licenses.mit; - }) {}; - - "hslua-objectorientation_2_3_0" = callPackage ({ mkDerivation, base, bytestring, containers, exceptions , hslua-core, hslua-marshalling, hslua-typing, lua-arbitrary, mtl , QuickCheck, quickcheck-instances, tasty, tasty-hslua, tasty-hunit @@ -153287,31 +152371,9 @@ self: { ]; description = "Object orientation tools for HsLua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-packaging" = callPackage - ({ mkDerivation, base, bytestring, containers, hslua-core - , hslua-marshalling, hslua-objectorientation, mtl, tasty - , tasty-hslua, tasty-hunit, text - }: - mkDerivation { - pname = "hslua-packaging"; - version = "2.2.1"; - sha256 = "1yxfrsxmmsb96lyfihlk9ks53l2z2aln3whfqaha7grs3gx1yaib"; - libraryHaskellDepends = [ - base containers hslua-core hslua-marshalling - hslua-objectorientation mtl text - ]; - testHaskellDepends = [ - base bytestring hslua-core hslua-marshalling - hslua-objectorientation mtl tasty tasty-hslua tasty-hunit text - ]; - description = "Utilities to build Lua modules"; - license = lib.licenses.mit; - }) {}; - - "hslua-packaging_2_3_0" = callPackage ({ mkDerivation, base, bytestring, containers, hslua-core , hslua-marshalling, hslua-objectorientation, hslua-typing, mtl , tasty, tasty-hslua, tasty-hunit, text @@ -153331,7 +152393,6 @@ self: { ]; description = "Utilities to build Lua modules"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hslua-repl" = callPackage @@ -153348,8 +152409,6 @@ self: { ]; description = "Isocline-based Lua REPL"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hslua-typing" = callPackage @@ -153370,8 +152429,6 @@ self: { ]; description = "Type specifiers for Lua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "hsluv-haskell" = callPackage @@ -153752,8 +152809,8 @@ self: { }: mkDerivation { pname = "hspec"; - version = "2.9.7"; - sha256 = "092sfqjkargxxszp9jjqa8ldjz0xv34jwn6k21q59ys5ckvsrpc1"; + version = "2.10.10"; + sha256 = "1903bm001vh9cxmhh87p3c76136dl6aq82srqgvdb5hpsmimwjws"; libraryHaskellDepends = [ base hspec-core hspec-discover hspec-expectations QuickCheck ]; @@ -153761,14 +152818,14 @@ self: { license = lib.licenses.mit; }) {}; - "hspec_2_11_1" = callPackage + "hspec_2_11_4" = callPackage ({ mkDerivation, base, hspec-core, hspec-discover , hspec-expectations, QuickCheck }: mkDerivation { pname = "hspec"; - version = "2.11.1"; - sha256 = "0rm2hcnhka0b8z7kdlzsd4lvk5jna29n9qfrfxzvn5a8ncj0mb71"; + version = "2.11.4"; + sha256 = "0yk34qspm97l32qpk6i0gijvr4xfnhq89wch12mifxv2pcxywdpi"; libraryHaskellDepends = [ base hspec-core hspec-discover hspec-expectations QuickCheck ]; @@ -153778,32 +152835,20 @@ self: { }) {}; "hspec-api" = callPackage - ({ mkDerivation, base, hspec, hspec-core, hspec-discover }: - mkDerivation { - pname = "hspec-api"; - version = "2.9.0"; - sha256 = "0a260pjz0fyj51wpdnlb5kzrrwzdam2rxr019c5xrl14gg77a007"; - libraryHaskellDepends = [ base hspec-core ]; - testHaskellDepends = [ base hspec hspec-core ]; - testToolDepends = [ hspec-discover ]; - description = "A Testing Framework for Haskell"; - license = lib.licenses.mit; - }) {}; - - "hspec-api_2_11_1" = callPackage ({ mkDerivation, base, hspec, hspec-core, hspec-discover , transformers }: mkDerivation { pname = "hspec-api"; - version = "2.11.1"; - sha256 = "0jq8x5rfskb29nh1hpy9y1rc7g6nwbdba8nnri5kdc3jf3jwmnff"; + version = "2.11.4"; + sha256 = "09z0jxiv02j83q79aws948vr6vfqzpv5dm4dwwfqgxa715s9mlg8"; libraryHaskellDepends = [ base hspec-core transformers ]; testHaskellDepends = [ base hspec hspec-core transformers ]; testToolDepends = [ hspec-discover ]; description = "A Testing Framework for Haskell"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-attoparsec" = callPackage @@ -153896,25 +152941,25 @@ self: { "hspec-core" = callPackage ({ mkDerivation, ansi-terminal, array, base, base-orphans - , call-stack, clock, deepseq, directory, filepath, ghc, ghc-boot-th + , call-stack, deepseq, directory, filepath, haskell-lexer , hspec-expectations, hspec-meta, HUnit, process, QuickCheck , quickcheck-io, random, setenv, silently, stm, temporary - , tf-random, transformers + , tf-random, time, transformers }: mkDerivation { pname = "hspec-core"; - version = "2.9.7"; - sha256 = "040rzqiqwkp373jjpij8lkmv08pp2ya92zzcf95bw8px215rp08n"; + version = "2.10.10"; + sha256 = "1djmiy5xjnx71bjagmvipc5dsnvhakm03y72g3vyg7iggxqr6iv4"; libraryHaskellDepends = [ - ansi-terminal array base call-stack clock deepseq directory - filepath ghc ghc-boot-th hspec-expectations HUnit QuickCheck - quickcheck-io random setenv stm tf-random transformers + ansi-terminal array base call-stack deepseq directory filepath + haskell-lexer hspec-expectations HUnit process QuickCheck + quickcheck-io random setenv stm tf-random time transformers ]; testHaskellDepends = [ - ansi-terminal array base base-orphans call-stack clock deepseq - directory filepath ghc ghc-boot-th hspec-expectations hspec-meta - HUnit process QuickCheck quickcheck-io random setenv silently stm - temporary tf-random transformers + ansi-terminal array base base-orphans call-stack deepseq directory + filepath haskell-lexer hspec-expectations hspec-meta HUnit process + QuickCheck quickcheck-io random setenv silently stm temporary + tf-random time transformers ]; testToolDepends = [ hspec-meta ]; testTarget = "--test-option=--skip --test-option='Test.Hspec.Core.Runner.hspecResult runs specs in parallel'"; @@ -153922,7 +152967,7 @@ self: { license = lib.licenses.mit; }) {}; - "hspec-core_2_11_1" = callPackage + "hspec-core_2_11_4" = callPackage ({ mkDerivation, ansi-terminal, array, base, base-orphans , call-stack, deepseq, directory, filepath, haskell-lexer , hspec-expectations, hspec-meta, HUnit, process, QuickCheck @@ -153931,8 +152976,8 @@ self: { }: mkDerivation { pname = "hspec-core"; - version = "2.11.1"; - sha256 = "1r8jnhfg6yn4spq5bml4rg47ifkq7xsk6lb1mnikly7l5x91nscl"; + version = "2.11.4"; + sha256 = "0h1ilavzz23wr3659rx9crp0mijr8sz9qqhfm9fwq5hq91n6g1r8"; libraryHaskellDepends = [ ansi-terminal array base call-stack deepseq directory filepath haskell-lexer hspec-expectations HUnit process QuickCheck @@ -153999,8 +153044,8 @@ self: { }: mkDerivation { pname = "hspec-discover"; - version = "2.9.7"; - sha256 = "0536kdxjw6p8b6gcwvmr22jbmb6cgzbddi0fkd01b2m847z37sb5"; + version = "2.10.10"; + sha256 = "0cig2l1l8wgxrg2s2srzsrws5vqa0fgf249gb1g222x91s63h2d8"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base directory filepath ]; @@ -154015,14 +153060,14 @@ self: { maintainers = [ lib.maintainers.maralorn ]; }) {}; - "hspec-discover_2_11_1" = callPackage + "hspec-discover_2_11_4" = callPackage ({ mkDerivation, base, directory, filepath, hspec-meta, mockery , QuickCheck }: mkDerivation { pname = "hspec-discover"; - version = "2.11.1"; - sha256 = "15jcz0dldq9jjzciv7vwnlxw9h7vbglvcgq90zwb50lpj1d9l916"; + version = "2.11.4"; + sha256 = "05j8jbjkl18c0w6nnaf0ymr449pp4vhnlkdri5470jyzqsawp879"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base directory filepath ]; @@ -154050,12 +153095,14 @@ self: { license = lib.licenses.mit; }) {}; - "hspec-expectations_0_8_3" = callPackage + "hspec-expectations_0_8_4" = callPackage ({ mkDerivation, base, call-stack, HUnit, nanospec }: mkDerivation { pname = "hspec-expectations"; - version = "0.8.3"; - sha256 = "0wi1s0byfrlay98w1w38lj0mi0ifqzhvkl05q5dv5yr1wl50mgvi"; + version = "0.8.4"; + sha256 = "1zr1pqchcwglfr5dvcrgc1l5x924n9w09n2zr68dmkqf4dzdx3bv"; + revision = "2"; + editedCabalFile = "14zzsjqcz1zbnvi50i82lx84nc8b5da7ar5cazzh44lklyag0ds2"; libraryHaskellDepends = [ base call-stack HUnit ]; testHaskellDepends = [ base call-stack HUnit nanospec ]; description = "Catchy combinators for HUnit"; @@ -154376,8 +153423,8 @@ self: { }: mkDerivation { pname = "hspec-meta"; - version = "2.9.3"; - sha256 = "1raxwpsmcijl3x2h5naw6aydhbiknxvhj3x7v384bi1rqi51ainm"; + version = "2.10.5"; + sha256 = "0jgagvmvp3nvz9vdgvr42x0xv7nnjzz1rshs6x4wzc38qvcrssbn"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -154395,26 +153442,27 @@ self: { mainProgram = "hspec-meta-discover"; }) {}; - "hspec-meta_2_10_5" = callPackage - ({ mkDerivation, ansi-terminal, array, base, call-stack, clock - , deepseq, directory, filepath, ghc, ghc-boot-th, QuickCheck - , quickcheck-io, random, setenv, stm, time, transformers + "hspec-meta_2_11_4" = callPackage + ({ mkDerivation, ansi-terminal, array, base, call-stack, deepseq + , directory, filepath, haskell-lexer, hspec-expectations, HUnit + , process, QuickCheck, quickcheck-io, random, stm, tf-random, time + , transformers }: mkDerivation { pname = "hspec-meta"; - version = "2.10.5"; - sha256 = "0jgagvmvp3nvz9vdgvr42x0xv7nnjzz1rshs6x4wzc38qvcrssbn"; + version = "2.11.4"; + sha256 = "1bzgr0sxm3arrbm6dj819sd3f2h7q5siv1n3lzw648ijhqrlkpja"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - ansi-terminal array base call-stack clock deepseq directory - filepath ghc ghc-boot-th QuickCheck quickcheck-io random setenv stm - time transformers + ansi-terminal array base call-stack deepseq directory filepath + haskell-lexer hspec-expectations HUnit process QuickCheck + quickcheck-io random stm tf-random time transformers ]; executableHaskellDepends = [ - ansi-terminal array base call-stack clock deepseq directory - filepath ghc ghc-boot-th QuickCheck quickcheck-io random setenv - time transformers + ansi-terminal array base call-stack deepseq directory filepath + haskell-lexer hspec-expectations HUnit process QuickCheck + quickcheck-io random stm tf-random time transformers ]; description = "A version of Hspec which is used to test Hspec itself"; license = lib.licenses.mit; @@ -154468,6 +153516,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Read environment variables for hspec tests"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hspec-parsec" = callPackage @@ -154584,27 +153634,6 @@ self: { }) {}; "hspec-smallcheck" = callPackage - ({ mkDerivation, base, base-orphans, call-stack, hspec, hspec-core - , HUnit, QuickCheck, smallcheck - }: - mkDerivation { - pname = "hspec-smallcheck"; - version = "0.5.2"; - sha256 = "06c1ym793zkdwi4bxk5f4l7m1n1bg5jmnm0p68q2pa9rlhk1lc4s"; - revision = "1"; - editedCabalFile = "0bih2r7pdfca8jw9jii84nsx3q6xfwjylsilgwxx02xl35dv0nkp"; - libraryHaskellDepends = [ - base call-stack hspec-core HUnit smallcheck - ]; - testHaskellDepends = [ - base base-orphans call-stack hspec hspec-core HUnit QuickCheck - smallcheck - ]; - description = "SmallCheck support for the Hspec testing framework"; - license = lib.licenses.mit; - }) {}; - - "hspec-smallcheck_0_5_3" = callPackage ({ mkDerivation, base, base-orphans, call-stack, hspec, hspec-core , hspec-discover, HUnit, QuickCheck, smallcheck }: @@ -154622,7 +153651,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "SmallCheck support for the Hspec testing framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hspec-snap" = callPackage @@ -154743,6 +153771,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "hspec-tmp-proc_0_5_2_0" = callPackage + ({ mkDerivation, base, hspec, tmp-proc }: + mkDerivation { + pname = "hspec-tmp-proc"; + version = "0.5.2.0"; + sha256 = "0p5mjcapvplw21bkiknpg30f583d7ssvh06fc2yg004m0ar9y7na"; + libraryHaskellDepends = [ base hspec tmp-proc ]; + description = "Simplify use of tmp-proc from hspec tests"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "hspec-wai" = callPackage ({ mkDerivation, base, base-compat, bytestring, case-insensitive , hspec, hspec-core, hspec-expectations, http-types, QuickCheck @@ -155262,6 +154302,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "Haskell for Unix shell scripting tasks"; license = "LGPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hssourceinfo" = callPackage @@ -155786,8 +154828,8 @@ self: { pname = "htaglib"; version = "1.2.0"; sha256 = "0ph04j1ysjzzrcyllgibzrzfv5g5mgpa6s0ksxww15aryipw65sa"; - revision = "2"; - editedCabalFile = "1vb9izb058z8lsq5yp4c0w4lralb0mzr5g6hw4mvd82yjf07il0z"; + revision = "3"; + editedCabalFile = "199iqhjcznd3xp5qiinmmasz4aynhgpmsij1ajswasnd4ng127lq"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base bytestring text transformers ]; librarySystemDepends = [ taglib ]; @@ -155823,8 +154865,8 @@ self: { }: mkDerivation { pname = "htalkat"; - version = "0.1.2.2"; - sha256 = "08w501lyhhr5d7w6s9zvhrwk8sm3kkr5v6l2h6ghazqcvlrl63v2"; + version = "0.1.2.3"; + sha256 = "1z2mdkacnchrjd2w1czgwjr0gnm63d9mm500br7r89gc0qjkbi26"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -156137,17 +155179,20 @@ self: { ]; description = "A high-performance HTML tokenizer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "html-parse-util" = callPackage ({ mkDerivation, attoparsec, base, html-parse, text }: mkDerivation { pname = "html-parse-util"; - version = "0.2.2"; - sha256 = "0341fs6140dn61lmp2cy6gk0cxyqval7lwr68by3rp158mdb66ix"; + version = "0.2.3"; + sha256 = "1p4i3xmz6q5f1qmiwsf4085ixsiibgy6zvmji078m8bxmh00lgdb"; libraryHaskellDepends = [ attoparsec base html-parse text ]; description = "Utility functions for working with html-parse"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "html-presentation-text" = callPackage @@ -156502,10 +155547,10 @@ self: { }: mkDerivation { pname = "http-api-data"; - version = "0.4.3"; - sha256 = "171bw2a44pg50d3y77gw2y9vmx72laky7hnn5hw6r93pnjmlf9yz"; - revision = "6"; - editedCabalFile = "0q4rhz81r5v0z1mn7x9q0ldbfv1a2cp3dpw8s2j96halsq34l4zl"; + version = "0.5"; + sha256 = "0gxpfrkr83gq5kndfbyg03ps0g421bn4vafdqng7wmnn5hhb9vgp"; + revision = "1"; + editedCabalFile = "1gcqa0lm804cqv1xdaxz87mg0fv7d98i57px8al7qgdzpldma17k"; libraryHaskellDepends = [ attoparsec attoparsec-iso8601 base base-compat bytestring containers cookie hashable http-types tagged text time-compat @@ -156521,25 +155566,24 @@ self: { license = lib.licenses.bsd3; }) {}; - "http-api-data_0_5_1" = callPackage - ({ mkDerivation, attoparsec, attoparsec-iso8601, base, base-compat - , bytestring, containers, cookie, hashable, hspec, hspec-discover - , http-types, HUnit, QuickCheck, quickcheck-instances, tagged, text - , time-compat, transformers, unordered-containers, uuid-types + "http-api-data_0_6" = callPackage + ({ mkDerivation, base, bytestring, containers, cookie, hashable + , hspec, hspec-discover, http-types, HUnit, QuickCheck + , quickcheck-instances, tagged, text, text-iso8601, time-compat + , transformers, unordered-containers, uuid-types }: mkDerivation { pname = "http-api-data"; - version = "0.5.1"; - sha256 = "0aqjfzxzk3z9qqxrf80sjarnxxkp016z86n3gira4fg14i4ccrk1"; + version = "0.6"; + sha256 = "0ihkvjhm1rfgfnr2s5kzsmmqbnxgmyaxi0gqzqs4lxyhvy14743l"; libraryHaskellDepends = [ - attoparsec attoparsec-iso8601 base base-compat bytestring - containers cookie hashable http-types tagged text time-compat - transformers unordered-containers uuid-types + base bytestring containers cookie hashable http-types tagged text + text-iso8601 time-compat transformers unordered-containers + uuid-types ]; testHaskellDepends = [ - base base-compat bytestring cookie hspec HUnit QuickCheck - quickcheck-instances text time-compat unordered-containers - uuid-types + base bytestring cookie hspec HUnit QuickCheck quickcheck-instances + text time-compat unordered-containers uuid-types ]; testToolDepends = [ hspec-discover ]; description = "Converting to/from HTTP API data like URL pieces, headers and query parameters"; @@ -156556,8 +155600,8 @@ self: { pname = "http-api-data-qq"; version = "0.1.0.0"; sha256 = "1lvfdbprdwq09k1wkjfvvkpi79053dc4kzkv4g1cx94qb1flbd7a"; - revision = "3"; - editedCabalFile = "1ywq3kl32rp57rb2p3y79jrbi99p32j30w9nrm94jgf4m2jdahc5"; + revision = "4"; + editedCabalFile = "1v9jac4aigxyk6a6v7ydxsbwsi6pwlchxnph58vb66xyb17cazsn"; libraryHaskellDepends = [ base http-api-data template-haskell text ]; @@ -156933,6 +155977,8 @@ self: { pname = "http-conduit"; version = "2.3.8.1"; sha256 = "11zf4hyw8f1gpj0w1cmgc9g62xwy2v4hhzqazdsla4q49iqbzxgd"; + revision = "1"; + editedCabalFile = "1wvr0v948s5fmlf47r4pqjan355x6v65rm7dz7y65ngj10xwk5f9"; libraryHaskellDepends = [ aeson attoparsec base bytestring conduit conduit-extra http-client http-client-tls http-types mtl resourcet transformers unliftio-core @@ -156949,29 +155995,30 @@ self: { license = lib.licenses.bsd3; }) {}; - "http-conduit_2_3_8_2" = callPackage - ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring - , case-insensitive, conduit, conduit-extra, cookie - , crypton-connection, data-default-class, hspec, http-client - , http-client-tls, http-types, HUnit, mtl, network, resourcet - , streaming-commons, temporary, text, time, tls, transformers - , unliftio, unliftio-core, utf8-string, wai, wai-conduit, warp - , warp-tls + "http-conduit_2_3_8_3" = callPackage + ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base + , blaze-builder, bytestring, case-insensitive, conduit + , conduit-extra, cookie, crypton-connection, data-default-class + , hspec, http-client, http-client-tls, http-types, HUnit, mtl + , network, resourcet, streaming-commons, temporary, text, time, tls + , transformers, unliftio, unliftio-core, utf8-string, wai + , wai-conduit, warp, warp-tls }: mkDerivation { pname = "http-conduit"; - version = "2.3.8.2"; - sha256 = "019sl85c4skksc3hl1mq9j4sw47pffgv53dl0nln3vaci09pfigd"; + version = "2.3.8.3"; + sha256 = "1x6pvpcjndxm26plk29v5nfz19rnci4fjzbamidpjaidi990jlba"; libraryHaskellDepends = [ - aeson attoparsec base bytestring conduit conduit-extra http-client - http-client-tls http-types mtl resourcet transformers unliftio-core + aeson attoparsec attoparsec-aeson base bytestring conduit + conduit-extra http-client http-client-tls http-types mtl resourcet + transformers unliftio-core ]; testHaskellDepends = [ - aeson base blaze-builder bytestring case-insensitive conduit - conduit-extra cookie crypton-connection data-default-class hspec - http-client http-types HUnit network resourcet streaming-commons - temporary text time tls transformers unliftio utf8-string wai - wai-conduit warp warp-tls + aeson attoparsec-aeson base blaze-builder bytestring + case-insensitive conduit conduit-extra cookie crypton-connection + data-default-class hspec http-client http-types HUnit network + resourcet streaming-commons temporary text time tls transformers + unliftio utf8-string wai wai-conduit warp warp-tls ]; doCheck = false; description = "HTTP client package with conduit interface and HTTPS support"; @@ -157177,6 +156224,8 @@ self: { pname = "http-io-streams"; version = "0.1.6.2"; sha256 = "0nil98dnw0y6g417mr9c9dan071ri3726dv0asgwwplq5mwy780q"; + revision = "1"; + editedCabalFile = "1ayqy22q2ld87qx3zjpfzrkhryjmjn7zc7adgw0jhahmg2lbd6q9"; libraryHaskellDepends = [ attoparsec base base64-bytestring binary blaze-builder brotli-streams bytestring case-insensitive containers @@ -157597,8 +156646,8 @@ self: { }: mkDerivation { pname = "http-streams"; - version = "0.8.9.6"; - sha256 = "1h8nnp1y4ngv6mwr3fxv428kcvrd3ming179sza8fkn49pcwdlxs"; + version = "0.8.9.8"; + sha256 = "1dfsynqhl7whrbz8hvjdxlnlnywwywjjm7gkii0jl67k7fxm4375"; libraryHaskellDepends = [ aeson attoparsec base base64-bytestring blaze-builder bytestring case-insensitive directory filepath HsOpenSSL http-common @@ -157688,40 +156737,6 @@ self: { }) {}; "http2" = callPackage - ({ mkDerivation, aeson, aeson-pretty, array, async, base - , base16-bytestring, bytestring, case-insensitive, containers - , cryptonite, directory, filepath, gauge, Glob, heaps, hspec - , hspec-discover, http-types, mwc-random, network - , network-byte-order, network-run, psqueues, stm, text - , time-manager, typed-process, unix-time, unordered-containers - , vector - }: - mkDerivation { - pname = "http2"; - version = "3.0.3"; - sha256 = "1kv99i3pnnx31xndlkaczrpd2j5mvzbqlfz1kaw6cwlwkdnl5bhv"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - array async base bytestring case-insensitive containers http-types - network network-byte-order psqueues stm time-manager unix-time - ]; - testHaskellDepends = [ - aeson aeson-pretty async base base16-bytestring bytestring - cryptonite directory filepath Glob hspec http-types network - network-byte-order network-run text typed-process - unordered-containers vector - ]; - testToolDepends = [ hspec-discover ]; - benchmarkHaskellDepends = [ - array base bytestring case-insensitive containers gauge heaps - mwc-random network-byte-order psqueues stm - ]; - description = "HTTP/2 library"; - license = lib.licenses.bsd3; - }) {}; - - "http2_4_1_4" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, async, base , base16-bytestring, bytestring, case-insensitive, containers , crypton, directory, filepath, gauge, Glob, hspec, hspec-discover @@ -157752,7 +156767,6 @@ self: { ]; description = "HTTP/2 library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "http2-client" = callPackage @@ -157773,6 +156787,8 @@ self: { testHaskellDepends = [ base ]; description = "A native HTTP2 client library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "http2-client-exe" = callPackage @@ -157869,6 +156885,22 @@ self: { broken = true; }) {}; + "http2-tls" = callPackage + ({ mkDerivation, base, bytestring, data-default-class, http2 + , network, network-run, recv, time-manager, tls, unliftio + }: + mkDerivation { + pname = "http2-tls"; + version = "0.0.0"; + sha256 = "0grd4i90wpdrd8k0dvm56hzfc2pncx0hjfy7678v9w8r524rbcqh"; + libraryHaskellDepends = [ + base bytestring data-default-class http2 network network-run recv + time-manager tls unliftio + ]; + description = "Library for HTTP/2 over TLS"; + license = lib.licenses.bsd3; + }) {}; + "http3" = callPackage ({ mkDerivation, array, attoparsec, base, base16-bytestring , bytestring, case-insensitive, conduit, conduit-extra, containers @@ -158618,8 +157650,10 @@ self: { }: mkDerivation { pname = "hurl-xml"; - version = "0.2.0.1"; - sha256 = "1xs1jww33mj1ysaw1x6mpjvad91y99f5mdvbk4vzyxipx1hw6sx5"; + version = "0.2.0.2"; + sha256 = "1gaahflp2i262gdzr911rbp3bhaijs8cggdr9yrzw55qj7q47dbq"; + revision = "1"; + editedCabalFile = "1ag73vf0v5qi2vlp2xm11xp3hqff06xqysx29jz1zpyh16s2h3bl"; libraryHaskellDepends = [ base bytestring containers css-syntax data-default-class directory file-embed filepath html-conduit hurl network-uri stylist-traits @@ -158778,8 +157812,8 @@ self: { }: mkDerivation { pname = "hvega"; - version = "0.12.0.3"; - sha256 = "1dmc8va82qzr9c7kn8w3nm70f3nb59gz3f6178j6iaph0acplyfh"; + version = "0.12.0.5"; + sha256 = "0zxd6kdzragrmjanipf19dgbbbjvb1zfpmd2lw00akj8h2ddyy5i"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ aeson base text unordered-containers ]; @@ -159056,7 +158090,9 @@ self: { ]; description = "Unbelievably fast streaming DSV file parser"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "hw-dsv"; + broken = true; }) {}; "hw-dump" = callPackage @@ -159926,6 +158962,8 @@ self: { ]; description = "Primitive functions and data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hw-string-parse" = callPackage @@ -160080,7 +159118,9 @@ self: { ]; description = "XML parser based on succinct data structures"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "hw-xml"; + broken = true; }) {}; "hwall-auth-iitk" = callPackage @@ -160733,6 +159773,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Type-aware transformations for data and programs"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "hydra-hs" = callPackage @@ -161208,8 +160250,8 @@ self: { pname = "hyperloglog"; version = "0.4.6"; sha256 = "0zwg4dhgasa9sx7pbjjjb9kz2bnhb3r2daij2b572cszv65l91nv"; - revision = "2"; - editedCabalFile = "0al93mhfhng8vwvhz8721gkzjjdblycpv4pi9lygbj8ay129djpr"; + revision = "3"; + editedCabalFile = "12gq3v5xpw8rn0hr7kqc4ji7byw675mnhjawlvmz6d2hr8hdrcmd"; libraryHaskellDepends = [ approximate base binary bits bytes bytestring cereal cereal-vector comonad cpu deepseq distributive hashable lens reflection @@ -161321,8 +160363,8 @@ self: { pname = "hyphenation"; version = "0.8.2"; sha256 = "05330kd99cg9v6w26sj87wk2nfvpmn2r177kr66vr9n0rlmia60y"; - revision = "1"; - editedCabalFile = "1ylp7a274rg3ymkj39v27ab387dp04cbagd5jxb4qfqqjrbkvyrs"; + revision = "2"; + editedCabalFile = "0l5b5a8cl9prqghgr8nfxzc3wx2w021mkp784k8af40ci0qgidsi"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base bytestring containers file-embed text unordered-containers @@ -162057,6 +161099,7 @@ self: { ]; description = "Squares style for the identicon package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "identifiers" = callPackage @@ -162213,6 +161256,7 @@ self: { ]; description = "Functional Programming Language with Dependent Types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) gmp;}; "ieee" = callPackage @@ -162338,6 +161382,8 @@ self: { pname = "iff"; version = "0.0.6.1"; sha256 = "1i0g90dgsnv8pis2xqicalxsdx4m24hz8n38c0srxwj69r402v3w"; + revision = "1"; + editedCabalFile = "1q0qrgldibgfv2fb6cbc5i1j60njjjnswzfb5q7hbs64r6cp6jbz"; libraryHaskellDepends = [ base binary bytestring ]; description = "Constructing and dissecting IFF files"; license = lib.licenses.gpl3Only; @@ -162493,8 +161539,8 @@ self: { }: mkDerivation { pname = "ihaskell"; - version = "0.10.3.0"; - sha256 = "0caghqp1k04mhfxqpz2hics92wdw8krnjycqsxsjp8s7impl36vl"; + version = "0.10.4.0"; + sha256 = "0vl6nmr72abf4jijxga9lnhj1w1iz5b4642r8xnqmavz4ds9qpsv"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -162624,6 +161670,8 @@ self: { libraryHaskellDepends = [ base bytestring ihaskell process ]; description = "IHaskell display instance for GraphViz (external binary)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ihaskell-hatex" = callPackage @@ -162641,8 +161689,8 @@ self: { ({ mkDerivation, aeson, base, hvega, ihaskell, text }: mkDerivation { pname = "ihaskell-hvega"; - version = "0.5.0.3"; - sha256 = "12bznrjb3qgy9di9p3faymaba8wsbx7v9gp5zxifnad6aqwlblf8"; + version = "0.5.0.4"; + sha256 = "13dz7f9gb8wli42srl91nq7fflnfc6vbi4d8bcly1387hkh2mji4"; libraryHaskellDepends = [ aeson base hvega ihaskell text ]; description = "IHaskell display instance for hvega types"; license = lib.licenses.bsd3; @@ -162663,6 +161711,7 @@ self: { ]; description = "Embed R quasiquotes and plots in IHaskell notebooks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ihaskell-juicypixels" = callPackage @@ -162777,6 +161826,8 @@ self: { ]; description = "JSX-like but for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ihs" = callPackage @@ -162830,6 +161881,8 @@ self: { ]; description = "Optimised list functions for doing index-related things"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "illuminate" = callPackage @@ -163736,8 +162789,8 @@ self: { }: mkDerivation { pname = "incipit"; - version = "0.7.0.0"; - sha256 = "00ymmb2d5hlskc2zc88kibgx1c5mxp4bdfymahzhqg1qhyw3q9ci"; + version = "0.8.0.0"; + sha256 = "15pfxy2xzff9598v076gd7fl0k235y2ydm8pirvqj485zj7mgyyg"; libraryHaskellDepends = [ base incipit-core polysemy-conc polysemy-log polysemy-resume polysemy-time @@ -164145,8 +163198,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "indexed-profunctors"; - version = "0.1.1"; - sha256 = "1cbccbvrx73drr1jf3yyw0rp1mcfv3jc1rvdcby5xxx4ja543fjs"; + version = "0.1.1.1"; + sha256 = "166329a5jmrs4q1ycb132gq7kbrdyzrvrxzzzwp5czmv00lvns9f"; libraryHaskellDepends = [ base ]; description = "Utilities for indexed profunctors"; license = lib.licenses.bsd3; @@ -164509,6 +163562,7 @@ self: { description = "Type inference and checker for JavaScript (experimental)"; license = lib.licenses.gpl2Only; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "infinite-list" = callPackage @@ -164588,6 +163642,8 @@ self: { ]; description = "Inflections library for Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "inflist" = callPackage @@ -164613,8 +163669,8 @@ self: { }: mkDerivation { pname = "influxdb"; - version = "1.9.2.2"; - sha256 = "08nqby0m69n8vqppprd3wk5z4r0aqs8kggkjzps106k809q0ycdg"; + version = "1.9.3"; + sha256 = "04rqmzwgbnf9n6c06gki0f2yfz993am9p8dcpnk7yrcv63ryh74y"; isLibrary = true; isExecutable = true; setupHaskellDepends = [ base Cabal cabal-doctest ]; @@ -164855,19 +163911,20 @@ self: { "inline-c-cpp" = callPackage ({ mkDerivation, base, bytestring, containers, hspec, inline-c - , safe-exceptions, template-haskell, text, vector + , safe-exceptions, system-cxx-std-lib, template-haskell, text + , vector }: mkDerivation { pname = "inline-c-cpp"; - version = "0.5.0.0"; - sha256 = "0m14nb9brpnh2cgq8gg6182mdcmn45hf734la68dnhq23sn63lpx"; + version = "0.5.0.1"; + sha256 = "16wf59kgs6zw8ypyb6wy842j04b2pdiwhfmpsvlvjkqhpqn2q406"; libraryHaskellDepends = [ base bytestring containers inline-c safe-exceptions - template-haskell text + system-cxx-std-lib template-haskell text ]; testHaskellDepends = [ base bytestring containers hspec inline-c safe-exceptions - template-haskell vector + system-cxx-std-lib template-haskell vector ]; description = "Lets you embed C++ code into Haskell"; license = lib.licenses.mit; @@ -164966,6 +164023,8 @@ self: { ]; description = "Seamlessly call R from Haskell and vice versa. No FFI required."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) R;}; "inliterate" = callPackage @@ -164986,26 +164045,11 @@ self: { testHaskellDepends = [ base text ]; description = "Interactive literate programming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "inlitpp"; }) {}; "input-parsers" = callPackage - ({ mkDerivation, attoparsec, base, binary, bytestring - , monoid-subclasses, parsec, parsers, text, transformers - }: - mkDerivation { - pname = "input-parsers"; - version = "0.2.3.2"; - sha256 = "0y643507p9grj8gkq722p4b9gbrkg8xyh6pi19qvrbmmadpn1r89"; - libraryHaskellDepends = [ - attoparsec base binary bytestring monoid-subclasses parsec parsers - text transformers - ]; - description = "Extension of the parsers library with more capability and efficiency"; - license = lib.licenses.bsd3; - }) {}; - - "input-parsers_0_3_0_1" = callPackage ({ mkDerivation, attoparsec, base, binary, bytestring , monoid-subclasses, parsec, parsers, text, transformers }: @@ -165019,7 +164063,6 @@ self: { ]; description = "Extension of the parsers library with more capability and efficiency"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "inquire" = callPackage @@ -165046,8 +164089,8 @@ self: { }: mkDerivation { pname = "insert-ordered-containers"; - version = "0.2.5.2"; - sha256 = "0ybcqbcaq3ixpfrpdb0xl89gzjj3f6xhsgwwh57nlcqdcvvzhpls"; + version = "0.2.5.3"; + sha256 = "0v23lawska0240vw8avxv71150y4qzbn4aj22lnkd3jxg5cnwkzh"; libraryHaskellDepends = [ aeson base deepseq hashable indexed-traversable lens optics-core optics-extra semigroupoids text transformers unordered-containers @@ -165097,8 +164140,8 @@ self: { }: mkDerivation { pname = "inspection-testing"; - version = "0.4.6.1"; - sha256 = "0mxff0v3ciccbk4b8kxnh4752fzbwn7213qd8xji0csv6gi2w83y"; + version = "0.5.0.2"; + sha256 = "1jk6xhiy8i9n7w3pz1p7yiyv1p76nwknv0f34r9f5kq36mn0k6kw"; libraryHaskellDepends = [ base containers ghc mtl template-haskell transformers ]; @@ -165107,23 +164150,6 @@ self: { license = lib.licenses.mit; }) {}; - "inspection-testing_0_5_0_1" = callPackage - ({ mkDerivation, base, containers, ghc, mtl, template-haskell - , transformers - }: - mkDerivation { - pname = "inspection-testing"; - version = "0.5.0.1"; - sha256 = "0zq7ickp6633y262nafi507zp0pmw8v6854sr1cncd3qqmrhnx99"; - libraryHaskellDepends = [ - base containers ghc mtl template-haskell transformers - ]; - testHaskellDepends = [ base ]; - description = "GHC plugin to do inspection testing"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "inspector-wrecker" = callPackage ({ mkDerivation, aeson, base, bytestring, case-insensitive , connection, data-default, http-client, http-client-tls @@ -165413,8 +164439,8 @@ self: { pname = "int-cast"; version = "0.2.0.0"; sha256 = "0s8rqm5d9f4y2sskajsw8ff7q8xp52vwqa18m6bajldp11m9a1p0"; - revision = "4"; - editedCabalFile = "1l5n3hsa8gr0wzc3cb32ha2j8kcf976i84z04580q41macf0r0h6"; + revision = "6"; + editedCabalFile = "11yvshlvp4ma279h9d4s1sdhlng4abar85crwkjsbjlvhfhlc3xw"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base QuickCheck test-framework test-framework-quickcheck2 @@ -165462,6 +164488,8 @@ self: { ]; description = "Newtype wrappers over IntSet and IntMap"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "int-multimap" = callPackage @@ -165499,6 +164527,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-conversion" = callPackage @@ -165517,8 +164547,6 @@ self: { benchmarkHaskellDepends = [ base bytestring tasty-bench text ]; description = "Conversion from strings to Integer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "integer-gmp_1_1" = callPackage @@ -165603,8 +164631,8 @@ self: { }: mkDerivation { pname = "integer-types"; - version = "0.1.1.0"; - sha256 = "0m22rmag4kdf3rad8i916dk1j2qwcnrviz9wwqhxz3rnf2r3jqm2"; + version = "0.1.4.0"; + sha256 = "0c1js39965d7g3naqlhfdxjs7w4zygnibf4raha60lq3dgnc7nc0"; libraryHaskellDepends = [ base deepseq hashable quaalude ]; testHaskellDepends = [ base deepseq exceptions hashable hedgehog hspec hspec-hedgehog @@ -165838,8 +164866,8 @@ self: { pname = "intern"; version = "0.9.4"; sha256 = "00c74apc2ap1pjxmzk1c975zzqrc94p69l7v1fvfakv87mbrg8j0"; - revision = "2"; - editedCabalFile = "1jd429wyh11py7yd95zgaqf3djwvmqznslanlp7jcbrv8ag3dyg8"; + revision = "3"; + editedCabalFile = "03a2z3vs7rk666qhpc5avrpga8pgz8giml743zw6i7470ikznrkg"; libraryHaskellDepends = [ array base bytestring hashable text unordered-containers ]; @@ -166193,8 +165221,8 @@ self: { }: mkDerivation { pname = "interval-patterns"; - version = "0.7.0.2"; - sha256 = "0sa2v7z3ryx45by6zcgfi56n53f3akf4xifj9sp69rhc4mlqj735"; + version = "0.7.0.3"; + sha256 = "16521q6jb0lxncsy3wav6p5jfp8jv1sw0simlyfjx0nl6gjpbz40"; libraryHaskellDepends = [ base containers groups heaps lattices semirings time time-compat ]; @@ -166253,8 +165281,8 @@ self: { }: mkDerivation { pname = "intricacy"; - version = "0.8.1.1"; - sha256 = "0dvwzbwsrkngdxmgrl2lv9vd30l7afz676ypwnjm8d1z1f03i6pj"; + version = "0.8.2"; + sha256 = "0k419xvh98ydpfmb0h1lr6k31gwh15370fbsfllcnzdvk3gqvbx8"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -166457,10 +165485,8 @@ self: { }: mkDerivation { pname = "invert"; - version = "1.0.0.2"; - sha256 = "13zl9i6g7ygkm3pgm7b72815cfp66mykxzp5vwy5kqakr8c3w1fp"; - revision = "3"; - editedCabalFile = "1jrpqnd03j5h1g879n63ygj561db7kvk43xjvhhv4f4h1rmpzpri"; + version = "1.0.0.4"; + sha256 = "1iinm4wc2g5dqkvgga94srkczklr7fw8hk9vanhdx38x71531gzl"; libraryHaskellDepends = [ base containers generic-deriving hashable unordered-containers vector @@ -166477,31 +165503,6 @@ self: { license = lib.licenses.asl20; }) {}; - "invert_1_0_0_3" = callPackage - ({ mkDerivation, base, containers, criterion, generic-deriving - , hashable, unordered-containers, vector - }: - mkDerivation { - pname = "invert"; - version = "1.0.0.3"; - sha256 = "08bkn9pv02bklmrn5cf17qkw949ryvs51dc8pzxkixgbjk9fpny4"; - libraryHaskellDepends = [ - base containers generic-deriving hashable unordered-containers - vector - ]; - testHaskellDepends = [ - base containers generic-deriving hashable unordered-containers - vector - ]; - benchmarkHaskellDepends = [ - base containers criterion generic-deriving hashable - unordered-containers vector - ]; - description = "Automatically generate a function’s inverse"; - license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - }) {}; - "invertible" = callPackage ({ mkDerivation, base, haskell-src-meta, invariant, lens , partial-isomorphisms, QuickCheck, semigroupoids, template-haskell @@ -166509,10 +165510,8 @@ self: { }: mkDerivation { pname = "invertible"; - version = "0.2.0.7"; - sha256 = "1ngcmy59cyrg5idcn8a4gxg6ipq88rhhwhdb09gra8jcraq9n7ii"; - revision = "1"; - editedCabalFile = "19xcczz26ji5xaws4ikvacqz991qgislj32hs8rlks07qw3qmnbn"; + version = "0.2.0.8"; + sha256 = "1j67nxx91w0la58gxhxgz3bqsnvab5myyrb0k13zw2xwk9cb8912"; libraryHaskellDepends = [ base haskell-src-meta invariant lens partial-isomorphisms semigroupoids template-haskell transformers @@ -166772,8 +165771,8 @@ self: { pname = "io-streams"; version = "1.5.2.2"; sha256 = "1zn4iyd18g9jc1qdgixp6hi56nj7czy4jdz2xca59hcn2q2xarfk"; - revision = "1"; - editedCabalFile = "1fkjzk7s99sb7h1lvandw9p8r05ly4206y3aiah0jg39zjvbi5az"; + revision = "2"; + editedCabalFile = "12q3nhd4wqyv1m7wvzvs5a8yyarcjdrvdhmb4c5hx3zrs5l7sflw"; configureFlags = [ "-fnointeractivetests" ]; libraryHaskellDepends = [ attoparsec base bytestring network primitive process text time @@ -166797,8 +165796,8 @@ self: { pname = "io-streams-haproxy"; version = "1.0.1.0"; sha256 = "1dcn5hd4fiwyq7m01r6fi93vfvygca5s6mz87c78m0zyj29clkmp"; - revision = "7"; - editedCabalFile = "0wib2mz6ifnixrcp9s1pkd00v9q7dvyka1z7zqc3pgif47hr1dbw"; + revision = "8"; + editedCabalFile = "03gzlz7hg2jvnx2355r65201680lcm59ln7azzb118abirl460s6"; libraryHaskellDepends = [ attoparsec base bytestring io-streams network transformers ]; @@ -167414,7 +166413,9 @@ self: { testHaskellDepends = [ base hashable HUnit text ]; description = "IRC core library for glirc"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.kiwi ]; + broken = true; }) {}; "irc-ctcp" = callPackage @@ -168725,6 +167726,7 @@ self: { ]; description = "Efficient relational queries on Haskell sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "ixset-typed" = callPackage @@ -168744,6 +167746,8 @@ self: { ]; description = "Efficient relational queries on Haskell sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ixset-typed-binary-instance" = callPackage @@ -168755,6 +167759,7 @@ self: { libraryHaskellDepends = [ base binary ixset-typed ]; description = "Binary instance for ixset-typed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ixset-typed-cassava" = callPackage @@ -168770,6 +167775,7 @@ self: { ]; description = "cassava encoding and decoding via ixset-typed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ixset-typed-conversions" = callPackage @@ -168786,6 +167792,7 @@ self: { ]; description = "Conversions from ixset-typed to other containers"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ixset-typed-hashable-instance" = callPackage @@ -168797,6 +167804,7 @@ self: { libraryHaskellDepends = [ base hashable ixset-typed ]; description = "Hashable instance for ixset-typed"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "ixshader" = callPackage @@ -168934,8 +167942,8 @@ self: { pname = "jack"; version = "0.7.2.2"; sha256 = "0f47cyhsjw57k4cgbmwvawn02v9dvx4x1pn7k2z612srf5l1igb5"; - revision = "1"; - editedCabalFile = "08y9jiyqxxpv6kjivlk2qaiidj3hayyfi7baqzsfn28bskxr7d9b"; + revision = "2"; + editedCabalFile = "1hjk165kmdryyr5j50dgk59sa6kqvhhp6g5i31b2kzif9glbmq3s"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -168992,6 +168000,7 @@ self: { ]; description = "Jack, zonal, and Schur polynomials"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "jacobi-elliptic" = callPackage @@ -169226,6 +168235,23 @@ self: { broken = true; }) {}; + "jaskell" = callPackage + ({ mkDerivation, base, directory, hspec, hspec-discover, megaparsec + , template-haskell + }: + mkDerivation { + pname = "jaskell"; + version = "0.1.0.0"; + sha256 = "1hfm9ai1hpk6ahvsnmkg6x5ffsb10w944nbi032n53nxmqbzqmwi"; + libraryHaskellDepends = [ base megaparsec template-haskell ]; + testHaskellDepends = [ base directory hspec megaparsec ]; + testToolDepends = [ hspec-discover ]; + description = "Stack-based concatenative language embedded in Haskell"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "jason" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, text , unordered-containers, vector @@ -169678,24 +168704,6 @@ self: { }) {}; "jira-wiki-markup" = callPackage - ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }: - mkDerivation { - pname = "jira-wiki-markup"; - version = "1.4.0"; - sha256 = "0p6axj6km4440ss5naw68r3r85si4qxqgrklp6ssfyapawy0s88w"; - revision = "1"; - editedCabalFile = "043x87s8lyg0ck2krwdn1ncr0sxc7p03jmgykwyvg8c7i56n3m7n"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base mtl parsec text ]; - executableHaskellDepends = [ base text ]; - testHaskellDepends = [ base parsec tasty tasty-hunit text ]; - description = "Handle Jira wiki markup"; - license = lib.licenses.mit; - mainProgram = "jira-wiki-markup"; - }) {}; - - "jira-wiki-markup_1_5_1" = callPackage ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }: mkDerivation { pname = "jira-wiki-markup"; @@ -169708,7 +168716,6 @@ self: { testHaskellDepends = [ base parsec tasty tasty-hunit text ]; description = "Handle Jira wiki markup"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "jira-wiki-markup"; }) {}; @@ -169920,6 +168927,7 @@ self: { ]; description = "A library for creating a jobs management website running custom jobs"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "join" = callPackage @@ -170034,6 +169042,8 @@ self: { ]; description = "JSON with Structure"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "jordan-openapi" = callPackage @@ -170078,6 +169088,7 @@ self: { ]; description = "Servant Combinators for Jordan"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jordan-servant-client" = callPackage @@ -170101,6 +169112,7 @@ self: { ]; description = "Servant Client Instances for Jordan Servant Types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jordan-servant-openapi" = callPackage @@ -170147,6 +169159,7 @@ self: { ]; description = "Servers for Jordan-Based Servant Combinators"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "jort" = callPackage @@ -170166,33 +169179,6 @@ self: { }) {}; "jose" = callPackage - ({ mkDerivation, aeson, base, base64-bytestring, bytestring - , concise, containers, cryptonite, hspec, lens, memory, monad-time - , mtl, network-uri, pem, QuickCheck, quickcheck-instances, tasty - , tasty-hspec, tasty-quickcheck, template-haskell, text, time, x509 - }: - mkDerivation { - pname = "jose"; - version = "0.9"; - sha256 = "0kii03gr6n8ayp1q3hid5qslzwgxm6isjnw8klvg7j82kliikycj"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base base64-bytestring bytestring concise containers - cryptonite lens memory monad-time mtl network-uri QuickCheck - quickcheck-instances template-haskell text time x509 - ]; - testHaskellDepends = [ - aeson base base64-bytestring bytestring concise containers - cryptonite hspec lens mtl network-uri pem QuickCheck - quickcheck-instances tasty tasty-hspec tasty-quickcheck text time - x509 - ]; - description = "JSON Object Signing and Encryption (JOSE) and JSON Web Token (JWT) library"; - license = lib.licenses.asl20; - }) {}; - - "jose_0_10" = callPackage ({ mkDerivation, aeson, base, base64-bytestring, bytestring , concise, containers, cryptonite, hedgehog, hspec, lens, memory , monad-time, mtl, network-uri, pem, tasty, tasty-hedgehog @@ -170216,7 +169202,6 @@ self: { ]; description = "JSON Object Signing and Encryption (JOSE) and JSON Web Token (JWT) library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "jose-jwt" = callPackage @@ -170227,8 +169212,8 @@ self: { }: mkDerivation { pname = "jose-jwt"; - version = "0.9.5"; - sha256 = "0iw686xqx500n2f500qwqc6j7i503r7s10sxlmfwj0wjz9mhmp57"; + version = "0.9.6"; + sha256 = "03qwn17yahcki4dlsg2zz4gxp2mlp80yxmwrwlfrb10jgncpsqvc"; libraryHaskellDepends = [ aeson attoparsec base bytestring cereal containers cryptonite memory mtl text time transformers transformers-compat @@ -170607,6 +169592,22 @@ self: { license = lib.licenses.bsd3; }) {}; + "json_0_11" = callPackage + ({ mkDerivation, array, base, bytestring, containers, mtl, parsec + , pretty, syb, text + }: + mkDerivation { + pname = "json"; + version = "0.11"; + sha256 = "1476fxrfybch9j2mr6yacbvhnggj5ksir1a42114j8s8w89anyfh"; + libraryHaskellDepends = [ + array base bytestring containers mtl parsec pretty syb text + ]; + description = "Support for serialising Haskell to and from JSON"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "json-alt" = callPackage ({ mkDerivation, aeson, base }: mkDerivation { @@ -170914,8 +169915,8 @@ self: { }: mkDerivation { pname = "json-feed"; - version = "2.0.0.8"; - sha256 = "1iq2m3fhi7c2z9na4yqy94m047caqi60rx6d3g6bgf6mvpn5aqk3"; + version = "2.0.0.9"; + sha256 = "0nj66jkql0irq5vyxhmdxxjpazr3g86x7j8klqjwxvdj5jmvy53d"; libraryHaskellDepends = [ aeson base bytestring mime-types network-uri tagsoup text time ]; @@ -171109,8 +170110,8 @@ self: { pname = "json-query"; version = "0.2.1.0"; sha256 = "1cla0jwqdbiifl7h8xr61nh0p2d9df77ds8npllik1n4b4wi5v5p"; - revision = "1"; - editedCabalFile = "1idazzqzz276yxisfbn5hbmx1qgl896jp3wxp68hpz74bxwbgxlm"; + revision = "3"; + editedCabalFile = "14w6nrjg764l422zc6vbxrbqy0b8s5yynr2bf0lv674qipq7026k"; libraryHaskellDepends = [ array-chunks base bytebuild bytestring contiguous json-syntax primitive primitive-unlifted profunctors scientific-notation @@ -171281,6 +170282,46 @@ self: { license = lib.licenses.bsd3; }) {}; + "json-spec" = callPackage + ({ mkDerivation, aeson, base, bytestring, hspec, lens, openapi3 + , scientific, text, time, vector + }: + mkDerivation { + pname = "json-spec"; + version = "0.1.0.0"; + sha256 = "0cm2k50vi2ys9p24ziwfw0f4sky9gq07ibf3s5hw22cz4gpf47ys"; + libraryHaskellDepends = [ + aeson base bytestring lens openapi3 scientific text time vector + ]; + testHaskellDepends = [ + aeson base bytestring hspec lens openapi3 scientific text time + vector + ]; + description = "Type-level JSON specification"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + + "json-spec-openapi" = callPackage + ({ mkDerivation, aeson, base, bytestring, hspec, json-spec, lens + , openapi3, scientific, text, time + }: + mkDerivation { + pname = "json-spec-openapi"; + version = "0.1.0.1"; + sha256 = "0p65dwqp5dlrb6wcds0yjmmcn7xc57acrw4al3lzn2mqad3aq7ij"; + libraryHaskellDepends = [ + aeson base json-spec lens openapi3 text + ]; + testHaskellDepends = [ + aeson base bytestring hspec json-spec lens openapi3 scientific text + time + ]; + description = "json-spec-openapi"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "json-state" = callPackage ({ mkDerivation, aeson, aeson-pretty, base, bytestring, libgit , time-units @@ -171303,8 +170344,8 @@ self: { }: mkDerivation { pname = "json-stream"; - version = "0.4.5.2"; - sha256 = "1hhnv59zwphvnfi6wym4bmqkcnk3b2adni4hxxgslmmf8yqi98ih"; + version = "0.4.5.3"; + sha256 = "0jysj25x98kw5326a0n08bygm70yc4l1y9ajyf1bca8003m5smvx"; libraryHaskellDepends = [ aeson base bytestring containers primitive scientific text unordered-containers vector @@ -171328,8 +170369,8 @@ self: { }: mkDerivation { pname = "json-syntax"; - version = "0.2.3.0"; - sha256 = "0alljkky2a4lqgl2dfdccp9nkxdyijl718mlvlnfac0wl1lxz890"; + version = "0.2.4.0"; + sha256 = "0mhlz6w7zzp97l675jxcwlwhz1r10d4m5mqmdmq12qyamsj8l7hg"; libraryHaskellDepends = [ array-builder array-chunks base bytebuild byteslice bytesmith bytestring contiguous natural-arithmetic primitive run-st @@ -171766,24 +170807,26 @@ self: { }) {}; "jsonrpc-conduit" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit - , conduit-extra, hspec, hspec-discover, mtl, text, transformers - , unordered-containers + ({ mkDerivation, aeson, attoparsec, attoparsec-aeson, base + , bytestring, conduit, conduit-extra, hspec, hspec-discover, mtl + , text, transformers, unordered-containers }: mkDerivation { pname = "jsonrpc-conduit"; - version = "0.3.12"; - sha256 = "0yv7x9c1qgc332vzk61zlr4v0zckjgx3nbd17klxf3w8hljb25vs"; + version = "0.4.0"; + sha256 = "1qd8ngscgbakcnms1kf02m950255gavka1n2wvg0xjm7i60fkkwg"; libraryHaskellDepends = [ - aeson attoparsec base bytestring conduit conduit-extra mtl text - transformers unordered-containers + aeson attoparsec attoparsec-aeson base bytestring conduit + conduit-extra mtl text transformers unordered-containers ]; testHaskellDepends = [ - aeson base bytestring conduit conduit-extra hspec text + aeson attoparsec attoparsec-aeson base bytestring conduit + conduit-extra hspec text ]; testToolDepends = [ hspec-discover ]; description = "JSON-RPC 2.0 server over a Conduit."; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "jsonrpc-tinyclient" = callPackage @@ -172099,7 +171142,9 @@ self: { executableHaskellDepends = [ base ]; description = "A first-order reasoning toolbox"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "jukebox"; + broken = true; }) {}; "jump" = callPackage @@ -172651,6 +171696,8 @@ self: { benchmarkHaskellDepends = [ aeson base containers criterion text ]; description = "Perform 漢字検定 (Japan Kanji Aptitude Test) level analysis on Japanese Kanji"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "kansas-comet" = callPackage @@ -172661,8 +171708,8 @@ self: { pname = "kansas-comet"; version = "0.4.1"; sha256 = "1j54rsqna8xrw1si8i74v0c9k4jjv8a2q001aa8sx4rxb7d1qbzy"; - revision = "5"; - editedCabalFile = "0mw1667kpzg84q5iwdk90nq1n87i46zp9w0wgk9y0znwhbqw7hsw"; + revision = "6"; + editedCabalFile = "1zmxwppdm0mpc0sh8h35vrp259wig4k11gx1zx6s1089mncrp12f"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson base containers data-default-class scotty stm text time @@ -173066,8 +172113,8 @@ self: { }: mkDerivation { pname = "katip-wai"; - version = "0.1.2.1"; - sha256 = "1shzmjpz043fglvn4niydbjf3a41bmx2dhyp7ch5g256irqs4a21"; + version = "0.1.2.2"; + sha256 = "09mwjxnpm2a1s1m99qfyd1v5snf0jar470vg5rsvfr840d27bayh"; libraryHaskellDepends = [ aeson base bytestring clock http-types katip network text uuid wai ]; @@ -174207,8 +173254,8 @@ self: { }: mkDerivation { pname = "keyed-vals"; - version = "0.2.0.0"; - sha256 = "0im4wn7m5y6kmi8cjxfn72316zldg9v92fbw6hlimc7hkndb34mf"; + version = "0.2.2.0"; + sha256 = "1f6sigfx2cywx2kf4z3xyjzi5b8zzisb6ic3z6py6ybzwnpxglr5"; libraryHaskellDepends = [ aeson base bytestring containers http-api-data redis-glob text ]; @@ -174224,8 +173271,8 @@ self: { }: mkDerivation { pname = "keyed-vals-hspec-tests"; - version = "0.2.0.0"; - sha256 = "1pmhd9gjq92gn5z36l6av3hbxq5ynwhzy3igij7wvndx3mkj94hm"; + version = "0.2.2.0"; + sha256 = "15izwj5yby3sfw6b830g44yxkz64gjhrxqrav3gip6a50m8alfq5"; libraryHaskellDepends = [ aeson base benri-hspec bytestring containers hspec http-api-data keyed-vals text @@ -174241,8 +173288,8 @@ self: { }: mkDerivation { pname = "keyed-vals-mem"; - version = "0.2.0.0"; - sha256 = "08zsrwdcqw7ic1l9ygcalyg0k985ck1gal03kw21jlsh3l77942d"; + version = "0.2.2.0"; + sha256 = "09ha9sgx12sr1v072c9wlh368b7mqy8cf0glradz3z85ambgw483"; libraryHaskellDepends = [ base bytestring containers keyed-vals text unliftio unliftio-core ]; @@ -174259,8 +173306,8 @@ self: { }: mkDerivation { pname = "keyed-vals-redis"; - version = "0.2.0.0"; - sha256 = "1fxb1r6c19sslhmml04w7adpqwq1glavm5mfix7iiaxly358jdy6"; + version = "0.2.2.0"; + sha256 = "1wkf3jaxljb71l9a8cmk4qd048g8if9mq2iw97ch0q5c7k8lqahj"; libraryHaskellDepends = [ base bytestring containers hedis keyed-vals read-env-var text unliftio unliftio-core @@ -174587,17 +173634,6 @@ self: { }) {}; "kind-apply" = callPackage - ({ mkDerivation, base }: - mkDerivation { - pname = "kind-apply"; - version = "0.3.2.1"; - sha256 = "0si02ps0aivra87sc57fss088vimvs9j32r7xhbaqv8vh0wi0ng9"; - libraryHaskellDepends = [ base ]; - description = "Utilities to work with lists of types"; - license = lib.licenses.bsd3; - }) {}; - - "kind-apply_0_4_0_0" = callPackage ({ mkDerivation, base, first-class-families }: mkDerivation { pname = "kind-apply"; @@ -174606,21 +173642,9 @@ self: { libraryHaskellDepends = [ base first-class-families ]; description = "Utilities to work with lists of types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "kind-generics" = callPackage - ({ mkDerivation, base, kind-apply }: - mkDerivation { - pname = "kind-generics"; - version = "0.4.1.4"; - sha256 = "11l1n57wfh1gr9mn0gb9kbkjbrfghmf3qasl0l6fjlbjcl8yvzbm"; - libraryHaskellDepends = [ base kind-apply ]; - description = "Generic programming in GHC style for arbitrary kinds and GADTs"; - license = lib.licenses.bsd3; - }) {}; - - "kind-generics_0_5_0_0" = callPackage ({ mkDerivation, base, first-class-families, kind-apply }: mkDerivation { pname = "kind-generics"; @@ -174629,7 +173653,6 @@ self: { libraryHaskellDepends = [ base first-class-families kind-apply ]; description = "Generic programming in GHC style for arbitrary kinds and GADTs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "kind-generics-deriving" = callPackage @@ -174650,31 +173673,13 @@ self: { }) {}; "kind-generics-th" = callPackage - ({ mkDerivation, base, ghc-prim, kind-generics, template-haskell - , th-abstraction - }: - mkDerivation { - pname = "kind-generics-th"; - version = "0.2.2.3"; - sha256 = "06zhjaaakml1p3crjx26nmydbnrscxvwgyqy3w4083caysxw1vsj"; - revision = "1"; - editedCabalFile = "1drkj6b618yzgacbm5b100znm63r7ivzlxhpzhymkc8dqcacr7mq"; - libraryHaskellDepends = [ - base ghc-prim kind-generics template-haskell th-abstraction - ]; - testHaskellDepends = [ base kind-generics template-haskell ]; - description = "Template Haskell support for generating `GenericK` instances"; - license = lib.licenses.bsd3; - }) {}; - - "kind-generics-th_0_2_3_1" = callPackage ({ mkDerivation, base, fcf-family, ghc-prim, kind-generics , template-haskell, th-abstraction }: mkDerivation { pname = "kind-generics-th"; - version = "0.2.3.1"; - sha256 = "1xcpv659176jhsxzqs9642pn192hkbl3qcccabh1ynx3nysivk7m"; + version = "0.2.3.2"; + sha256 = "1k7byznlp3xnxmgw8dh5bgdjf3ygxki76xbq7m6w33bcd0gp98l4"; libraryHaskellDepends = [ base fcf-family ghc-prim kind-generics template-haskell th-abstraction @@ -174682,7 +173687,6 @@ self: { testHaskellDepends = [ base kind-generics template-haskell ]; description = "Template Haskell support for generating `GenericK` instances"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "kind-integer" = callPackage @@ -175063,19 +174067,19 @@ self: { "koji-tool" = callPackage ({ mkDerivation, base, directory, extra, filepath, formatting, Glob , http-conduit, http-directory, koji, pretty-simple, rpm-nvr - , simple-cmd, simple-cmd-args, text, time, utf8-string - , xdg-userdirs + , simple-cmd, simple-cmd-args, simple-prompt, text, time + , utf8-string, xdg-userdirs }: mkDerivation { pname = "koji-tool"; - version = "1.0.1"; - sha256 = "0vj0gz8q0mnagp0p25d4bl5s8m966l7gi5wl4qgfazbavy09x7sv"; + version = "1.1"; + sha256 = "0xm6qxfxfl9qf8mmsns783mvwhx3p81h2iwak6kww8j5lsdv2n6w"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ base directory extra filepath formatting Glob http-conduit http-directory koji pretty-simple rpm-nvr simple-cmd - simple-cmd-args text time utf8-string xdg-userdirs + simple-cmd-args simple-prompt text time utf8-string xdg-userdirs ]; testHaskellDepends = [ base simple-cmd ]; description = "Koji CLI tool for querying tasks and installing builds"; @@ -175518,7 +174522,9 @@ self: { testHaskellDepends = [ base ]; description = "coverage driven random testing framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "kudzu"; + broken = true; }) {}; "kuifje" = callPackage @@ -175610,6 +174616,7 @@ self: { ]; description = "Key/Value Indexed Table container and formatting library"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "kyotocabinet" = callPackage @@ -175647,6 +174654,8 @@ self: { libraryHaskellDepends = [ base text time ]; description = "Enables providing localization as typeclass instances in separate files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "labeled-graph" = callPackage @@ -175801,6 +174810,7 @@ self: { testHaskellDepends = [ base hspec servant servant-foreign text ]; description = "Generate Ruby clients from Servant APIs"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "lacroix" = callPackage @@ -176132,10 +175142,8 @@ self: { }: mkDerivation { pname = "lambdabot"; - version = "5.3.1"; - sha256 = "0fznnbjrk5m6g0jd65ngmckqcgnn87hs30mxqfkncqbqp86s3zyd"; - revision = "2"; - editedCabalFile = "0q7sb9man3zxgaajm8vy59ld0xsb5vzjai8vb8rnljxdkgsy4i5j"; + version = "5.3.1.1"; + sha256 = "0icybndmsivnrw6wibh31g4n8bj1cclbf5cvwf816xblfmgcdhvf"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -176161,10 +175169,8 @@ self: { }: mkDerivation { pname = "lambdabot-core"; - version = "5.3.1"; - sha256 = "1hiq1wh60cprx49y1178rwsw8dcflzx10g2ivi77d4qxyiawljph"; - revision = "2"; - editedCabalFile = "0cp2aldnqxd74l4ggxm523shfyvh864zvp6v0d0zyry5jrx7zyfr"; + version = "5.3.1.1"; + sha256 = "1paya40niapvkyc8qc3k36l7qsskfdxih8d789lhd9s8rr0f9hdi"; libraryHaskellDepends = [ base binary bytestring containers dependent-map dependent-sum dependent-sum-template directory edit-distance exceptions filepath @@ -176188,10 +175194,8 @@ self: { }: mkDerivation { pname = "lambdabot-haskell-plugins"; - version = "5.3.1"; - sha256 = "05xja5xamvl61xc09fyijmv0sylfd3aaii3p410xa34msglsyssd"; - revision = "2"; - editedCabalFile = "15filg6s0xhizffmhx7ca220930d2xjqvmfaafcrl7vpn3dcrgbl"; + version = "5.3.1.1"; + sha256 = "1fivdnj0nb4332j9m5filkpfy9wjkmsjc3kxh2w17c7irhj26f71"; libraryHaskellDepends = [ array arrows base bytestring containers data-memocombinators directory filepath haskell-src-exts-simple hoogle HTTP IOSpec @@ -176211,10 +175215,8 @@ self: { }: mkDerivation { pname = "lambdabot-irc-plugins"; - version = "5.3.1"; - sha256 = "0fcbp39vm05g6sjjmxmdxflia5n0yckai0chqqkk1g01khb4pkjy"; - revision = "2"; - editedCabalFile = "17kg3vac8jiciwygzxdws3bskiwlxfm41hbqn8wm0hcz0l9h4ss0"; + version = "5.3.1.1"; + sha256 = "1nvkkqv28dyvq7hdwz1p1yjii55vc8m6i7ccjzs9ag720cha2n4m"; libraryHaskellDepends = [ base bytestring containers directory filepath lambdabot-core lifted-base mtl network SafeSemaphore split time @@ -176232,10 +175234,8 @@ self: { }: mkDerivation { pname = "lambdabot-misc-plugins"; - version = "5.3.1"; - sha256 = "01dq0lxr7cbnh6bzlk5cndqif44q1sw2azqimz43gaplpqbnavl6"; - revision = "2"; - editedCabalFile = "188l0yj672dbdssfafnlz4jybyd1d1i7yb3j66v483b5m09m0f2x"; + version = "5.3.1.1"; + sha256 = "16f9bf5c7al904iffykwp98l00j8m1f2r6qlivj03jwb6s5plm6w"; libraryHaskellDepends = [ base bytestring containers filepath lambdabot-core lifted-base mtl network network-uri parsec process regex-tdfa SafeSemaphore split @@ -176253,10 +175253,8 @@ self: { }: mkDerivation { pname = "lambdabot-novelty-plugins"; - version = "5.3.1"; - sha256 = "0v851nxpxr90agfyh9nx44f1r310fs93y2gji4a7x1synb786rnw"; - revision = "2"; - editedCabalFile = "1m500jq122wml8cp398szd7m9bya4fw5yg2fcv349fdz32wr18hd"; + version = "5.3.1.1"; + sha256 = "1x4whzn3d4gni1xjwrjr95jqi50gwgf02x64gg9nwvkc5lh4admx"; libraryHaskellDepends = [ base binary brainfuck bytestring containers dice directory lambdabot-core misfortune process random random-fu regex-tdfa @@ -176273,10 +175271,8 @@ self: { }: mkDerivation { pname = "lambdabot-reference-plugins"; - version = "5.3.1"; - sha256 = "16zp4mpp77778i8vkcr58nr3xg2rnfdlm5ap0sdrqqfx51bs8ybq"; - revision = "2"; - editedCabalFile = "1c65bw5q7gap9n1rlxv0y988fd7srzkdzz0m2x6b70kfkj19ha7m"; + version = "5.3.1.1"; + sha256 = "1s8s4k394p59lg3xrcn0bwq9wcqzdvzx6qanmsrch0nzwg6l4g7h"; libraryHaskellDepends = [ base bytestring containers HTTP lambdabot-core mtl network network-uri oeis process regex-tdfa split tagsoup utf8-string @@ -176291,10 +175287,8 @@ self: { }: mkDerivation { pname = "lambdabot-social-plugins"; - version = "5.3.1"; - sha256 = "0d8hc34hky8br53yj15qchbkm796d7x9zhhm8bq9h4rn1a2zfmdz"; - revision = "2"; - editedCabalFile = "1gk4qmjzizxk4qzc3kvq36p515my2cf6vybhnb2zaxpnckg9v68k"; + version = "5.3.1.1"; + sha256 = "04gls4klsa7kz22k6aar636hci3iafxa5mwx8kxvgawahvlcy0p2"; libraryHaskellDepends = [ base binary bytestring containers lambdabot-core mtl split time ]; @@ -176326,6 +175320,7 @@ self: { ]; description = "Lambdabot for Telegram"; license = lib.licenses.gpl2Plus; + hydraPlatforms = lib.platforms.none; mainProgram = "telegram-lambdabot"; }) {}; @@ -176333,8 +175328,8 @@ self: { ({ mkDerivation, base, oeis, QuickCheck, QuickCheck-safe }: mkDerivation { pname = "lambdabot-trusted"; - version = "5.3.1"; - sha256 = "03wmk7l7krb51zql2qxf805ww0gndbgysfw0fgm3pzd98j7bfimh"; + version = "5.3.1.1"; + sha256 = "0kzkp7cy7wcig2wi2l12j8pflapsmdj45y8qq1l5j86gcvsk7xf3"; libraryHaskellDepends = [ base oeis QuickCheck QuickCheck-safe ]; description = "Lambdabot trusted code"; license = "GPL"; @@ -176739,33 +175734,6 @@ self: { }) {}; "lame" = callPackage - ({ mkDerivation, base, bytestring, directory, exceptions, filepath - , hspec, hspec-discover, htaglib, mp3lame, temporary, text - , transformers, wave - }: - mkDerivation { - pname = "lame"; - version = "0.2.0"; - sha256 = "1bqq3aanfffdsl3v0am7jdfslcr6y372cq7jx36z7g09zy5mp2sp"; - revision = "2"; - editedCabalFile = "15yjwhwxiqds425y7a4s1z9vdrgmqwq2y5kvl1d1xhw7h05ryxkr"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - base bytestring directory exceptions filepath text transformers - wave - ]; - librarySystemDepends = [ mp3lame ]; - testHaskellDepends = [ - base directory filepath hspec htaglib temporary text - ]; - 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_0_2_1" = callPackage ({ mkDerivation, base, bytestring, directory, exceptions, filepath , hspec, hspec-discover, htaglib, mp3lame, temporary, text , transformers, wave @@ -176774,6 +175742,8 @@ self: { pname = "lame"; version = "0.2.1"; sha256 = "1xz98v2kqs69jijza0vyz57lpbs3h2f7fcablihlzprh1sylc3vq"; + revision = "1"; + editedCabalFile = "15jf93rcjwzgl0780c86nn29dif6avwpj3x4xpkq5lmll9zxqj60"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base bytestring directory exceptions filepath text transformers @@ -177263,28 +176233,6 @@ self: { }) {}; "language-docker" = callPackage - ({ mkDerivation, base, bytestring, containers, data-default - , data-default-class, hspec, hspec-megaparsec, HUnit, megaparsec - , prettyprinter, QuickCheck, split, text, time - }: - mkDerivation { - pname = "language-docker"; - version = "12.0.0"; - sha256 = "1slrq343rcg9shmqxxy8kzk911071x31q61q75dnldnm3x27j6by"; - libraryHaskellDepends = [ - base bytestring containers data-default data-default-class - megaparsec prettyprinter split text time - ]; - testHaskellDepends = [ - base bytestring containers data-default data-default-class hspec - hspec-megaparsec HUnit megaparsec prettyprinter QuickCheck split - text time - ]; - description = "Dockerfile parser, pretty-printer and embedded DSL"; - license = lib.licenses.gpl3Only; - }) {}; - - "language-docker_12_1_0" = callPackage ({ mkDerivation, base, bytestring, containers, data-default , data-default-class, hspec, hspec-megaparsec, HUnit, megaparsec , prettyprinter, QuickCheck, split, text, time @@ -177304,7 +176252,6 @@ self: { ]; description = "Dockerfile parser, pretty-printer and embedded DSL"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "language-dockerfile" = callPackage @@ -177460,14 +176407,13 @@ self: { }) {}; "language-gemini" = callPackage - ({ mkDerivation, base, text }: + ({ mkDerivation, base, hedgehog, hspec, hspec-hedgehog, text }: mkDerivation { pname = "language-gemini"; - version = "0.1.0.0"; - sha256 = "1pfx1vn3bmjmvf019gdw7pfibfg23spvcpg147gy8ymf4yr7rxz6"; - revision = "1"; - editedCabalFile = "0gkllr25h5msjvlcx1pch6a4ndm7yymdqh4ya95drc7gns0kz1zc"; + version = "0.1.0.1"; + sha256 = "1vnl280ld0wazffzx19an5d6gybx4396z57idcfvdvzkap97qbh9"; libraryHaskellDepends = [ base text ]; + testHaskellDepends = [ base hedgehog hspec hspec-hedgehog text ]; description = "Datatypes and parsing/printing functions to represent the Gemini markup language"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -178108,6 +177054,8 @@ self: { ]; description = "AST and pretty printer for Sally"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "language-sh" = callPackage @@ -178253,6 +177201,8 @@ self: { pname = "language-toolkit"; version = "1.1.0.0"; sha256 = "0ffr53jggh3c01v802xywy387jv5wa5vwwyvipiqpxwqcspr4nd7"; + revision = "1"; + editedCabalFile = "129ya22xxv71hv8xxknlpd9ig3xbwld00likf19g7b6psnx60kk0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base containers deepseq parallel ]; @@ -178410,8 +177360,8 @@ self: { pname = "lapack-ffi-tools"; version = "0.1.3.1"; sha256 = "1mf41wcbxkgiv71c3jjwhsdg9d7qpa88qsifpa5vgplpx2v1p6ya"; - revision = "1"; - editedCabalFile = "1mlqmyfsz65if9in8i8cyzm2nbqka00lwg15s2m0hq61sg3kfyfs"; + revision = "2"; + editedCabalFile = "1jz2kiy64vbxazhy4bsfcnwd14kqc7g9vk7v6yyw0p0zlhqfzfv5"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -178453,8 +177403,8 @@ self: { }: mkDerivation { pname = "large-anon"; - version = "0.2.1"; - sha256 = "192cs2pby5pxl1668b4s4sm0ppc3qnk189x2i3fv9y3fb8fqjq66"; + version = "0.3.0"; + sha256 = "07jy3q9x1h49c6zmad2x2s9id4lldklgd133m67l3sfh61qz72vv"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -178464,8 +177414,8 @@ self: { ]; executableHaskellDepends = [ base fourmolu text ]; testHaskellDepends = [ - aeson aeson-pretty arrows base bytestring large-generics mtl - optics-core parsec QuickCheck record-dot-preprocessor + aeson aeson-pretty arrows base bytestring containers large-generics + mtl optics-core parsec QuickCheck record-dot-preprocessor record-hasfield sop-core Stream tasty tasty-hunit tasty-quickcheck text typelet validation-selective ]; @@ -178493,6 +177443,8 @@ self: { ]; description = "Generic programming API for large-records and large-anon"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "large-hashable" = callPackage @@ -178549,6 +177501,7 @@ self: { ]; description = "Efficient compilation for large records, linear in the size of the record"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "largeword" = callPackage @@ -178821,10 +177774,8 @@ self: { }: mkDerivation { pname = "lattices"; - version = "2.0.3"; - sha256 = "1mn78xqwsksybggnsnx8xkmzlc9his1si14dy5v6vmlchkjym9qg"; - revision = "4"; - editedCabalFile = "0nkcdqb3gsp1lqpj7hv4knndj7p258j0cp4cbqx7jixc93gkq044"; + version = "2.1"; + sha256 = "1wxam7c00bcfl3g1aiayxzjscmmbm393gfj8zmx77ijhs7v1zp3v"; libraryHaskellDepends = [ base base-compat containers deepseq hashable integer-logarithms QuickCheck semigroupoids tagged transformers universe-base @@ -179189,20 +178140,20 @@ self: { "lazy-async" = callPackage ({ mkDerivation, base, exceptions, hedgehog, lifted-async - , monad-control, optics-core, optics-th, rank2classes, stm - , transformers, transformers-base + , monad-control, optics-core, optics-th, stm, transformers + , transformers-base }: mkDerivation { pname = "lazy-async"; - version = "1.0.0.2"; - sha256 = "0727384j636pbnfmw2v98j6yn9qw0inv5zrsvmyf1p6znk718jf8"; + version = "1.1.0.0"; + sha256 = "05jn9jdy3rbdl2pygjrzpv2kivq9h6iw2zq8nk1ximc43xxpca4a"; libraryHaskellDepends = [ - base exceptions lifted-async monad-control rank2classes stm - transformers transformers-base + base exceptions lifted-async monad-control stm transformers + transformers-base ]; testHaskellDepends = [ base exceptions hedgehog lifted-async monad-control optics-core - optics-th rank2classes stm transformers transformers-base + optics-th stm transformers transformers-base ]; description = "Asynchronous actions that don't start right away"; license = lib.licenses.mit; @@ -179700,18 +178651,6 @@ self: { }) {}; "leancheck" = callPackage - ({ mkDerivation, base, template-haskell }: - mkDerivation { - pname = "leancheck"; - version = "0.9.12"; - sha256 = "15wpklkbr03dciai4mk8bm1yk9svxxmbsl22wsvwk3ns7aiamrkj"; - libraryHaskellDepends = [ base template-haskell ]; - testHaskellDepends = [ base ]; - description = "Enumerative property-based testing"; - license = lib.licenses.bsd3; - }) {}; - - "leancheck_1_0_0" = callPackage ({ mkDerivation, base, template-haskell }: mkDerivation { pname = "leancheck"; @@ -179721,7 +178660,6 @@ self: { testHaskellDepends = [ base ]; description = "Enumerative property-based testing"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "leancheck-enum-instances" = callPackage @@ -180165,46 +179103,6 @@ self: { }) {}; "lens" = callPackage - ({ mkDerivation, array, assoc, base, base-compat, base-orphans - , bifunctors, bytestring, call-stack, comonad, containers - , contravariant, criterion, deepseq, distributive, exceptions - , filepath, free, generic-deriving, ghc-prim, hashable, HUnit - , indexed-traversable, indexed-traversable-instances - , kan-extensions, mtl, parallel, profunctors, QuickCheck - , reflection, semigroupoids, simple-reflect, strict, tagged - , template-haskell, test-framework, test-framework-hunit - , test-framework-quickcheck2, text, th-abstraction, these - , transformers, transformers-compat, unordered-containers, vector - }: - mkDerivation { - pname = "lens"; - version = "5.1.1"; - sha256 = "08mkm2mjvhmwg9hc4kd4cd6dgmcszs1p2mzp1nmri7lqbpy9jknc"; - revision = "1"; - editedCabalFile = "19z3k7ikpfa96b86yabxghfqpnq9d0ayy4gdlvci3ycvws0s8cy6"; - libraryHaskellDepends = [ - array assoc base base-orphans bifunctors bytestring call-stack - comonad containers contravariant distributive exceptions filepath - free ghc-prim hashable indexed-traversable - indexed-traversable-instances kan-extensions mtl parallel - profunctors reflection semigroupoids strict tagged template-haskell - text th-abstraction these transformers transformers-compat - unordered-containers vector - ]; - testHaskellDepends = [ - base containers deepseq HUnit mtl QuickCheck simple-reflect - test-framework test-framework-hunit test-framework-quickcheck2 - transformers - ]; - benchmarkHaskellDepends = [ - base base-compat bytestring comonad containers criterion deepseq - generic-deriving transformers unordered-containers vector - ]; - description = "Lenses, Folds and Traversals"; - license = lib.licenses.bsd2; - }) {}; - - "lens_5_2_2" = callPackage ({ mkDerivation, array, assoc, base, base-compat, base-orphans , bifunctors, bytestring, call-stack, comonad, containers , contravariant, criterion, deepseq, distributive, exceptions @@ -180220,6 +179118,8 @@ self: { pname = "lens"; version = "5.2.2"; sha256 = "1qvnzxa8z3jk7kcrc394cd6drckcncpqd1jq3kk8dg9m372mhp45"; + revision = "1"; + editedCabalFile = "0dc47dfby74lmw5y436yhqi0pkgmw7vs12d14c7vhi9n2wr5f7g0"; libraryHaskellDepends = [ array assoc base base-orphans bifunctors bytestring call-stack comonad containers contravariant distributive exceptions filepath @@ -180240,7 +179140,6 @@ self: { ]; description = "Lenses, Folds and Traversals"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "lens-accelerate" = callPackage @@ -180293,15 +179192,17 @@ self: { }) {}; "lens-aeson" = callPackage - ({ mkDerivation, aeson, attoparsec, base, bytestring, lens - , scientific, text, text-short, unordered-containers, vector + ({ mkDerivation, aeson, base, bytestring, lens, scientific, text + , text-short, unordered-containers, vector }: mkDerivation { pname = "lens-aeson"; - version = "1.2.2"; - sha256 = "0wwmg0zv2561dmmbil829dw6qmdl02kfs690iy549nbznj2kil8l"; + version = "1.2.3"; + sha256 = "00ac8anw6a3alwlqqvbr1vp7brajrdp66ximl7ylvj28wbznmg3v"; + revision = "1"; + editedCabalFile = "1h3y26a6z9dxifqm1ndqhlnwa41gb8majr3rqs7i93xnyp8y20b6"; libraryHaskellDepends = [ - aeson attoparsec base bytestring lens scientific text text-short + aeson base bytestring lens scientific text text-short unordered-containers vector ]; description = "Law-abiding lenses for aeson"; @@ -180413,6 +179314,17 @@ self: { broken = true; }) {}; + "lens-indexed-plated" = callPackage + ({ mkDerivation, base, lens }: + mkDerivation { + pname = "lens-indexed-plated"; + version = "0.1.0"; + sha256 = "1kr0xq65b2510y88y62s69psfjbgrmq0nl7y6lkvrmqk3ngx53jb"; + libraryHaskellDepends = [ base lens ]; + description = "Indexed version of Plated"; + license = lib.licenses.bsd2; + }) {}; + "lens-labels" = callPackage ({ mkDerivation, base, ghc-prim, profunctors, tagged }: mkDerivation { @@ -180643,6 +179555,7 @@ self: { description = "Lenses for toml-parser"; license = lib.licenses.isc; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lens-tutorial" = callPackage @@ -181198,6 +180111,23 @@ self: { mainProgram = "bf-test"; }) {}; + "libBF_0_6_6" = callPackage + ({ mkDerivation, base, deepseq, hashable }: + mkDerivation { + pname = "libBF"; + version = "0.6.6"; + sha256 = "1wjfcpvcp749mipyj7j9s8qwj68kvhn1516l43gnq2hhfy9bpsvs"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base deepseq hashable ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ base ]; + description = "A binding to the libBF library"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + mainProgram = "bf-test"; + }) {}; + "libGenI" = callPackage ({ mkDerivation, base, binary, containers, HUnit, mtl, parsec , process, QuickCheck @@ -181246,6 +180176,8 @@ self: { ]; description = "Haskell interface to libarchive"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libarchive;}; "libarchive-conduit" = callPackage @@ -181392,6 +180324,7 @@ self: { ]; description = "Store and manipulate data in a graph"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "libhbb" = callPackage @@ -181514,6 +180447,8 @@ self: { ]; description = "A Haskell implementation of JSON Web Token (JWT)"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "liblastfm" = callPackage @@ -181634,7 +180569,9 @@ self: { ]; description = "Bindings for libmdbx, an embedded key/value store"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "libmdbx-exe"; + broken = true; }) {}; "libmodbus" = callPackage @@ -181813,14 +180750,15 @@ self: { "libphonenumber" = callPackage ({ mkDerivation, base, bytestring, c2hs, containers, deepseq, hspec - , phonenumber, process, protobuf, QuickCheck, transformers + , phonenumber, process, protobuf, QuickCheck, system-cxx-std-lib + , transformers }: mkDerivation { pname = "libphonenumber"; version = "0.1.2.0"; sha256 = "0iw4ps3dky0grbvmajaz81d6q9zzqy8r9jfjmh6bc5i6k3w0mqwa"; libraryHaskellDepends = [ - base bytestring containers deepseq transformers + base bytestring containers deepseq system-cxx-std-lib transformers ]; librarySystemDepends = [ phonenumber protobuf ]; libraryToolDepends = [ c2hs ]; @@ -182188,6 +181126,8 @@ self: { description = "Bindings to libtelnet"; license = lib.licenses.gpl3Plus; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libtelnet;}; "libversion" = callPackage @@ -182331,15 +181271,15 @@ self: { }: mkDerivation { pname = "libyaml-streamly"; - version = "0.2.1"; - sha256 = "0jh980ilaxhdhyp3vbmg0s3c2vf5ckxlkyj6n45vqb56847mg5bk"; - revision = "1"; - editedCabalFile = "0lf4zz6li7g4nz6gspvs0f14fkg9bkgdzz6bclhsnv36ksbr1h8w"; + version = "0.2.2"; + sha256 = "1dzsmcgsszkh5n7hpzxy1i4c2mrzp19ncddagklwcpll85aqp3an"; libraryHaskellDepends = [ base bytestring deepseq safe-exceptions streamly ]; description = "Low-level, streaming YAML interface via streamly"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "libzfs" = callPackage @@ -182658,10 +181598,8 @@ self: { }: mkDerivation { pname = "lifx-lan"; - version = "0.8.0"; - sha256 = "0zkc0575i87ii8izz0fsvd959wkxfacz36ng7msb25ld8byhsh1g"; - revision = "1"; - editedCabalFile = "16ah6j1zbxza374vmb4215i5swq6wny1jhp9y8niakf7g3b2dcgw"; + version = "0.8.1"; + sha256 = "1h971r7i36ay0v9nalgjfsz7vnpd1ps74g0d8lawcm00s4fgw8as"; libraryHaskellDepends = [ ansi-terminal base binary bytestring colour composition containers extra monad-loops mtl network random safe text time transformers @@ -182825,14 +181763,11 @@ self: { }: mkDerivation { pname = "lima"; - version = "0.2.1.3"; - sha256 = "0834lh5yaynfyy2k6lqbb43dsrgsrmpi11w73js8p08zhzkhndnr"; - isLibrary = true; - isExecutable = true; + version = "0.3.0.0"; + sha256 = "05hjx72sshf6bvhlfr23f4jpdqv0qi898nd53a9hi4940n8a15jv"; libraryHaskellDepends = [ - base data-default microlens microlens-th text + base data-default microlens microlens-th string-interpolate text ]; - executableHaskellDepends = [ base microlens text ]; testHaskellDepends = [ base breakpoint directory doctest-parallel hedgehog microlens pretty-simple string-interpolate tasty tasty-hedgehog tasty-hunit @@ -182840,7 +181775,6 @@ self: { ]; description = "Convert between Haskell, Markdown, Literate Haskell, TeX"; license = lib.licenses.mit; - mainProgram = "readme"; }) {}; "limp" = callPackage @@ -183027,6 +181961,22 @@ self: { broken = true; }) {}; + "line-indexed-cursor" = callPackage + ({ mkDerivation, array, base, bytestring, criterion, hspec, random + }: + mkDerivation { + pname = "line-indexed-cursor"; + version = "0.1.0.0"; + sha256 = "14aihlbjlbiazdjh0ic1bhqpwc0g1z2y42f8s79pcwm8rk1lvgim"; + libraryHaskellDepends = [ array base bytestring ]; + testHaskellDepends = [ base hspec ]; + benchmarkHaskellDepends = [ base criterion random ]; + description = "Line-indexed file reader"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "line-size" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -183057,33 +182007,6 @@ self: { }) {}; "linear" = callPackage - ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes - , bytestring, cereal, containers, deepseq, distributive, ghc-prim - , hashable, HUnit, indexed-traversable, lens, random, reflection - , semigroupoids, semigroups, simple-reflect, tagged - , template-haskell, test-framework, test-framework-hunit - , transformers, transformers-compat, unordered-containers, vector - , void - }: - mkDerivation { - pname = "linear"; - version = "1.21.10"; - sha256 = "1d3s1p4imkifn7dccqci2qiwcg99x22kf250hzh4fh4xghi361xr"; - libraryHaskellDepends = [ - adjunctions base base-orphans binary bytes cereal containers - deepseq distributive ghc-prim hashable indexed-traversable lens - random reflection semigroupoids semigroups tagged template-haskell - transformers transformers-compat unordered-containers vector void - ]; - testHaskellDepends = [ - base binary bytestring deepseq HUnit reflection simple-reflect - test-framework test-framework-hunit vector - ]; - description = "Linear Algebra"; - license = lib.licenses.bsd3; - }) {}; - - "linear_1_22" = callPackage ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes , bytestring, cereal, containers, deepseq, distributive, ghc-prim , hashable, HUnit, indexed-traversable, lens, random, reflection @@ -183109,7 +182032,6 @@ self: { ]; description = "Linear Algebra"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "linear-accelerate" = callPackage @@ -183334,9 +182256,9 @@ self: { ({ mkDerivation, array, base, constraints }: mkDerivation { pname = "linear-smc"; - version = "2.0.2"; - sha256 = "0dzbqdjrx5c3nkdddmijrd153wydi66yfgjr85279440a68nqbcx"; - libraryHaskellDepends = [ base constraints ]; + version = "2.2.3"; + sha256 = "0i8j7zsrycmcrhf830mrfisvfyhzrr65c14nl9dg9yjfdsw9gh3x"; + libraryHaskellDepends = [ array base constraints ]; testHaskellDepends = [ array base constraints ]; description = "Build SMC morphisms using linear types"; license = lib.licenses.lgpl3Plus; @@ -183496,7 +182418,9 @@ self: { ]; description = "A lightweight readline-replacement library for Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "linenoise-demo"; + broken = true; }) {}; "lines-of-action" = callPackage @@ -183546,6 +182470,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Express Integral types as linguistic ordinals (1st, 2nd, 3rd, etc)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "link-relations" = callPackage @@ -183866,6 +182792,21 @@ self: { platforms = lib.platforms.linux; }) {}; + "linux-file-extents_0_2_0_1" = callPackage + ({ mkDerivation, base, unix }: + mkDerivation { + pname = "linux-file-extents"; + version = "0.2.0.1"; + sha256 = "0c8zp47sjr741m86ah1yq71lcav32xid05x5c83adwb23a6fgmsk"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base unix ]; + description = "Retrieve file fragmentation information under Linux"; + license = lib.licenses.bsd3; + platforms = lib.platforms.linux; + hydraPlatforms = lib.platforms.none; + }) {}; + "linux-framebuffer" = callPackage ({ mkDerivation, base, bindings-DSL, unix }: mkDerivation { @@ -183927,6 +182868,19 @@ self: { platforms = lib.platforms.linux; }) {}; + "linux-namespaces_0_1_3_1" = callPackage + ({ mkDerivation, base, bytestring, unix }: + mkDerivation { + pname = "linux-namespaces"; + version = "0.1.3.1"; + sha256 = "1h0ar1jqgip5k5b7c2v452jk62ig1pfgpw587faw8z0ai51yrl9a"; + libraryHaskellDepends = [ base bytestring unix ]; + description = "Work with linux namespaces: create new or enter existing ones"; + license = lib.licenses.bsd3; + platforms = lib.platforms.linux; + hydraPlatforms = lib.platforms.none; + }) {}; + "linux-perf" = callPackage ({ mkDerivation, base, binary, bytestring, containers, directory , filepath, ghc-events, mtl, pretty, process, unix @@ -184217,6 +183171,7 @@ self: { license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; mainProgram = "fixpoint"; + broken = true; }) {inherit (pkgs) git; inherit (pkgs) nettools; inherit (pkgs) z3;}; @@ -184660,6 +183615,20 @@ self: { maintainers = [ lib.maintainers.Gabriella439 ]; }) {}; + "list-transformer_1_1_0" = callPackage + ({ mkDerivation, base, doctest, mmorph, mtl }: + mkDerivation { + pname = "list-transformer"; + version = "1.1.0"; + sha256 = "061a2cnlv335ski627zrdfk8nd110wpiawclq5nwa3sx0l92xsrx"; + libraryHaskellDepends = [ base mmorph mtl ]; + testHaskellDepends = [ base doctest ]; + description = "List monad transformer"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.Gabriella439 ]; + }) {}; + "list-tries" = callPackage ({ mkDerivation, base, binary, ChasingBottoms, containers, dlist , HUnit, QuickCheck, template-haskell, test-framework @@ -184704,15 +183673,17 @@ self: { "list-witnesses" = callPackage ({ mkDerivation, base, decidable, functor-products, microlens - , profunctors, singletons, vinyl + , profunctors, singletons, singletons-base, vinyl }: mkDerivation { pname = "list-witnesses"; - version = "0.1.3.2"; - sha256 = "1hzm8ijx8id5ij199dg362ai1wmdrs8mr10qkv57639hv61almyq"; + version = "0.1.4.0"; + sha256 = "1npsb38smvjfpamnv1b5xhnb9ckk65c35dngny6jxgw0i1xi975l"; + revision = "2"; + editedCabalFile = "0i4kcxc150nvy2vmljr4mvxy4wqlijiar6jvn8bjh5lfjapc0l98"; libraryHaskellDepends = [ base decidable functor-products microlens profunctors singletons - vinyl + singletons-base vinyl ]; description = "Witnesses for working with type-level lists"; license = lib.licenses.bsd3; @@ -184895,31 +183866,6 @@ self: { }) {}; "literatex" = callPackage - ({ mkDerivation, ansi-wl-pprint, base, bytestring, conduit - , filepath, optparse-applicative, tasty, tasty-hunit, text, ttc - , unliftio - }: - mkDerivation { - pname = "literatex"; - version = "0.2.1.0"; - sha256 = "0sqkfk7wq4k8jpljn4ih3pfv766ay8kf9s8l8x7h3pcqpnxd0xix"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring conduit text ttc unliftio - ]; - executableHaskellDepends = [ - ansi-wl-pprint base optparse-applicative ttc - ]; - testHaskellDepends = [ - base bytestring filepath tasty tasty-hunit text ttc unliftio - ]; - description = "transform literate source code to Markdown"; - license = lib.licenses.mit; - mainProgram = "literatex"; - }) {}; - - "literatex_0_3_0_0" = callPackage ({ mkDerivation, ansi-wl-pprint, base, bytestring, conduit , filepath, optparse-applicative, tasty, tasty-hunit, text, ttc , unliftio @@ -184928,6 +183874,8 @@ self: { pname = "literatex"; version = "0.3.0.0"; sha256 = "0ph3s26hxvnkdqc3s09d3ka1p224zmgwc3k6zi7jmma0sgrmnm9x"; + revision = "1"; + editedCabalFile = "1nn5manl4133hl3r2xnk1m36kb43j7k1vaw5v71pn5krdnx9ygkp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -184941,7 +183889,6 @@ self: { ]; description = "transform literate source code to Markdown"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "literatex"; }) {}; @@ -184957,6 +183904,8 @@ self: { testHaskellDepends = [ base containers mtl tasty tasty-hunit ]; description = "Simple implementation of Earley parsing"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "little-logger" = callPackage @@ -184965,8 +183914,8 @@ self: { }: mkDerivation { pname = "little-logger"; - version = "1.0.1"; - sha256 = "110yk385dss8hyyzkf2hpaxvrd39hgfhyv6sjf0pxqbxa4bqv51f"; + version = "1.0.2"; + sha256 = "0b4sxh14js1kwnxajv479m6ra3hfm434xbgir16ja506fnsharfj"; libraryHaskellDepends = [ base microlens monad-logger mtl text unliftio-core ]; @@ -184979,37 +183928,19 @@ self: { }) {}; "little-rio" = callPackage - ({ mkDerivation, base, deepseq, exceptions, little-logger - , microlens, microlens-mtl, mtl, primitive, resourcet - , unliftio-core - }: - mkDerivation { - pname = "little-rio"; - version = "1.0.1"; - sha256 = "0l505nimjwg9i8kkj2ndp5i4mh0mhxnhssxsvgmd5qnzxw4i0rd3"; - libraryHaskellDepends = [ - base deepseq exceptions little-logger microlens microlens-mtl mtl - primitive resourcet unliftio-core - ]; - description = "When you need just the RIO monad"; - license = lib.licenses.bsd3; - }) {}; - - "little-rio_2_0_0" = callPackage ({ mkDerivation, base, exceptions, little-logger, microlens, mtl , primitive, resourcet, unliftio-core }: mkDerivation { pname = "little-rio"; - version = "2.0.0"; - sha256 = "1hg1vf29lvsg2p8n7w10vy2kb7qgsaw3ybj5hsgxcr2v1inafgil"; + version = "2.0.1"; + sha256 = "1plj2pysd28f0ipfhvg710xddj68dcgp667if0hxk8lxhql0s9n1"; libraryHaskellDepends = [ base exceptions little-logger microlens mtl primitive resourcet unliftio-core ]; description = "When you need just the RIO monad"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "live-sequencer" = callPackage @@ -185483,6 +184414,32 @@ self: { broken = true; }) {}; + "llvm-party" = callPackage + ({ mkDerivation, array, attoparsec, base, bytestring, Cabal + , containers, exceptions, fail, mtl, pretty-show, process + , QuickCheck, tasty, tasty-hunit, tasty-quickcheck + , template-haskell, temporary, transformers, unordered-containers + , utf8-string + }: + mkDerivation { + pname = "llvm-party"; + version = "12.1.1"; + sha256 = "1gsnpzgbz2mgbhqgy4lrj97pp9qgsdhpk9bdwb45y6mp6afp8gc9"; + setupHaskellDepends = [ base Cabal containers ]; + libraryHaskellDepends = [ + array attoparsec base bytestring containers exceptions fail mtl + template-haskell transformers unordered-containers utf8-string + ]; + testHaskellDepends = [ + base bytestring containers mtl pretty-show process QuickCheck tasty + tasty-hunit tasty-quickcheck temporary transformers + ]; + description = "General purpose LLVM bindings"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "llvm-pkg-config" = callPackage ({ mkDerivation, base, Cabal, explicit-exception, process , shell-utility, transformers, utility-ht @@ -185570,6 +184527,8 @@ 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 @@ -185632,6 +184591,8 @@ self: { ]; description = "Higher level API for working with LMDB"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lmdb-simple" = callPackage @@ -185838,6 +184799,8 @@ self: { pname = "loc"; version = "0.1.4.1"; sha256 = "12bsbjl0808dfcshz38iih3cl3768zix23adznnq821ffxsxfiiw"; + revision = "1"; + editedCabalFile = "0jfpyy8nl776fihnbzwh3cb9n6xss6l77prfhhqw32dgy4pnqcam"; libraryHaskellDepends = [ base containers ]; testHaskellDepends = [ base containers hedgehog hspec hspec-hedgehog @@ -185846,6 +184809,23 @@ self: { license = lib.licenses.asl20; }) {}; + "loc_0_2_0_0" = callPackage + ({ mkDerivation, base, containers, hedgehog, hspec, hspec-hedgehog + , integer-types + }: + mkDerivation { + pname = "loc"; + version = "0.2.0.0"; + sha256 = "1wp446p3vzn5xy5zyija37c6yifpf128fkhg8akfmkzw2xsn51pj"; + libraryHaskellDepends = [ base containers integer-types ]; + testHaskellDepends = [ + base containers hedgehog hspec hspec-hedgehog integer-types + ]; + description = "Line and column positions and ranges in text files"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + }) {}; + "loc-test" = callPackage ({ mkDerivation, base, containers, hedgehog, loc }: mkDerivation { @@ -185855,6 +184835,8 @@ self: { libraryHaskellDepends = [ base containers hedgehog loc ]; description = "Hedgehog generators for loc"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "local-address" = callPackage @@ -186367,17 +185349,6 @@ self: { }) {}; "logfloat" = callPackage - ({ mkDerivation, array, base }: - mkDerivation { - pname = "logfloat"; - version = "0.13.4"; - sha256 = "0kbx7p3lfbvqfcqpwfspm82x3z404sa85k586jwlkhyh7rxv1fh3"; - libraryHaskellDepends = [ array base ]; - description = "Log-domain floating point numbers"; - license = lib.licenses.bsd3; - }) {}; - - "logfloat_0_14_0" = callPackage ({ mkDerivation, array, base }: mkDerivation { pname = "logfloat"; @@ -186386,7 +185357,6 @@ self: { libraryHaskellDepends = [ array base ]; description = "Log-domain floating point numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "logfmt" = callPackage @@ -186461,29 +185431,6 @@ self: { }) {}; "logging-effect" = callPackage - ({ mkDerivation, async, base, bytestring, criterion, exceptions - , fast-logger, free, lifted-async, monad-control, monad-logger, mtl - , prettyprinter, semigroups, stm, stm-delay, text, time - , transformers, transformers-base, unliftio-core - }: - mkDerivation { - pname = "logging-effect"; - version = "1.3.13"; - sha256 = "109q5jh07n8h94jrfxc694b54c3dzn831a87l0i5ailz9cfvbmj4"; - libraryHaskellDepends = [ - async base exceptions free monad-control mtl prettyprinter - semigroups stm stm-delay text time transformers transformers-base - unliftio-core - ]; - benchmarkHaskellDepends = [ - base bytestring criterion fast-logger lifted-async monad-logger - prettyprinter text time - ]; - description = "A mtl-style monad transformer for general purpose & compositional logging"; - license = lib.licenses.bsd3; - }) {}; - - "logging-effect_1_4_0" = callPackage ({ mkDerivation, async, base, bytestring, criterion, exceptions , fast-logger, free, lifted-async, monad-control, monad-logger, mtl , prettyprinter, semigroups, stm, stm-delay, text, time @@ -186504,7 +185451,6 @@ self: { ]; description = "A mtl-style monad transformer for general purpose & compositional logging"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "logging-effect-colors" = callPackage @@ -186826,8 +185772,8 @@ self: { }: mkDerivation { pname = "logstash"; - version = "0.1.0.3"; - sha256 = "17s7529mcvpm7pqjz5d980ra70z41zk0k52l6ps1p1zfi5p4niys"; + version = "0.1.0.4"; + sha256 = "1x736zc8r8vbrb4n82sqskgs0k5avbdscviwy0rcj7gpsr2qd89g"; libraryHaskellDepends = [ aeson async base bytestring data-default-class exceptions monad-control mtl network resource-pool resourcet retry stm @@ -187113,6 +186059,8 @@ self: { libraryHaskellDepends = [ base integer-gmp ]; description = "FFI bindings for C long double"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "longboi" = callPackage @@ -187180,6 +186128,8 @@ self: { ]; description = "parser with looksee"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lookup-tables" = callPackage @@ -187397,18 +186347,18 @@ self: { "lorentz" = callPackage ({ mkDerivation, aeson-pretty, base-noprelude, bimap, bytestring , constraints, containers, cryptonite, data-default - , first-class-families, fmt, lens, morley, morley-prelude, mtl - , named, optparse-applicative, singletons, singletons-base + , first-class-families, lens, morley, morley-prelude, mtl, named + , optparse-applicative, singletons, singletons-base , template-haskell, text, type-errors, unordered-containers, vinyl , with-utf8 }: mkDerivation { pname = "lorentz"; - version = "0.15.1"; - sha256 = "1wp5v74w3i0xrzcd5b5vk2cfvkzi3dbrnf1hr3fjf3x67dpjgs89"; + version = "0.15.2"; + sha256 = "1jnh4prjkjbiy3qhwn0iz4immhhqrdhbnqagyiqlinbrpb3nzm8x"; libraryHaskellDepends = [ aeson-pretty base-noprelude bimap bytestring constraints containers - cryptonite data-default first-class-families fmt lens morley + cryptonite data-default first-class-families lens morley morley-prelude mtl named optparse-applicative singletons singletons-base template-haskell text type-errors unordered-containers vinyl with-utf8 @@ -187753,7 +186703,7 @@ self: { license = lib.licenses.mit; }) {}; - "lsp_2_0_0_0" = callPackage + "lsp_2_1_0_0" = callPackage ({ mkDerivation, aeson, async, attoparsec, base, bytestring , co-log-core, containers, data-default, directory, exceptions , filepath, hashable, hspec, hspec-discover, lens, lsp-types, mtl @@ -187763,8 +186713,8 @@ self: { }: mkDerivation { pname = "lsp"; - version = "2.0.0.0"; - sha256 = "1rhibq4s0d9vxsfnwa35nm5xll693k0hbfp6b2c9478s8wg32wxg"; + version = "2.1.0.0"; + sha256 = "03gk98fgf32blywdds0fc5351bmcbbfrnqwlg33l2ih75nwa59y8"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -187783,6 +186733,31 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "lsp-client" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring, co-log-core + , data-default, dependent-map, Diff, directory, extra, filepath + , generic-lens, Glob, hashable, hspec, lens, lsp, lsp-types, mtl + , process, QuickCheck, stm, text, text-rope, unix, unliftio + , unordered-containers + }: + mkDerivation { + pname = "lsp-client"; + version = "0.1.0.0"; + sha256 = "0ivq79g57kxr1lfca137acvbzi3lx0qa10ahmpkpc2wc9bj0mb05"; + libraryHaskellDepends = [ + aeson aeson-pretty base bytestring co-log-core data-default + dependent-map Diff directory filepath generic-lens Glob hashable + lens lsp lsp-types mtl stm text text-rope unix unliftio + unordered-containers + ]; + testHaskellDepends = [ + aeson base bytestring extra hspec lens lsp-types process QuickCheck + unliftio + ]; + description = "Haskell library for Language Server Protocol clients"; + license = lib.licenses.asl20; + }) {}; + "lsp-test" = callPackage ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base , bytestring, co-log-core, conduit, conduit-parse, containers @@ -187812,7 +186787,7 @@ self: { license = lib.licenses.bsd3; }) {}; - "lsp-test_0_15_0_0" = callPackage + "lsp-test_0_15_0_1" = callPackage ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, async, base , bytestring, co-log-core, conduit, conduit-parse, containers , data-default, Diff, directory, exceptions, extra, filepath, Glob @@ -187821,8 +186796,8 @@ self: { }: mkDerivation { pname = "lsp-test"; - version = "0.15.0.0"; - sha256 = "0fg1nc1xkv5cl26vbny97r1w755qim9hcmzfxdx38wklrishrvcx"; + version = "0.15.0.1"; + sha256 = "1n3sqmb41kzczyqpz9ddqi3wmkpdwdjvgzldjn3pncs4lfxfjnxd"; libraryHaskellDepends = [ aeson aeson-pretty ansi-terminal async base bytestring co-log-core conduit conduit-parse containers data-default Diff directory @@ -187889,7 +186864,7 @@ self: { license = lib.licenses.mit; }) {}; - "lsp-types_2_0_0_1" = callPackage + "lsp-types_2_0_1_0" = callPackage ({ mkDerivation, aeson, base, binary, containers, data-default , deepseq, Diff, directory, dlist, exceptions, file-embed, filepath , hashable, hspec, hspec-discover, lens, mod, mtl, network-uri @@ -187898,8 +186873,8 @@ self: { }: mkDerivation { pname = "lsp-types"; - version = "2.0.0.1"; - sha256 = "119w6crys6jh680gm2pdpvxxqxs0fwqfdmzlr274qlj00sa51wc7"; + version = "2.0.1.0"; + sha256 = "1q7zc7jpyf44x10fk4wccq7k8sqq2fkqrx75v2rk1ahlklanqh2p"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -187990,6 +186965,7 @@ self: { ]; description = "Parameterized file evaluator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "ltext"; }) {}; @@ -188071,20 +187047,6 @@ self: { }) {}; "lua" = callPackage - ({ mkDerivation, base, lua5_4, tasty, tasty-hunit }: - mkDerivation { - pname = "lua"; - version = "2.2.1"; - sha256 = "07wni3ji46ndqabwffgwzij2jk34dq2d66z15hcd6jg33sqnym45"; - configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ]; - libraryHaskellDepends = [ base ]; - librarySystemDepends = [ lua5_4 ]; - testHaskellDepends = [ base tasty tasty-hunit ]; - description = "Lua, an embeddable scripting language"; - license = lib.licenses.mit; - }) {inherit (pkgs) lua5_4;}; - - "lua_2_3_1" = callPackage ({ mkDerivation, base, lua5_4, tasty, tasty-hunit }: mkDerivation { pname = "lua"; @@ -188096,7 +187058,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Lua, an embeddable scripting language"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) lua5_4;}; "lua-arbitrary" = callPackage @@ -188233,7 +187194,9 @@ self: { testHaskellDepends = [ base lucid text ]; description = "Use Alpine.js in your lucid templates"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "lucid-alpine-exe"; + broken = true; }) {}; "lucid-aria" = callPackage @@ -188362,17 +187325,15 @@ self: { }) {}; "lucid2" = callPackage - ({ mkDerivation, base, bifunctors, blaze-builder, bytestring - , containers, hspec, HUnit, mtl, parsec, text, transformers + ({ mkDerivation, base, bifunctors, bytestring, containers, hspec + , HUnit, mtl, parsec, text, transformers }: mkDerivation { pname = "lucid2"; - version = "0.0.20221012"; - sha256 = "00r3qmxrs3jh3v4gl5m38j86ihh78q4vmsk4bz2pbcc8gh2yficj"; - revision = "1"; - editedCabalFile = "029vhllgcdayrk34dssqirf1xpsr7z9jmi1lrh7qg2m061ypipxf"; + version = "0.0.20230706"; + sha256 = "165bar5kgdrldg46f743jhf0p2krvrrpsg0my7zbgxyjayrwf8bd"; libraryHaskellDepends = [ - base blaze-builder bytestring containers mtl text transformers + base bytestring containers mtl text transformers ]; testHaskellDepends = [ base bifunctors hspec HUnit mtl parsec text @@ -188438,6 +187399,7 @@ self: { description = "An implementation of Luhn's check digit algorithm"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lui" = callPackage @@ -188736,6 +187698,8 @@ self: { ]; description = "Read the configuration file of the standard LXD client"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lye" = callPackage @@ -188789,6 +187753,8 @@ self: { ]; description = "Bindings to LZ4"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "lz4-conduit" = callPackage @@ -190607,8 +189573,8 @@ self: { }: mkDerivation { pname = "manifold-random"; - version = "0.6.0.0"; - sha256 = "088kvfap0lbpnzz0vraa4pclj3savm0m4a174digd1r9x025v4kv"; + version = "0.6.1.0"; + sha256 = "1cxxsymsss21gcai6c33xp6ddnkpsi4ywjw2wfigqhdj2x6qhgjd"; libraryHaskellDepends = [ base constrained-categories linearmap-category manifolds random-fu semigroups vector-space @@ -190622,22 +189588,22 @@ self: { ({ mkDerivation, array, base, binary, call-stack, comonad , constrained-categories, containers, deepseq, equational-reasoning , free, free-vector-spaces, half-space, ieee754, lens, linear - , linearmap-category, manifolds-core, MemoTrie, number-show - , placeholders, pragmatic-show, QuickCheck, semigroups - , spatial-rotations, tagged, tasty, tasty-hunit, tasty-quickcheck - , transformers, vector, vector-space, void + , linearmap-category, list-t, manifolds-core, MemoTrie, number-show + , placeholders, pragmatic-show, QuickCheck, semigroups, singletons + , singletons-base, spatial-rotations, tagged, tasty, tasty-hunit + , tasty-quickcheck, transformers, vector, vector-space, void }: mkDerivation { pname = "manifolds"; - version = "0.6.0.0"; - sha256 = "1vp3lnp15s1qzkplxj8bss4s27gp7p9aj3rc0q99dzkr4ylbw2gz"; + version = "0.6.1.0"; + sha256 = "0mhzaqisim9fqvc5w14kr73fmhis7z5q48p2fzli5d1v1kx8vfj2"; libraryHaskellDepends = [ array base binary call-stack comonad constrained-categories containers deepseq equational-reasoning free free-vector-spaces - half-space ieee754 lens linear linearmap-category manifolds-core - MemoTrie number-show placeholders pragmatic-show QuickCheck - semigroups spatial-rotations tagged transformers vector - vector-space void + half-space ieee754 lens linear linearmap-category list-t + manifolds-core MemoTrie number-show placeholders pragmatic-show + QuickCheck semigroups singletons singletons-base spatial-rotations + tagged transformers vector vector-space void ]; testHaskellDepends = [ base constrained-categories containers lens linear @@ -190733,8 +189699,8 @@ self: { pname = "map-syntax"; version = "0.3"; sha256 = "0b3ddi998saw5gi5r4bjbpid03rxlifn08zv15wf0b90ambhcc4k"; - revision = "7"; - editedCabalFile = "1vq9s26pclyfh1hms84a8749ixchp2fjkaviyqz37hwg5pw2s27p"; + revision = "8"; + editedCabalFile = "0cqpj3cdygj1dpinz182kaa6zid22wb34x6kiv8kyx40px9n8wx5"; libraryHaskellDepends = [ base containers mtl ]; testHaskellDepends = [ base containers deepseq hspec HUnit mtl QuickCheck transformers @@ -190963,6 +189929,29 @@ self: { mainProgram = "markdown-unlit"; }) {}; + "markdown-unlit_0_6_0" = callPackage + ({ mkDerivation, base, base-compat, directory, hspec + , hspec-discover, QuickCheck, silently, stringbuilder, temporary + }: + mkDerivation { + pname = "markdown-unlit"; + version = "0.6.0"; + sha256 = "0nkvg33i8vkpb774lph306c7xwl8ib26ily5zjy37np43xc1i2yk"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base base-compat ]; + executableHaskellDepends = [ base base-compat ]; + testHaskellDepends = [ + base base-compat directory hspec QuickCheck silently stringbuilder + temporary + ]; + testToolDepends = [ hspec-discover ]; + description = "Literate Haskell support for Markdown"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + mainProgram = "markdown-unlit"; + }) {}; + "markdown2svg" = callPackage ({ mkDerivation, base, binary-file, Cabal, directory, filepath , markdown-pap, monads-tf, papillon, png-file, yjsvg @@ -191207,6 +190196,8 @@ self: { ]; description = "A ContT-based wrapper for Haskell-to-C marshalling functions"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "marvin" = callPackage @@ -191540,6 +190531,8 @@ self: { ]; description = "A composable abstraction for checking or converting a context value"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "matchers" = callPackage @@ -191649,6 +190642,8 @@ self: { testHaskellDepends = [ base hspec mtl QuickCheck text ]; description = "A library for formulating and solving math programs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "math-programming-glpk" = callPackage @@ -191667,6 +190662,7 @@ self: { ]; description = "A GLPK backend to the math-programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "math-programming-tests" = callPackage @@ -191684,6 +190680,7 @@ self: { ]; description = "Utility functions for testing implementations of the math-programming library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mathblog" = callPackage @@ -191807,17 +190804,6 @@ self: { }) {}; "mathlist" = callPackage - ({ mkDerivation, base }: - mkDerivation { - pname = "mathlist"; - version = "0.1.0.4"; - sha256 = "1zcnjw96n76pfmz3jnci76abcxxb16ahzxlcll0sm2qgn604yk5a"; - libraryHaskellDepends = [ base ]; - description = "Math using lists, including FFT and Wavelet"; - license = lib.licenses.bsd3; - }) {}; - - "mathlist_0_2_0_0" = callPackage ({ mkDerivation, base }: mkDerivation { pname = "mathlist"; @@ -191826,7 +190812,6 @@ self: { libraryHaskellDepends = [ base ]; description = "Math using lists, including FFT and Wavelet"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "matlab" = callPackage @@ -191939,6 +190924,8 @@ self: { pname = "matrix-client"; version = "0.1.5.0"; sha256 = "0hmca0knk1z3zg6v7rqfr0019n76pdsr8xj9ndywjk4c733lxm18"; + revision = "1"; + editedCabalFile = "0l21qxzqg50hh6l8f4p7hpixn5iqiq7d2m4r58j8q80mrk1dx0jf"; libraryHaskellDepends = [ aeson aeson-casing base base64 bytestring containers exceptions hashable http-client http-client-tls http-types network-uri @@ -192109,8 +191096,8 @@ self: { }: mkDerivation { pname = "matterhorn"; - version = "50200.18.0"; - sha256 = "06dig3jj9q6wfc0phxxskqkkzvh4d7xarvp8m6l09nbph1v7ziwz"; + version = "50200.19.0"; + sha256 = "1rs1j8bqqiasmwv44mn1lpx14264rbvwp4lk04lgr9qbw07yih6j"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -192146,8 +191133,8 @@ self: { }: mkDerivation { pname = "mattermost-api"; - version = "50200.14.0"; - sha256 = "1yl9586x7r6jy5pkbagmxr105ilp26blrjl02gpzhh07ppyah6nf"; + version = "50200.15.0"; + sha256 = "02hg12mwd6511bkgckxdfs01vxxmhyvvd2rh84q708cnwsv8haaz"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -192171,8 +191158,8 @@ self: { }: mkDerivation { pname = "mattermost-api-qc"; - version = "50200.14.0"; - sha256 = "03px6qxy9aqc7nmzy6jdh09q6k4nznr2alggd0c5c4s1f2yliknv"; + version = "50200.15.0"; + sha256 = "1nd0k8b060ihpz53ln4dmslsfvl74vcd47zdfrqnk2a81y62p55i"; libraryHaskellDepends = [ base containers mattermost-api QuickCheck text time ]; @@ -192376,8 +191363,8 @@ self: { pname = "mbox-utility"; version = "0.0.3.1"; sha256 = "0vh9ibh4g3fssq9jfzrmaa56sk4k35r27lmz2xq4fhc62fmkia92"; - revision = "1"; - editedCabalFile = "1q2kplw6pkakls161hzpjwrd34k0xsv2flcdjmsrd0py45cdavhz"; + revision = "2"; + editedCabalFile = "185nnlv14ff0rmjbz5n4alrkgx376iy61wjyjhg0wdlagxa91z71"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -192406,6 +191393,8 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Haskell MBTiles client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mbug" = callPackage @@ -192613,6 +191602,8 @@ self: { ]; description = "MD5 Hash"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mdapi" = callPackage @@ -192728,6 +191719,8 @@ self: { ]; description = "Mealy machines for processing time-series and ordered data"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "means" = callPackage @@ -192803,6 +191796,8 @@ self: { pname = "med-module"; version = "0.1.3"; sha256 = "04p1aj85hsr3wpnnfg4nxbqsgq41ga63mrg2w39d8ls8ljvajvna"; + revision = "1"; + editedCabalFile = "0m69cvm2nzx2g0y8jfkymap529fm0k65wg82dycj0dc60p9fj66r"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -193041,25 +192036,6 @@ self: { }) {}; "mega-sdist" = callPackage - ({ mkDerivation, aeson, base, bytestring, optparse-simple, pantry - , path, path-io, rio, rio-orphans, yaml - }: - mkDerivation { - pname = "mega-sdist"; - version = "0.4.2.1"; - sha256 = "00c1cc2cgwr6p01xc8sf570aly5hw6p932anjjra7rw7a3mcmc96"; - isLibrary = false; - isExecutable = true; - executableHaskellDepends = [ - aeson base bytestring optparse-simple pantry path path-io rio - rio-orphans yaml - ]; - description = "Handles uploading to Hackage from mega repos"; - license = lib.licenses.mit; - mainProgram = "mega-sdist"; - }) {}; - - "mega-sdist_0_4_3_0" = callPackage ({ mkDerivation, aeson, base, bytestring, optparse-simple, pantry , path, path-io, rio, rio-orphans, yaml }: @@ -193075,7 +192051,6 @@ self: { ]; description = "Handles uploading to Hackage from mega repos"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "mega-sdist"; }) {}; @@ -193099,8 +192074,8 @@ self: { }: mkDerivation { pname = "megaparsec"; - version = "9.2.2"; - sha256 = "0d52dbcz9nlqkkfqfs9kck5kmvkfzf3628z4ik4gr7hbbkjh72x4"; + version = "9.3.1"; + sha256 = "00dp79sssb2j9w0sbzphkqjn49xzrafd16gkqda5ngqhbjdniw73"; libraryHaskellDepends = [ base bytestring case-insensitive containers deepseq mtl parser-combinators scientific text transformers @@ -193136,13 +192111,13 @@ self: { "megaparsec-tests" = callPackage ({ mkDerivation, base, bytestring, case-insensitive, containers , hspec, hspec-discover, hspec-expectations, hspec-megaparsec - , megaparsec, mtl, parser-combinators, QuickCheck, scientific, text - , transformers + , megaparsec, mtl, parser-combinators, QuickCheck, scientific + , temporary, text, transformers }: mkDerivation { pname = "megaparsec-tests"; - version = "9.2.2"; - sha256 = "0jfzd5asm1lci78mc5sxymihmbjj9yxqx2952arxjw32psr6bpgz"; + version = "9.3.1"; + sha256 = "01gd6xlqfazpbawzwgbk0ag86dq8nv5qdrhny9b7hrks3i3b558m"; libraryHaskellDepends = [ base bytestring containers hspec hspec-expectations hspec-megaparsec megaparsec mtl QuickCheck text transformers @@ -193150,7 +192125,8 @@ self: { testHaskellDepends = [ base bytestring case-insensitive containers hspec hspec-expectations hspec-megaparsec megaparsec mtl - parser-combinators QuickCheck scientific text transformers + parser-combinators QuickCheck scientific temporary text + transformers ]; testToolDepends = [ hspec-discover ]; description = "Test utilities and the test suite of Megaparsec"; @@ -193657,24 +192633,6 @@ self: { }) {}; "memory" = callPackage - ({ mkDerivation, base, basement, bytestring, deepseq, foundation - , ghc-prim - }: - mkDerivation { - pname = "memory"; - version = "0.17.0"; - sha256 = "0yl3ivvn7i9wbx910b7bzj9c3g0jjjk91j05wj74qb5zx2yyf9rk"; - revision = "1"; - editedCabalFile = "1gybf726kz17jm1am0rphi0srmyqyza45y6jdqbq0b8sspm8kggb"; - libraryHaskellDepends = [ - base basement bytestring deepseq ghc-prim - ]; - testHaskellDepends = [ base basement bytestring foundation ]; - description = "memory and related abstraction stuff"; - license = lib.licenses.bsd3; - }) {}; - - "memory_0_18_0" = callPackage ({ mkDerivation, base, basement, bytestring, deepseq, foundation , ghc-prim }: @@ -193688,7 +192646,6 @@ self: { testHaskellDepends = [ base basement bytestring foundation ]; description = "memory and related abstraction stuff"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "memory-cd" = callPackage @@ -193709,6 +192666,7 @@ self: { ]; description = "memory and related abstraction stuff"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "memory-hexstring" = callPackage @@ -194497,10 +193455,8 @@ self: { }: mkDerivation { pname = "mfsolve"; - version = "0.3.2.1"; - sha256 = "190dszcnvy5j5bs3n0kya8a9nq0vdhrpgpndjpsxw7x70y3hc9d2"; - revision = "1"; - editedCabalFile = "0938ji6l1bx787lxcw6rzjwskm9vxm615cvx7hxpbwp0hbxrj5sa"; + version = "0.3.2.2"; + sha256 = "10cg30xg0d4d2dnfrgrg3bwd16zy9jsyy8wdbhsmjzhf149f6gq9"; libraryHaskellDepends = [ base hashable mtl mtl-compat unordered-containers ]; @@ -194617,8 +193573,8 @@ self: { pname = "microaeson"; version = "0.1.0.1"; sha256 = "0rx5gm7apazc0sm65v687ab5106ximka9khizxq1lbckd2x0cq3q"; - revision = "3"; - editedCabalFile = "12grcl9hpw3585k6h2rswgj4phfpqb3i1ygk2jympsngyqq5kvjf"; + revision = "5"; + editedCabalFile = "0ri4hmai3g1xn8vmmvvfbvvbgm0wjiwwjbp3ympidrkpnz9b9rq6"; libraryHaskellDepends = [ array base bytestring containers deepseq fail text ]; @@ -194736,17 +193692,6 @@ self: { }) {}; "microlens" = callPackage - ({ mkDerivation, base }: - mkDerivation { - pname = "microlens"; - version = "0.4.12.0"; - sha256 = "10q7gl9yavcln58sxdxzih7ff0ixxq5hpd87icvxw97yqf1p6hmm"; - libraryHaskellDepends = [ base ]; - description = "A tiny lens library with no dependencies"; - license = lib.licenses.bsd3; - }) {}; - - "microlens_0_4_13_1" = callPackage ({ mkDerivation, base }: mkDerivation { pname = "microlens"; @@ -194755,7 +193700,6 @@ self: { libraryHaskellDepends = [ base ]; description = "A tiny lens library with no dependencies"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "microlens-aeson" = callPackage @@ -194803,21 +193747,6 @@ self: { }) {}; "microlens-ghc" = callPackage - ({ mkDerivation, array, base, bytestring, containers, microlens - , transformers - }: - mkDerivation { - pname = "microlens-ghc"; - version = "0.4.13.2"; - sha256 = "1258p84jj4kv6l71ijwjzpvzvqxxsqbvs5vrksi24mlf29gaxqi0"; - libraryHaskellDepends = [ - array base bytestring containers microlens transformers - ]; - description = "microlens + array, bytestring, containers, transformers"; - license = lib.licenses.bsd3; - }) {}; - - "microlens-ghc_0_4_14_1" = callPackage ({ mkDerivation, array, base, bytestring, containers, microlens , transformers }: @@ -194830,7 +193759,6 @@ self: { ]; description = "microlens + array, bytestring, containers, transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "microlens-mtl" = callPackage @@ -194849,22 +193777,6 @@ self: { }) {}; "microlens-platform" = callPackage - ({ mkDerivation, base, hashable, microlens, microlens-ghc - , microlens-mtl, microlens-th, text, unordered-containers, vector - }: - mkDerivation { - pname = "microlens-platform"; - version = "0.4.2.1"; - sha256 = "0z8snyzy18kqj32fb89mzgscjrg6w2z0jkkj4b9vl2jvbps0gkg6"; - libraryHaskellDepends = [ - base hashable microlens microlens-ghc microlens-mtl microlens-th - text unordered-containers vector - ]; - description = "microlens + all batteries included (best for apps)"; - license = lib.licenses.bsd3; - }) {}; - - "microlens-platform_0_4_3_3" = callPackage ({ mkDerivation, base, hashable, microlens, microlens-ghc , microlens-mtl, microlens-th, text, unordered-containers, vector }: @@ -194878,7 +193790,6 @@ self: { ]; description = "microlens + all batteries included (best for apps)"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "microlens-process" = callPackage @@ -194896,6 +193807,8 @@ self: { testHaskellDepends = [ base doctest microlens process ]; description = "Micro-optics for the process library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "microlens-th" = callPackage @@ -194973,8 +193886,8 @@ self: { pname = "microstache"; version = "1.0.2.3"; sha256 = "16nj6ss8nmxd0z8lc2a9zpawgvi4kbd5wyjy17xknq43awbi6ynz"; - revision = "1"; - editedCabalFile = "04chnz0dcf30a5x90kwqdiad1qbyimmiqgbm38b6m3w72k408hfi"; + revision = "2"; + editedCabalFile = "0rafypnzzxmxhbc3lyd8ylyfrygijipbgh267slzkwfa8hikd0nz"; libraryHaskellDepends = [ aeson base containers deepseq directory filepath parsec text transformers unordered-containers vector @@ -195052,6 +193965,8 @@ self: { pname = "midi"; version = "0.2.2.4"; sha256 = "14dv5ihlk5jqmvd3b0wfk4nzk4phan5gx6fmvq616mrp6dsflx58"; + revision = "1"; + editedCabalFile = "086fhjrg3abwnxqwngfyw5paw4jszx5q9mxym5q7x9yqy4dl64j0"; libraryHaskellDepends = [ base binary bytestring event-list explicit-exception monoid-transformer non-negative QuickCheck random semigroups @@ -195530,17 +194445,6 @@ self: { }) {}; "mime-types" = callPackage - ({ mkDerivation, base, bytestring, containers, text }: - mkDerivation { - pname = "mime-types"; - version = "0.1.0.9"; - sha256 = "1lkipa4v73z3l5lqs6sdhl898iq41kyxv2jb9agsajzgd58l6cha"; - libraryHaskellDepends = [ base bytestring containers text ]; - description = "Basic mime-type handling types and functions"; - license = lib.licenses.mit; - }) {}; - - "mime-types_0_1_1_0" = callPackage ({ mkDerivation, base, bytestring, containers, text }: mkDerivation { pname = "mime-types"; @@ -195549,7 +194453,6 @@ self: { libraryHaskellDepends = [ base bytestring containers text ]; description = "Basic mime-type handling types and functions"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "min-max-pqueue" = callPackage @@ -195822,43 +194725,6 @@ self: { }) {}; "minio-hs" = callPackage - ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring - , case-insensitive, conduit, conduit-extra, connection, cryptonite - , cryptonite-conduit, digest, directory, exceptions, filepath - , http-client, http-client-tls, http-conduit, http-types, ini - , memory, network-uri, QuickCheck, raw-strings-qq, relude - , resourcet, retry, tasty, tasty-hunit, tasty-quickcheck - , tasty-smallcheck, text, time, transformers, unliftio - , unliftio-core, unordered-containers, xml-conduit - }: - mkDerivation { - pname = "minio-hs"; - version = "1.6.0"; - sha256 = "1pf1m02iz7lw4k53dac2rqnv84fcwcvx690y65h1mh2ip31abkp7"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base base64-bytestring binary bytestring case-insensitive - conduit conduit-extra connection cryptonite cryptonite-conduit - digest directory exceptions filepath http-client http-client-tls - http-conduit http-types ini memory network-uri raw-strings-qq - relude resourcet retry text time transformers unliftio - unliftio-core unordered-containers xml-conduit - ]; - testHaskellDepends = [ - aeson base base64-bytestring binary bytestring case-insensitive - conduit conduit-extra connection cryptonite cryptonite-conduit - digest directory exceptions filepath http-client http-client-tls - http-conduit http-types ini memory network-uri QuickCheck - raw-strings-qq relude resourcet retry tasty tasty-hunit - tasty-quickcheck tasty-smallcheck text time transformers unliftio - unliftio-core unordered-containers xml-conduit - ]; - description = "A MinIO Haskell Library for Amazon S3 compatible cloud storage"; - license = lib.licenses.asl20; - }) {}; - - "minio-hs_1_7_0" = callPackage ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring , case-insensitive, conduit, conduit-extra, connection, cryptonite , cryptonite-conduit, digest, directory, filepath, http-client @@ -195893,7 +194759,6 @@ self: { ]; description = "A MinIO Haskell Library for Amazon S3 compatible cloud storage"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "minions" = callPackage @@ -196215,6 +195080,7 @@ self: { testHaskellDepends = [ base hedgehog mismi-p text ]; description = "AWS Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "mismi-p" = callPackage @@ -196228,6 +195094,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "A commmon prelude for the mismi project"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "mismi-s3" = callPackage @@ -197074,6 +195942,28 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "mmzk-typeid" = callPackage + ({ mkDerivation, aeson, array, base, binary, bytestring, containers + , entropy, hashable, hspec, text, time, uuid-types + }: + mkDerivation { + pname = "mmzk-typeid"; + version = "0.3.1.0"; + sha256 = "08w1q8nrkb8rywzc3mkfjmwik4l4zw96vigjlr4znfz4ad40642y"; + libraryHaskellDepends = [ + aeson array base binary bytestring entropy hashable text time + uuid-types + ]; + testHaskellDepends = [ + aeson array base binary bytestring containers entropy hashable + hspec text time uuid-types + ]; + description = "A TypeID implementation for Haskell"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "mnist-idx" = callPackage ({ mkDerivation, base, binary, bytestring, directory, hspec , QuickCheck, vector @@ -197209,7 +196099,7 @@ self: { license = lib.licenses.mit; }) {}; - "mod" = callPackage + "mod_0_1_2_2" = callPackage ({ mkDerivation, base, deepseq, integer-gmp, primitive , quickcheck-classes, quickcheck-classes-base, semirings, tasty , tasty-bench, tasty-quickcheck, vector @@ -197228,9 +196118,10 @@ self: { benchmarkHaskellDepends = [ base tasty-bench ]; description = "Fast type-safe modular arithmetic"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; - "mod_0_2_0_1" = callPackage + "mod" = callPackage ({ mkDerivation, base, containers, deepseq, ghc-bignum, primitive , quickcheck-classes, quickcheck-classes-base, semirings, tasty , tasty-bench, tasty-quickcheck, vector @@ -197249,7 +196140,6 @@ self: { benchmarkHaskellDepends = [ base tasty-bench ]; description = "Fast type-safe modular arithmetic"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "modbus-tcp" = callPackage @@ -197706,17 +196596,17 @@ self: { "monad-bayes" = callPackage ({ mkDerivation, abstract-par, base, brick, containers, criterion - , foldl, free, histogram-fill, hspec, ieee754, integration, lens - , linear, log-domain, math-functions, matrix, monad-coroutine - , monad-extras, mtl, mwc-random, optparse-applicative, pipes - , pretty-simple, primitive, process, profunctors, QuickCheck - , random, safe, scientific, statistics, text, time, transformers - , typed-process, vector, vty + , directory, foldl, free, histogram-fill, hspec, ieee754 + , integration, lens, linear, log-domain, math-functions, matrix + , monad-coroutine, monad-extras, mtl, mwc-random + , optparse-applicative, pipes, pretty-simple, primitive, process + , QuickCheck, random, safe, scientific, statistics, text, time + , transformers, typed-process, vector, vty }: mkDerivation { pname = "monad-bayes"; - version = "1.1.0"; - sha256 = "0zpgmai2wh8iqdg8ds9y1928fsila80dhpidgz4hp0jkxkk988gh"; + version = "1.1.1"; + sha256 = "13y8s9dargzd5vy6m36dq2pnr23fibnx6r19iz414qsdbizp3196"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -197726,17 +196616,28 @@ self: { safe scientific statistics text vector vty ]; executableHaskellDepends = [ - base containers log-domain math-functions mwc-random - optparse-applicative pipes pretty-simple random text time vector + abstract-par base brick containers criterion directory foldl free + histogram-fill hspec ieee754 integration lens linear log-domain + math-functions matrix monad-coroutine monad-extras mtl mwc-random + optparse-applicative pipes pretty-simple primitive process + QuickCheck random safe scientific statistics text time transformers + typed-process vector vty ]; testHaskellDepends = [ - base containers foldl hspec ieee754 lens linear log-domain - math-functions matrix mtl mwc-random pipes pretty-simple - profunctors QuickCheck random statistics text transformers vector + abstract-par base brick containers criterion directory foldl free + histogram-fill hspec ieee754 integration lens linear log-domain + math-functions matrix monad-coroutine monad-extras mtl mwc-random + optparse-applicative pipes pretty-simple primitive process + QuickCheck random safe scientific statistics text time transformers + typed-process vector vty ]; benchmarkHaskellDepends = [ - abstract-par base containers criterion log-domain mwc-random pipes - pretty-simple process random text typed-process vector + abstract-par base brick containers criterion directory foldl free + histogram-fill hspec ieee754 integration lens linear log-domain + math-functions matrix monad-coroutine monad-extras mtl mwc-random + optparse-applicative pipes pretty-simple primitive process + QuickCheck random safe scientific statistics text time transformers + typed-process vector vty ]; description = "A library for probabilistic programming"; license = lib.licenses.mit; @@ -198204,8 +197105,8 @@ self: { }: mkDerivation { pname = "monad-logger-aeson"; - version = "0.4.0.4"; - sha256 = "01klhx1zizf9f5cn42n0zhsspgfiqg2vi6bdd5sliyfn38z1fhrn"; + version = "0.4.1.1"; + sha256 = "17kz1qbf5n1sdznsyvk3lfc7w6sad5b32143w3kr2gni3p0ms3ln"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -198289,6 +197190,8 @@ self: { benchmarkHaskellDepends = [ base criterion monad-logger ]; description = "Add prefixes to your monad-logger output"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-logger-syslog" = callPackage @@ -198424,6 +197327,8 @@ self: { testHaskellDepends = [ base ]; description = "A convenient wrapper around EKG metrics"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-metrics-extensible" = callPackage @@ -198689,12 +197594,12 @@ self: { }: mkDerivation { pname = "monad-schedule"; - version = "0.1.2.0"; - sha256 = "1crzah9arrr0c3zmld66r20w3jvd5gcblq9d3my784z9sh8cqwz3"; + version = "0.1.2.1"; + sha256 = "0fmqagy04p032f77q3lyzn8qqf3rr41id9ck5fr9308zvir338fg"; libraryHaskellDepends = [ base free stm time-domain transformers ]; testHaskellDepends = [ - base free HUnit QuickCheck test-framework test-framework-hunit - test-framework-quickcheck2 transformers + base free HUnit QuickCheck stm test-framework test-framework-hunit + test-framework-quickcheck2 time-domain transformers ]; description = "A new, simple, composable concurrency abstraction"; license = lib.licenses.mit; @@ -198710,6 +197615,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Monads of program skeleta"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "monad-st" = callPackage @@ -198854,18 +197761,6 @@ self: { }) {}; "monad-time" = callPackage - ({ mkDerivation, base, mtl, time }: - mkDerivation { - pname = "monad-time"; - version = "0.3.1.0"; - sha256 = "0z30c0k5bqlz86vwajnm6kj26i09zx6dzqwd00z6ba8hqyzm1x0a"; - libraryHaskellDepends = [ base mtl time ]; - testHaskellDepends = [ base mtl time ]; - description = "Type class for monads which carry the notion of the current time"; - license = lib.licenses.bsd3; - }) {}; - - "monad-time_0_4_0_0" = callPackage ({ mkDerivation, base, mtl, time }: mkDerivation { pname = "monad-time"; @@ -198875,7 +197770,6 @@ self: { testHaskellDepends = [ base mtl time ]; description = "Type class for monads which carry the notion of the current time"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "monad-time-effectful" = callPackage @@ -199137,8 +198031,8 @@ self: { }: mkDerivation { pname = "monadic-bang"; - version = "0.1.0.0"; - sha256 = "0wflx8vlwa5rxa94g40rsn8bwncnwvkbf5iagbhf74mjjdnrc17c"; + version = "0.1.1.0"; + sha256 = "143xi2yav13n28zppfrlk8xllm56ciw0lghbbdnafkf208szv91c"; libraryHaskellDepends = [ base containers fused-effects ghc transformers ]; @@ -199347,6 +198241,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "monads-tf_0_3_0_1" = callPackage + ({ mkDerivation, base, transformers }: + mkDerivation { + pname = "monads-tf"; + version = "0.3.0.1"; + sha256 = "00jzz9lqpz3s5xwvmc5xi300jkkjv9bk62k0jgwnqfv6py9x5g11"; + libraryHaskellDepends = [ base transformers ]; + description = "Monad classes, using type families"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "monadtransform" = callPackage ({ mkDerivation, base, transformers }: mkDerivation { @@ -199597,23 +198503,6 @@ self: { }) {}; "mono-traversable-keys" = callPackage - ({ mkDerivation, base, bytestring, containers, hashable, keys - , mono-traversable, text, transformers, unordered-containers - , vector, vector-instances - }: - mkDerivation { - pname = "mono-traversable-keys"; - version = "0.2.0"; - sha256 = "0v0bh73l6fa3bvyfakm2sbp9qi7bd8aw468kr8d51zsl8r0b6nil"; - libraryHaskellDepends = [ - base bytestring containers hashable keys mono-traversable text - transformers unordered-containers vector vector-instances - ]; - description = "Type-classes for interacting with monomorphic containers with a key"; - license = lib.licenses.bsd3; - }) {}; - - "mono-traversable-keys_0_3_0" = callPackage ({ mkDerivation, base, bytestring, containers, hashable, keys , mono-traversable, text, transformers, unordered-containers , vector, vector-instances @@ -199628,7 +198517,6 @@ self: { ]; description = "Type-classes for interacting with monomorphic containers with a key"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "mono-traversable-wrapper" = callPackage @@ -199705,6 +198593,8 @@ self: { pname = "monoid-map"; version = "0.2.0.0"; sha256 = "0mmz57l0yfkdk3psaxyavs2v5hs860ja5a0wk08n2zar3br4fa2l"; + revision = "1"; + editedCabalFile = "1whwicn2wln97xa0zilh7aqjz132qlb1jhzjf6vrcv3ad9kk4b89"; libraryHaskellDepends = [ base commutative-semigroups monoidal-containers patch reflex witherable @@ -199739,9 +198629,10 @@ self: { }) {}; "monoid-statistics" = callPackage - ({ mkDerivation, base, criterion, exceptions, math-functions - , mwc-random, QuickCheck, tasty, tasty-expected-failure - , tasty-hunit, tasty-quickcheck, vector, vector-th-unbox + ({ mkDerivation, base, criterion, doctest, exceptions + , math-functions, mwc-random, QuickCheck, tasty + , tasty-expected-failure, tasty-hunit, tasty-quickcheck, vector + , vector-th-unbox }: mkDerivation { pname = "monoid-statistics"; @@ -199751,7 +198642,7 @@ self: { base exceptions math-functions vector vector-th-unbox ]; testHaskellDepends = [ - base math-functions QuickCheck tasty tasty-expected-failure + base doctest math-functions QuickCheck tasty tasty-expected-failure tasty-hunit tasty-quickcheck ]; benchmarkHaskellDepends = [ @@ -199764,27 +198655,6 @@ self: { }) {}; "monoid-subclasses" = callPackage - ({ mkDerivation, base, bytestring, containers, primes, QuickCheck - , quickcheck-instances, tasty, tasty-quickcheck, text, vector - }: - mkDerivation { - pname = "monoid-subclasses"; - version = "1.1.3"; - sha256 = "1nglki10rlpi872p55pa8g809q5sna7yzh3zw4rqfhq89kb15wcv"; - revision = "1"; - editedCabalFile = "0y8sw3zsmz5ssn2gl2fsqg44n7xf3xsf6vhrzwnkbaa97hj76nh2"; - libraryHaskellDepends = [ - base bytestring containers primes text vector - ]; - testHaskellDepends = [ - base bytestring containers primes QuickCheck quickcheck-instances - tasty tasty-quickcheck text vector - ]; - description = "Subclasses of Monoid"; - license = lib.licenses.bsd3; - }) {}; - - "monoid-subclasses_1_2_3" = callPackage ({ mkDerivation, base, bytestring, commutative-semigroups , containers, primes, QuickCheck, quickcheck-instances, tasty , tasty-quickcheck, text, vector @@ -199803,7 +198673,6 @@ self: { ]; description = "Subclasses of Monoid"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "monoid-transformer" = callPackage @@ -199836,19 +198705,27 @@ self: { "monoidal-functors" = callPackage ({ mkDerivation, base, bifunctors, comonad, contravariant - , distributive, profunctors, semialign, semigroupoids, tagged - , these + , distributive, mtl, profunctors, semialign, semigroupoids, tagged + , these, transformers }: mkDerivation { pname = "monoidal-functors"; - version = "0.2.1.0"; - sha256 = "0fxbshb7ha6l872k77qiyv6k4056ihb8sjjgf767118azsmf130x"; + version = "0.2.2.0"; + sha256 = "1hc15igwwa177r1dkzv0h2zzjn1yf3s2zyl5vy6j71zzyzn3nwgb"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ - base bifunctors comonad contravariant distributive profunctors - semialign semigroupoids tagged these + base bifunctors comonad contravariant distributive mtl profunctors + semialign semigroupoids tagged these transformers + ]; + executableHaskellDepends = [ + base bifunctors contravariant distributive mtl ]; description = "Monoidal Functors Library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + mainProgram = "co-log"; + broken = true; }) {}; "monoidmap" = callPackage @@ -200000,6 +198877,7 @@ self: { description = "A datagrid widget for the Monomer library"; license = lib.licenses.mit; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; }) {}; "monomorphic" = callPackage @@ -200105,8 +198983,8 @@ self: { pname = "months"; version = "0.2"; sha256 = "054dag7806850hdii7s5rxg8gx2spdp33pnx4s4ckni9ayvspija"; - revision = "7"; - editedCabalFile = "0134xrfqbxzd0l09g12rmpcawjghl7yxpc3yzdxpdhakyvkw2s0b"; + revision = "8"; + editedCabalFile = "0xpid9mlk56c03axbqam9yws9g47rqbdils3zpqlc6pd4mrwb030"; libraryHaskellDepends = [ aeson attoparsec base base-compat deepseq hashable intervals QuickCheck text time-compat @@ -200302,38 +199180,36 @@ self: { , base58-bytestring, bimap, binary, bytestring, constraints , constraints-extras, containers, crypto-sodium, cryptonite , data-default, dependent-sum-template, Diff, elliptic-curve - , first-class-families, fmt, galois-field, generic-deriving, gitrev + , first-class-families, galois-field, generic-deriving, gitrev , haskeline, hex-text, hsblst, lens, megaparsec, memory , MonadRandom, morley-prelude, mtl, named, optparse-applicative - , pairing, parser-combinators, scientific, semigroups, show-type - , singletons, singletons-base, some, syb, template-haskell, text - , text-manipulate, th-lift-instances, th-reify-many, time, timerep - , type-errors, uncaught-exception, unordered-containers, vector - , vinyl, with-utf8, wl-pprint-text + , pairing, parser-combinators, prettyprinter, scientific + , semigroups, show-type, singletons, singletons-base, some, syb + , template-haskell, text, text-manipulate, th-lift-instances + , th-reify-many, time, timerep, type-errors, uncaught-exception + , unordered-containers, vector, vinyl, with-utf8 }: mkDerivation { pname = "morley"; - version = "1.19.1"; - sha256 = "030q46n5wzv9aiyj6lnljkbc009k2f9j41y9p1rfrgyqrhg1bln6"; + version = "1.19.2"; + sha256 = "04b7ldvqm4nxmzzbqykf72a7nnjlqhjbrhqsczz27nn84bjxmjql"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ aeson aeson-casing aeson-pretty base-noprelude base58-bytestring bimap binary bytestring constraints constraints-extras containers crypto-sodium cryptonite data-default dependent-sum-template Diff - elliptic-curve first-class-families fmt galois-field - generic-deriving gitrev hex-text hsblst lens megaparsec memory - MonadRandom morley-prelude mtl named optparse-applicative pairing - parser-combinators scientific semigroups show-type singletons - singletons-base some syb template-haskell text text-manipulate - th-lift-instances th-reify-many time timerep type-errors - uncaught-exception unordered-containers vector vinyl with-utf8 - wl-pprint-text + elliptic-curve first-class-families galois-field generic-deriving + gitrev haskeline hex-text hsblst lens megaparsec memory MonadRandom + morley-prelude mtl named optparse-applicative pairing + parser-combinators prettyprinter scientific semigroups show-type + singletons singletons-base some syb template-haskell text + text-manipulate th-lift-instances th-reify-many time timerep + type-errors uncaught-exception unordered-containers vector vinyl + with-utf8 ]; executableHaskellDepends = [ - aeson base-noprelude base58-bytestring bytestring data-default fmt - haskeline hex-text megaparsec MonadRandom morley-prelude named - optparse-applicative singletons text vinyl with-utf8 + base-noprelude morley-prelude optparse-applicative ]; description = "Developer tools for the Michelson Language"; license = lib.licenses.mit; @@ -200342,9 +199218,9 @@ self: { }) {}; "morley-client" = callPackage - ({ mkDerivation, aeson, aeson-casing, base-noprelude, binary + ({ mkDerivation, aeson, aeson-casing, base-noprelude, bimap, binary , bytestring, co-log, co-log-core, colourista, constraints - , containers, data-default, exceptions, fmt, hex-text + , containers, data-default, exceptions, hex-text , hspec-expectations, http-client, http-client-tls, http-types , HUnit, lens, lorentz, megaparsec, memory, morley, morley-prelude , mtl, optparse-applicative, process, random, safe-exceptions @@ -200354,24 +199230,23 @@ self: { }: mkDerivation { pname = "morley-client"; - version = "0.3.1"; - sha256 = "0m3a34bzyww2vxww6sc3l1s1kzbw41khss9mf47chirfvl1jhbaf"; + version = "0.3.2"; + sha256 = "0wallg3ryj9mq9z2qz7fxijh4phhjvi1rblmkjpqcxg3naypznn3"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson aeson-casing base-noprelude binary bytestring co-log - co-log-core colourista constraints containers data-default fmt - hex-text http-client http-client-tls http-types lens lorentz - megaparsec memory morley morley-prelude mtl optparse-applicative - process random scientific servant servant-client + aeson aeson-casing base-noprelude bimap binary bytestring co-log + co-log-core colourista constraints containers data-default hex-text + http-client http-client-tls http-types lens lorentz megaparsec + memory morley morley-prelude mtl optparse-applicative process + random safe-exceptions scientific servant servant-client servant-client-core singletons syb text time unliftio ]; executableHaskellDepends = [ - aeson base-noprelude data-default fmt morley morley-prelude - optparse-applicative safe-exceptions singletons + base-noprelude morley morley-prelude optparse-applicative ]; testHaskellDepends = [ - aeson base-noprelude bytestring co-log co-log-core exceptions fmt + aeson base-noprelude bytestring co-log co-log-core exceptions hex-text hspec-expectations http-types HUnit lens lorentz memory morley morley-prelude safe-exceptions servant-client-core singletons tasty tasty-ant-xml tasty-hunit-compat time @@ -200384,16 +199259,16 @@ self: { }) {}; "morley-prelude" = callPackage - ({ mkDerivation, base-noprelude, Cabal, fmt, int-cast, lens - , OddWord, template-haskell, time, universum + ({ mkDerivation, base-noprelude, bytestring, Cabal, int-cast, lens + , OddWord, prettyprinter, template-haskell, text, time, universum }: mkDerivation { pname = "morley-prelude"; - version = "0.5.2"; - sha256 = "0iir1l8h2agc78486p1gfk9m77nhyd5rdlm1znjj5ab85f5r4iy9"; + version = "0.5.3"; + sha256 = "104gffmi6knhzby3s2b8h6mwns5i5lm48915i0zc3839f1yg6dx0"; libraryHaskellDepends = [ - base-noprelude Cabal fmt int-cast lens OddWord template-haskell - time universum + base-noprelude bytestring Cabal int-cast lens OddWord prettyprinter + template-haskell text time universum ]; description = "A custom prelude used in Morley"; license = lib.licenses.mit; @@ -201600,23 +200475,65 @@ self: { broken = true; }) {}; + "ms-auth" = callPackage + ({ mkDerivation, aeson, base, bytestring, containers, directory + , hoauth2, http-client, http-types, jwt, scientific, scotty, text + , time, transformers, unliftio, uri-bytestring, validation-micro + }: + mkDerivation { + pname = "ms-auth"; + version = "0.3.0.0"; + sha256 = "0grvzd4mlz8fa1gyjil8jnjzdymq1iiz3qpmsrk7mavgbmrfndny"; + libraryHaskellDepends = [ + aeson base bytestring containers directory hoauth2 http-client + http-types jwt scientific scotty text time transformers unliftio + uri-bytestring validation-micro + ]; + description = "Microsoft Authentication API"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + + "ms-azure-api" = callPackage + ({ mkDerivation, aeson, base, bytestring, conduit, containers + , exceptions, hoauth2, http-client-tls, http-types, modern-uri, req + , scientific, text, time, transformers, unliftio, xeno, xmlbf + , xmlbf-xeno + }: + mkDerivation { + pname = "ms-azure-api"; + version = "0.4.0.0"; + sha256 = "0kda9lw77by7cdin7zk5rmv3n5a76dam0z6jjsnn94k7wm4h7mlg"; + libraryHaskellDepends = [ + aeson base bytestring conduit containers exceptions hoauth2 + http-client-tls http-types modern-uri req scientific text time + transformers unliftio xeno xmlbf xmlbf-xeno + ]; + description = "Microsoft Azure API"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "ms-graph-api" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, hoauth2 - , http-client, http-types, jwt, modern-uri, req, scientific, scotty - , text, time, transformers, unliftio, uri-bytestring - , validation-micro, wai, warp + , http-client, http-client-tls, http-types, modern-uri, req + , scientific, text, time, transformers, unliftio }: mkDerivation { pname = "ms-graph-api"; - version = "0.6.0.0"; - sha256 = "1wnl8kww7byzhyvswxf743cwnwmbg71vkck9rk5q82kdv7dxq8jc"; + version = "0.11.0.0"; + sha256 = "1jx2b8qr45xbb9zy8zfrxj7md1547jzndkwq597ya2jkz1cxpjcf"; libraryHaskellDepends = [ - aeson base bytestring containers hoauth2 http-client http-types jwt - modern-uri req scientific scotty text time transformers unliftio - uri-bytestring validation-micro wai warp + aeson base bytestring containers hoauth2 http-client + http-client-tls http-types modern-uri req scientific text time + transformers unliftio ]; description = "Microsoft Graph API"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ms-tds" = callPackage @@ -202694,6 +201611,8 @@ self: { testHaskellDepends = [ base hedgehog ]; description = "Typeclasses augmented with a phantom type parameter"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "multi-trie" = callPackage @@ -203323,6 +202242,25 @@ self: { broken = true; }) {Vector = null;}; + "multiwalk" = callPackage + ({ mkDerivation, base, bytestring, commonmark, commonmark-pandoc + , deepseq, pandoc-types, tasty, tasty-bench, tasty-hunit, text + , transformers + }: + mkDerivation { + pname = "multiwalk"; + version = "0.3.0.1"; + sha256 = "177kkl6vqav920wgy1w4srzjc73a95hm3qv3lz6v3b1h1z9bajgz"; + libraryHaskellDepends = [ base ]; + testHaskellDepends = [ base tasty tasty-hunit ]; + benchmarkHaskellDepends = [ + base bytestring commonmark commonmark-pandoc deepseq pandoc-types + tasty tasty-bench tasty-hunit text transformers + ]; + description = "Traverse data types via generics, acting on multiple types simultaneously"; + license = lib.licenses.gpl3Plus; + }) {}; + "muon" = callPackage ({ mkDerivation, base, blaze-html, ConfigFile, directory, Glob , happstack-server, HStringTemplate, markdown, MissingH, process @@ -205087,8 +204025,8 @@ self: { }: mkDerivation { pname = "named-text"; - version = "1.1.2.0"; - sha256 = "0yzz8vb4pjb177p3z3qr4rvn8nz5bdha0w7jmq1791g0g022jvqj"; + version = "1.1.3.0"; + sha256 = "0a0nnq5zhjnh8s5ykny4rvzck4s7n5vj82qwlww8jm3fnv4sj9ax"; libraryHaskellDepends = [ aeson base deepseq hashable prettyprinter sayable text ]; @@ -206689,8 +205627,8 @@ self: { pname = "netrc"; version = "0.2.0.0"; sha256 = "11iax3ick0im397jyyjkny7lax9bgrlgk90a25dp2jsglkphfpls"; - revision = "10"; - editedCabalFile = "1nfv0851h05h7g2fjz54z0myas9yfcnmcp9ncmzxnb3kdvvzbfgn"; + revision = "11"; + editedCabalFile = "1n9wdkb8vp2ja4myb5cxlk2chl51dv4wihp6sag1aapix8w8k90p"; libraryHaskellDepends = [ base bytestring deepseq parsec ]; testHaskellDepends = [ base bytestring tasty tasty-golden tasty-quickcheck @@ -206939,6 +205877,8 @@ self: { pname = "network"; version = "3.1.4.0"; sha256 = "13hmp4va00ydpzbnwjzgf5wd5iy7373j0f7baxrj1ncmmjps4lml"; + revision = "1"; + editedCabalFile = "1vwxy5zj4bizgg2g0hk3dy52kjh5d7lzn33lphmvbbs36aqcslp1"; libraryHaskellDepends = [ base bytestring deepseq directory ]; testHaskellDepends = [ base bytestring directory hspec HUnit QuickCheck temporary @@ -207650,12 +206590,12 @@ self: { }) {}; "network-run" = callPackage - ({ mkDerivation, base, bytestring, network }: + ({ mkDerivation, base, bytestring, network, time-manager }: mkDerivation { pname = "network-run"; - version = "0.2.5"; - sha256 = "08662w7ja9w4a4fwikaawxnxcszkd0mdmaajmshas2dd25xyikwi"; - libraryHaskellDepends = [ base bytestring network ]; + version = "0.2.6"; + sha256 = "0q3wr8zkccdfi6bfawrajhir1s2cl1knpy6pqg78kd0pvjai2j6a"; + libraryHaskellDepends = [ base bytestring network time-manager ]; description = "Simple network runner library"; license = lib.licenses.bsd3; }) {}; @@ -208666,8 +207606,8 @@ self: { ({ mkDerivation, base, Cabal, directory, filepath }: mkDerivation { pname = "ngx-export-distribution"; - version = "0.3.2.3"; - sha256 = "11p9c8x5shb3y01kp3gd454ik8jpkld9vbf0id42fajnxp9jyb2l"; + version = "0.3.2.4"; + sha256 = "1zmlpxl3g90wdqjzgzhhawvv3qhr9akf595fca1mnfd2fpxg6928"; libraryHaskellDepends = [ base Cabal directory filepath ]; description = "Build custom libraries for Nginx haskell module"; license = lib.licenses.bsd3; @@ -209240,7 +208180,9 @@ self: { ]; description = "A drop-in replacement for nix-serve that's faster and more stable"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "nix-serve"; + broken = true; }) {inherit (pkgs) nix;}; "nix-thunk" = callPackage @@ -210213,6 +209155,8 @@ self: { libraryHaskellDepends = [ base primitive vector ]; description = "Various iterative algorithms for optimization of nonlinear functions"; license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "nonlinear-optimization-ad" = callPackage @@ -210232,6 +209176,7 @@ self: { ]; description = "Wrapper of nonlinear-optimization package for using with AD package"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "nonlinear-optimization-backprop" = callPackage @@ -210303,6 +209248,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion deepseq ]; description = "Normalization insensitive string comparison"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "normalize" = callPackage @@ -210400,6 +209347,8 @@ self: { ]; description = "An opinionated Prelude replacement library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "notcpp" = callPackage @@ -211003,6 +209952,8 @@ self: { testHaskellDepends = [ base vector ]; description = "Multidimensional arrays, Linear algebra, Numerical analysis"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "null-canvas" = callPackage @@ -211118,6 +210069,8 @@ self: { benchmarkHaskellDepends = [ base tasty-bench ]; description = "Create number walls and save them as images"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numbered-semigroups" = callPackage @@ -211236,6 +210189,7 @@ self: { libraryHaskellDepends = [ base type-compare ]; description = "Type-level numeric types and classes"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "numeric-limits" = callPackage @@ -211300,19 +210254,20 @@ self: { "numeric-optimization" = callPackage ({ mkDerivation, base, constraints, containers, data-default-class - , hmatrix, hspec, HUnit, lbfgs, primitive, vector + , hmatrix, hspec, HUnit, lbfgs, numeric-limits, primitive, vector }: mkDerivation { pname = "numeric-optimization"; - version = "0.1.0.1"; - sha256 = "158ww5bnm2yblb3c8azd4cxb3vdc6ckkc3k0a5mdksr2d0lj1j20"; + version = "0.1.1.0"; + sha256 = "0qcrxrkcg70m6l2r7g1lhkajwllay6ky1h87fckzmc0li054idp8"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base constraints data-default-class hmatrix lbfgs primitive vector + base constraints data-default-class hmatrix lbfgs numeric-limits + primitive vector ]; testHaskellDepends = [ - base containers data-default-class hspec HUnit vector + base containers data-default-class hmatrix hspec HUnit vector ]; description = "Unified interface to various numerical optimization algorithms"; license = lib.licenses.bsd3; @@ -211612,6 +210567,8 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Numerical spaces"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "numhask-test" = callPackage @@ -211755,8 +210712,10 @@ self: { testToolDepends = [ hspec-discover ]; description = "Generate nix sources expr for the latest version of packages"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "nvfetcher"; maintainers = [ lib.maintainers.berberman ]; + broken = true; }) {}; "nvim-hs" = callPackage @@ -211878,8 +210837,8 @@ self: { }: mkDerivation { pname = "nyan-interpolation"; - version = "0.9.1"; - sha256 = "1rawvbfvciqg2cfk59sfhywcn51qbcxfipllr722ba0v6ldwaw8c"; + version = "0.9.2"; + sha256 = "1i4chj6alqpdx8225fw0npf992d20ipa99ja265v96inkyw8vivq"; libraryHaskellDepends = [ base fmt haskell-src-exts haskell-src-meta nyan-interpolation-core spoon template-haskell text @@ -211902,8 +210861,8 @@ self: { }: mkDerivation { pname = "nyan-interpolation-core"; - version = "0.9.1"; - sha256 = "1b92sbd0b97v7yryc9614k3b74jpyqlfxzrfbd6nxf0a044mhqps"; + version = "0.9.2"; + sha256 = "03mc447pamvzfkhnr7b06asm2kys0l0kh74qm34swr15ffyg125f"; libraryHaskellDepends = [ base fmt megaparsec mtl template-haskell text vector ]; @@ -211922,8 +210881,8 @@ self: { ({ mkDerivation, base, nyan-interpolation-core, text }: mkDerivation { pname = "nyan-interpolation-simple"; - version = "0.9.1"; - sha256 = "14d6lmqz3vb435czzhd4dlaw5rphwgcdd4q6fq3h877ngm3ypbck"; + version = "0.9.2"; + sha256 = "1mqxl9z1hgyfmh27agh8zyfrdncazqdnirdb2syixxwxwx775qbl"; libraryHaskellDepends = [ base nyan-interpolation-core text ]; description = "Simplified lightweight interpolation"; license = lib.licenses.mpl20; @@ -212280,6 +211239,7 @@ self: { ]; description = "Composable objects"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "oblivious-transfer" = callPackage @@ -212401,6 +211361,7 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "A module to manage payroll books for Japanese companies"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "octane" = callPackage @@ -212694,8 +211655,8 @@ self: { }: mkDerivation { pname = "ogma-cli"; - version = "1.0.9"; - sha256 = "1c2hg3wgx8jlrgch2mqasskjhx7d9b7ycixndp5rfls4jb94bipa"; + version = "1.0.10"; + sha256 = "0v5ax7xyl5hnq37h97cajg679xxvdv6z7mjwa2h0nj3g70wkxd9f"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ base ogma-core optparse-applicative ]; @@ -212717,8 +211678,8 @@ self: { }: mkDerivation { pname = "ogma-core"; - version = "1.0.9"; - sha256 = "0fl0wg9xxc9sjh10hx35qzs3mi9ql9m5cy4z1hvlm0kl4cz8ach1"; + version = "1.0.10"; + sha256 = "04kkk6r947dq7v23x95dp6kkp3adkynh6b23px3ij5g83k86kv2g"; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson base filepath IfElse mtl ogma-extra ogma-language-c @@ -212740,8 +211701,8 @@ self: { }: mkDerivation { pname = "ogma-extra"; - version = "1.0.9"; - sha256 = "14g55a7lyd363p06kvjnjj06rp4hn6plp23ivhsl829hs2rcpq1d"; + version = "1.0.10"; + sha256 = "0r2qlzs8dyxv9mvj7nr4akihxxx36bdlndp7x6fp848yasbik8bg"; libraryHaskellDepends = [ base bytestring Cabal directory filepath ]; @@ -212758,8 +211719,8 @@ self: { }: mkDerivation { pname = "ogma-language-c"; - version = "1.0.9"; - sha256 = "0flbxfpylbad4fvy12lxs7lhzd1bxv25gr2pi9ck3chgwyid39ff"; + version = "1.0.10"; + sha256 = "09yb37ccrg6wq7dflngfjnjwach3k633cw17il2vg6wh7r1b3ffw"; setupHaskellDepends = [ base BNFC Cabal process ]; libraryHaskellDepends = [ array base ]; testHaskellDepends = [ @@ -212777,8 +211738,8 @@ self: { }: mkDerivation { pname = "ogma-language-cocospec"; - version = "1.0.9"; - sha256 = "0a913c3xqznipkkybzym3dm5x915qa2ci6rzd4gb3rqk1f1wlhf2"; + version = "1.0.10"; + sha256 = "15hakc95xiy9yhzqm7hm5mrzxlam03g1a4rsppglv6zpn55764rb"; setupHaskellDepends = [ base BNFC Cabal process ]; libraryHaskellDepends = [ array base ]; testHaskellDepends = [ @@ -212794,8 +211755,8 @@ self: { ({ mkDerivation, base }: mkDerivation { pname = "ogma-language-copilot"; - version = "1.0.9"; - sha256 = "007psfn5r8d1fgrpx1h65a2qwh6w4hh9ym1hwip5f1c7yvlrf9sk"; + version = "1.0.10"; + sha256 = "1m6bbxkdxk7p20vb47abb796cx9qb3s87g9rjady9bncyyz0f199"; libraryHaskellDepends = [ base ]; description = "Ogma: Runtime Monitor translator: Copilot Language Endpoints"; license = "unknown"; @@ -212808,8 +211769,8 @@ self: { }: mkDerivation { pname = "ogma-language-fret-cs"; - version = "1.0.9"; - sha256 = "1gr38xg0y4bcg8yyk70bnx3d9qd8vigf43h6b8d415p363kwzkjw"; + version = "1.0.10"; + sha256 = "0lvh0cvn2m47pv87hv5ad2s5s1qfr2aii2zn53xlra5jm2ilmjav"; libraryHaskellDepends = [ aeson base ogma-language-cocospec ogma-language-smv ]; @@ -212829,8 +211790,8 @@ self: { }: mkDerivation { pname = "ogma-language-fret-reqs"; - version = "1.0.9"; - sha256 = "1n3y57zhq2qyy3bplkk1x6b9vgmxdnvsdcflnzv8wywl4v1bbb7a"; + version = "1.0.10"; + sha256 = "1ryqnhfpvpigmfyidrfql54pj5z3633iddlnnvn9q6qgpch4a4s0"; libraryHaskellDepends = [ aeson base ogma-language-cocospec ogma-language-smv text ]; @@ -212849,8 +211810,8 @@ self: { }: mkDerivation { pname = "ogma-language-smv"; - version = "1.0.9"; - sha256 = "151s4hvczr8kjfn5pq4h34hi0qqxlac2biinp29qx15pzh4ayijy"; + version = "1.0.10"; + sha256 = "0n56k5f1gbk345qxdd9wjv3n4w0za05zg00xvqdmc3lmpdn31g9k"; setupHaskellDepends = [ base BNFC Cabal process ]; libraryHaskellDepends = [ array base ]; testHaskellDepends = [ @@ -213126,8 +212087,8 @@ self: { }: mkDerivation { pname = "om-fork"; - version = "0.7.1.7"; - sha256 = "1fpgyh44had11yxarhdavscf12693kgal0js9j3mdj8115dv53nz"; + version = "0.7.1.8"; + sha256 = "1pam9jlm8c8pkljzh4b0js1p3yrp4xdwwxicy49dx33asjdxcm4h"; libraryHaskellDepends = [ aeson base exceptions ki monad-logger om-show text unliftio ]; @@ -213268,8 +212229,8 @@ self: { ({ mkDerivation, aeson, base, text }: mkDerivation { pname = "om-show"; - version = "0.1.2.6"; - sha256 = "1gkila7rbr2a3ijhaaia9q25113by387y30z3fnppvh5mgf5hlpz"; + version = "0.1.2.8"; + sha256 = "0j80r7cmf2rrml39mpm1vg2jsv1mkhqin1c1qxa127nxbm3zainc"; libraryHaskellDepends = [ aeson base text ]; description = "Utilities for showing string-like things"; license = lib.licenses.mit; @@ -213306,8 +212267,8 @@ self: { ({ mkDerivation, aeson, base, binary, clock, time, transformers }: mkDerivation { pname = "om-time"; - version = "0.3.0.2"; - sha256 = "1c33cbwby71yqn0z13hywsc749401jcqx0rwfb4s5wrcqc4n7461"; + version = "0.3.0.3"; + sha256 = "1fwifq0jsvmj339wmldah9cpb8yvn92f9d7illzi39zq1mvzw9ab"; libraryHaskellDepends = [ aeson base binary clock time transformers ]; @@ -213741,6 +212702,8 @@ self: { pname = "opaleye"; version = "0.9.7.0"; sha256 = "1njmns4myrjyfbmd4qrkrwqp6jyaridxkf4n0n8bgw3z5hr64jhv"; + revision = "1"; + editedCabalFile = "10yd5y3g4v1zmj52vflw6gbaqnmsfydb32sni5mbh7mwnp5d8z0k"; libraryHaskellDepends = [ aeson base base16-bytestring bytestring case-insensitive contravariant postgresql-simple pretty product-profunctors @@ -213758,6 +212721,38 @@ self: { license = lib.licenses.bsd3; }) {}; + "opaleye_0_10_0_0" = callPackage + ({ mkDerivation, aeson, base, base16-bytestring, bytestring + , case-insensitive, containers, contravariant, dotenv, hspec + , hspec-discover, multiset, postgresql-simple, pretty + , product-profunctors, profunctors, QuickCheck, scientific + , semigroups, text, time, time-compat, time-locale-compat + , transformers, uuid, void + }: + mkDerivation { + pname = "opaleye"; + version = "0.10.0.0"; + sha256 = "0x181722a8ml9a6nbcj5v9q8npjkc22qrahqkfrfrh69hb0zpqp4"; + revision = "1"; + editedCabalFile = "1a2rzhmm85dmip4rjrbhagwhsrdg9wdsm8a1fp4dpjknjavpjn96"; + libraryHaskellDepends = [ + aeson base base16-bytestring bytestring case-insensitive + contravariant postgresql-simple pretty product-profunctors + profunctors scientific semigroups text time-compat + time-locale-compat transformers uuid void + ]; + testHaskellDepends = [ + aeson base bytestring containers contravariant dotenv hspec + hspec-discover multiset postgresql-simple product-profunctors + profunctors QuickCheck semigroups text time time-compat + transformers uuid + ]; + testToolDepends = [ hspec-discover ]; + description = "An SQL-generating DSL targeting PostgreSQL"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "opaleye-classy" = callPackage ({ mkDerivation, base, bytestring, lens, mtl, opaleye , postgresql-simple, product-profunctors, transformers @@ -214035,21 +213030,19 @@ self: { }: mkDerivation { pname = "openai-hs"; - version = "0.3.0.0"; - sha256 = "0mimxdmfsfnplsnihyavv6cf07hz0nxryikff3xidd4ac4lfr87b"; + version = "0.3.0.1"; + sha256 = "0aicqx84q53fqm5f401irrlfmh5sxpcfm1khslpjzd5siqzasy67"; libraryHaskellDepends = [ aeson base bytestring casing cpphs http-client http-types openai-servant servant servant-auth-client servant-client servant-multipart-client text ]; - libraryToolDepends = [ cpphs ]; testHaskellDepends = [ aeson base bytestring casing containers cpphs hspec http-client http-client-tls http-types openai-servant servant servant-auth-client servant-client servant-client-core servant-multipart-client text vector ]; - testToolDepends = [ cpphs ]; description = "Unofficial OpenAI client"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -214063,8 +213056,8 @@ self: { }: mkDerivation { pname = "openai-servant"; - version = "0.3.0.0"; - sha256 = "1ilmfaj465ly9fjcgmp1nwd08n0p35sg9jgidw5qvyl4s60j7br2"; + version = "0.3.0.1"; + sha256 = "1w1id2c7hzhycy26lp2zdhg8vnzkh28wy7qjq75434p5c4l5wx64"; libraryHaskellDepends = [ aeson base bytestring casing mime-types servant servant-auth servant-auth-client servant-multipart-api text time vector @@ -214149,8 +213142,8 @@ self: { pname = "openapi3"; version = "3.2.3"; sha256 = "0svkzafxfmhjakv4h57p5sw59ksbxz1hn1y3fbg6zimwal4mgr6l"; - revision = "3"; - editedCabalFile = "1cp12nvndc2hpgjxv2j8p0nhrii9hawjsgph6yrcg88ckihy7zaz"; + revision = "4"; + editedCabalFile = "1wpdmp3xp948052y325h64smp6l809r8mcvh220bfbrb4vrbk43b"; isLibrary = true; isExecutable = true; setupHaskellDepends = [ base Cabal cabal-doctest ]; @@ -215070,6 +214063,8 @@ self: { ]; description = "OpenTracing for Haskell"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "opentracing-http-client" = callPackage @@ -215083,6 +214078,7 @@ self: { ]; description = "OpenTracing instrumentation of http-client"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentracing-jaeger" = callPackage @@ -215102,6 +214098,7 @@ self: { ]; description = "Jaeger backend for OpenTracing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentracing-wai" = callPackage @@ -215113,6 +214110,7 @@ self: { libraryHaskellDepends = [ base lens opentracing text wai ]; description = "Middleware adding OpenTracing tracing for WAI applications"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentracing-zipkin-common" = callPackage @@ -215124,6 +214122,7 @@ self: { libraryHaskellDepends = [ aeson base opentracing text ]; description = "Zipkin OpenTracing Backend Commons"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentracing-zipkin-v1" = callPackage @@ -215143,6 +214142,7 @@ self: { ]; description = "Zipkin V1 backend for OpenTracing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentracing-zipkin-v2" = callPackage @@ -215160,6 +214160,7 @@ self: { ]; description = "Zipkin V2 backend for OpenTracing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "opentype" = callPackage @@ -215371,8 +214372,8 @@ self: { }: mkDerivation { pname = "optics"; - version = "0.4.2"; - sha256 = "1irk0m3194vmrqwm29p5gjwd8w7i5hmg1ikxfw11yjfk0hvmbrzb"; + version = "0.4.2.1"; + sha256 = "0sszgi7xw8k57y6w16w80rp7zbcmx0h44bxb46n4yibmp9mdhlz6"; libraryHaskellDepends = [ array base containers mtl optics-core optics-extra optics-th transformers @@ -215397,10 +214398,8 @@ self: { }: mkDerivation { pname = "optics-core"; - version = "0.4.1"; - sha256 = "16ll8829g8v5g6gqdcfj77k6g4sqpmpxbda9jhm4h68pycay4r6a"; - revision = "1"; - editedCabalFile = "0sqwlbl6x0197bpkq7jvn9j5iwyr54z8qwmxbij6qlwjyfld2qxi"; + version = "0.4.1.1"; + sha256 = "1yxkgdxnjk2gjzrnapvwn87qqpxpb7k91mxnnk20l4m0cqy7x09y"; libraryHaskellDepends = [ array base containers indexed-profunctors indexed-traversable transformers @@ -215429,6 +214428,22 @@ self: { license = lib.licenses.bsd3; }) {}; + "optics-operators" = callPackage + ({ mkDerivation, base, mtl, optics-core, tasty, tasty-quickcheck }: + mkDerivation { + pname = "optics-operators"; + version = "0.1.0.1"; + sha256 = "09518gnk6a83fn1b0y46vzg1y7l4c17nkip2qiz286y9p8g4w1j7"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base mtl optics-core ]; + testHaskellDepends = [ + base mtl optics-core tasty tasty-quickcheck + ]; + description = "A tiny package containing operators missing from the official package"; + license = lib.licenses.mit; + }) {}; + "optics-th" = callPackage ({ mkDerivation, base, containers, mtl, optics-core, tagged , template-haskell, th-abstraction, transformers @@ -215620,6 +214635,20 @@ self: { license = lib.licenses.mit; }) {}; + "options_1_2_1_2" = callPackage + ({ mkDerivation, base, containers, hspec, monads-tf, patience }: + mkDerivation { + pname = "options"; + version = "1.2.1.2"; + sha256 = "0jjz7b69qrsrbfz07xq43v70habxk8sj2gdlbkwh0gbifyhqykbf"; + libraryHaskellDepends = [ base containers monads-tf ]; + testHaskellDepends = [ base containers hspec monads-tf patience ]; + doHaddock = false; + description = "Powerful and easy command-line option parser"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "options-time" = callPackage ({ mkDerivation, base, chell, options, time }: mkDerivation { @@ -215693,8 +214722,8 @@ self: { pname = "optparse-applicative-cmdline-util"; version = "0.2.0"; sha256 = "13nr0biqhc2sd30xxn7sms4f0wl629bcahp3hmmcgf45nl38vpbh"; - revision = "1"; - editedCabalFile = "0cgqffzjzww6b6w8mqrs3nm46jbhaqhmflwyd9cis1k35yrw6npg"; + revision = "2"; + editedCabalFile = "02z169my8711w5lxvmi9y124a2z4isks7333yylw14lwv8zw7csv"; libraryHaskellDepends = [ attoparsec base optparse-applicative text ]; @@ -215775,6 +214804,8 @@ self: { pname = "optparse-generic"; version = "1.5.0"; sha256 = "0ydh59naf8qjbgidisvd9z8sqw16x7604ryyqhjmfrlf468barm5"; + revision = "1"; + editedCabalFile = "1mrq3j9ip7kcq1q0lbsfvmpjvdpfa5xhdnbxh72x4l4k8g7n7q8x"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -216192,6 +215223,30 @@ self: { license = lib.licenses.bsd3; }) {}; + "org-parser" = callPackage + ({ mkDerivation, aeson, base, containers, Diff, megaparsec + , multiwalk, neat-interpolation, pretty, pretty-simple, relude + , replace-megaparsec, tasty, tasty-hunit, text, time + }: + mkDerivation { + pname = "org-parser"; + version = "0.1.0.0"; + sha256 = "15535yqakln6yh6h8hcibbk93w4mql4ifzds66hkkw63ny8f9jaq"; + libraryHaskellDepends = [ + aeson base containers megaparsec multiwalk relude + replace-megaparsec text time + ]; + testHaskellDepends = [ + aeson base containers Diff megaparsec multiwalk neat-interpolation + pretty pretty-simple relude replace-megaparsec tasty tasty-hunit + text time + ]; + description = "Parser for Org Mode documents"; + license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "org2anki" = callPackage ({ mkDerivation, base, parsec, regex-compat }: mkDerivation { @@ -216367,68 +215422,7 @@ self: { broken = true; }) {}; - "ormolu_0_1_4_1" = callPackage - ({ mkDerivation, ansi-terminal, base, bytestring, containers, Diff - , dlist, exceptions, filepath, ghc-lib-parser, gitrev, hspec - , hspec-discover, mtl, optparse-applicative, path, path-io, syb - , text - }: - mkDerivation { - pname = "ormolu"; - version = "0.1.4.1"; - sha256 = "1aamgzimjn9h7kwby9ajfgbj5dx08nmxyalwvpg9rs4xd8pbpd9s"; - revision = "1"; - editedCabalFile = "1fi8fxyhw9jdwhsbmrikjqd461wrz7h4kdszrahlvdjfdsn4wh7d"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - ansi-terminal base bytestring containers Diff dlist exceptions - ghc-lib-parser mtl syb text - ]; - executableHaskellDepends = [ - base filepath ghc-lib-parser gitrev optparse-applicative text - ]; - testHaskellDepends = [ - base containers filepath hspec path path-io text - ]; - testToolDepends = [ hspec-discover ]; - description = "A formatter for Haskell source code"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - mainProgram = "ormolu"; - }) {}; - - "ormolu_0_2_0_0" = callPackage - ({ mkDerivation, ansi-terminal, base, bytestring, containers, Diff - , dlist, exceptions, filepath, ghc-lib-parser, gitrev, hspec - , hspec-discover, mtl, optparse-applicative, path, path-io, syb - , text - }: - mkDerivation { - pname = "ormolu"; - version = "0.2.0.0"; - sha256 = "0zivz7vcl4m1rjay5md6cdqac9cnfwz9c844l20byiz5h49bwfhb"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - ansi-terminal base bytestring containers Diff dlist exceptions - ghc-lib-parser mtl syb text - ]; - executableHaskellDepends = [ - base filepath ghc-lib-parser gitrev optparse-applicative text - ]; - testHaskellDepends = [ - base containers filepath hspec path path-io text - ]; - testToolDepends = [ hspec-discover ]; - description = "A formatter for Haskell source code"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - mainProgram = "ormolu"; - }) {}; - - "ormolu" = callPackage + "ormolu_0_5_0_1" = callPackage ({ mkDerivation, aeson, ansi-terminal, array, base, bytestring , Cabal, containers, Diff, directory, dlist, exceptions, filepath , ghc-lib-parser, gitrev, hspec, hspec-discover, hspec-megaparsec @@ -216458,10 +215452,44 @@ self: { testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "ormolu"; }) {}; - "ormolu_0_5_3_0" = callPackage + "ormolu_0_5_2_0" = callPackage + ({ mkDerivation, ansi-terminal, array, base, binary, bytestring + , Cabal-syntax, containers, Diff, directory, dlist, file-embed + , filepath, ghc-lib-parser, gitrev, hspec, hspec-discover + , hspec-megaparsec, megaparsec, MemoTrie, mtl, optparse-applicative + , path, path-io, QuickCheck, syb, temporary, text + }: + mkDerivation { + pname = "ormolu"; + version = "0.5.2.0"; + sha256 = "1ai2wza4drirvf9pb7qsf03kii5jiayqs49c19ir93jd0ak9pi96"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + ansi-terminal array base binary bytestring Cabal-syntax containers + Diff directory dlist file-embed filepath ghc-lib-parser megaparsec + MemoTrie mtl syb text + ]; + executableHaskellDepends = [ + base containers filepath ghc-lib-parser gitrev optparse-applicative + text + ]; + testHaskellDepends = [ + base containers directory filepath ghc-lib-parser hspec + hspec-megaparsec path path-io QuickCheck temporary text + ]; + testToolDepends = [ hspec-discover ]; + description = "A formatter for Haskell source code"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "ormolu"; + }) {}; + + "ormolu" = callPackage ({ mkDerivation, ansi-terminal, array, base, binary, bytestring , Cabal-syntax, containers, Diff, directory, dlist, file-embed , filepath, ghc-lib-parser, hspec, hspec-discover, hspec-megaparsec @@ -216492,7 +215520,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A formatter for Haskell source code"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "ormolu"; }) {}; @@ -216537,8 +215564,8 @@ self: { }: mkDerivation { pname = "orthotope"; - version = "0.1.2.0"; - sha256 = "11hhwq1qhdcnk5jnp5plrmx09z8bqjxxh9dw3kqyxdgk6q56irhl"; + version = "0.1.4.0"; + sha256 = "1i5v9rg16igz7bw290anj98vwkv89y1crp2gc5340sbw1d48y7vb"; libraryHaskellDepends = [ base deepseq dlist pretty QuickCheck vector ]; @@ -216586,6 +215613,8 @@ self: { ]; description = "Auto-generated ory-hydra API Client"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "ory-kratos" = callPackage @@ -216606,6 +215635,8 @@ self: { ]; description = "API bindings for Ory Kratos"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "os-release" = callPackage @@ -217037,18 +216068,18 @@ self: { "pa-json" = callPackage ({ mkDerivation, aeson, aeson-better-errors, aeson-pretty, base - , bytestring, containers, hspec-core, hspec-expectations - , pa-error-tree, pa-label, pa-prelude, scientific, text, time - , vector + , base64-bytestring, bytestring, containers, hspec-core + , hspec-expectations, pa-error-tree, pa-label, pa-prelude + , scientific, text, time, vector }: mkDerivation { pname = "pa-json"; - version = "0.2.0.0"; - sha256 = "1r3nsbdlpbrmfj9zaql7zjbd5hzvmzbcqpk74l4j78wfif4g6zmm"; + version = "0.2.1.0"; + sha256 = "1j260q8mfd46fg4iijfva2b3db7k9zfyjpn1qblkhpf073x79hnh"; libraryHaskellDepends = [ - aeson aeson-better-errors aeson-pretty base bytestring containers - hspec-core hspec-expectations pa-error-tree pa-label pa-prelude - scientific text time vector + aeson aeson-better-errors aeson-pretty base base64-bytestring + bytestring containers hspec-core hspec-expectations pa-error-tree + pa-label pa-prelude scientific text time vector ]; description = "Our JSON parsers/encoders"; license = lib.licenses.bsd3; @@ -217098,6 +216129,21 @@ self: { license = lib.licenses.bsd3; }) {}; + "pa-run-command" = callPackage + ({ mkDerivation, base, bytestring, monad-logger, pa-prelude, text + , typed-process + }: + mkDerivation { + pname = "pa-run-command"; + version = "0.1.0.0"; + sha256 = "18r9ik4ab8wmdbl2ry4ardfkpi9raw8mf0rz0qavdjgdvl67x0rp"; + libraryHaskellDepends = [ + base bytestring monad-logger pa-prelude text typed-process + ]; + description = "Helper functions for spawning subprocesses"; + license = lib.licenses.bsd3; + }) {}; + "pack" = callPackage ({ mkDerivation, array, base, bytestring, lens, transformers , vector @@ -217173,6 +216219,8 @@ self: { ]; description = "A package for retrieving a package's version number"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "package-vt" = callPackage @@ -217728,10 +216776,8 @@ self: { ({ mkDerivation, array, base, colour, containers, MonadRandom }: mkDerivation { pname = "palette"; - version = "0.3.0.2"; - sha256 = "0820n3cj4zy9s46diln2rrs4lrxbipkhdw74p2w42gc7k1nlj54i"; - revision = "5"; - editedCabalFile = "1h5vs204qkq0m9ks5sf7f300drpkinkhinvmnijq8x0mbjl8hsg4"; + version = "0.3.0.3"; + sha256 = "11d3011j680nhd0r2b29fhirld2vijwynwbgv8i5v1q7lgrb92az"; libraryHaskellDepends = [ array base colour containers MonadRandom ]; @@ -217810,70 +216856,6 @@ self: { }) {}; "pandoc" = callPackage - ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base - , base64, binary, blaze-html, blaze-markup, bytestring - , case-insensitive, citeproc, commonmark, commonmark-extensions - , commonmark-pandoc, connection, containers, data-default, deepseq - , Diff, directory, doclayout, doctemplates, emojis, exceptions - , file-embed, filepath, Glob, gridtables, haddock-library, hslua - , hslua-aeson, hslua-module-doclayout, hslua-module-path - , hslua-module-system, hslua-module-text, hslua-module-version - , http-client, http-client-tls, http-types, ipynb, jira-wiki-markup - , JuicyPixels, lpeg, mtl, network, network-uri, pandoc-lua-marshal - , pandoc-types, parsec, pretty, pretty-show, process, random, safe - , scientific, servant-server, SHA, skylighting, skylighting-core - , split, syb, tagsoup, tasty, tasty-bench, tasty-golden - , tasty-hunit, tasty-lua, tasty-quickcheck, temporary, texmath - , text, text-conversions, time, unicode-collation - , unicode-transforms, unix, wai, wai-extra, warp, xml, xml-conduit - , xml-types, yaml, zip-archive, zlib - }: - mkDerivation { - pname = "pandoc"; - version = "2.19.2"; - sha256 = "0ia2gpl345lwymk38y89sgcqjci7sjmxbi228idg6nkaqfa3ds1n"; - configureFlags = [ "-f-trypandoc" ]; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson aeson-pretty array attoparsec base base64 binary blaze-html - blaze-markup bytestring case-insensitive citeproc commonmark - commonmark-extensions commonmark-pandoc connection containers - data-default deepseq directory doclayout doctemplates emojis - exceptions file-embed filepath Glob gridtables haddock-library - hslua hslua-aeson hslua-module-doclayout hslua-module-path - hslua-module-system hslua-module-text hslua-module-version - http-client http-client-tls http-types ipynb jira-wiki-markup - JuicyPixels lpeg mtl network network-uri pandoc-lua-marshal - pandoc-types parsec pretty pretty-show process random safe - scientific servant-server SHA skylighting skylighting-core split - syb tagsoup temporary texmath text text-conversions time - unicode-collation unicode-transforms unix wai xml xml-conduit - xml-types yaml zip-archive zlib - ]; - executableHaskellDepends = [ base safe wai-extra warp ]; - testHaskellDepends = [ - base bytestring containers Diff directory doctemplates exceptions - filepath Glob hslua mtl pandoc-types process tasty tasty-golden - tasty-hunit tasty-lua tasty-quickcheck text time xml zip-archive - ]; - benchmarkHaskellDepends = [ - base bytestring deepseq mtl tasty-bench text - ]; - postInstall = '' - mkdir -p $out/share/man/man1 - mv "man/"*.1 $out/share/man/man1/ - ''; - description = "Conversion between markup formats"; - license = lib.licenses.gpl2Plus; - mainProgram = "pandoc"; - maintainers = [ - lib.maintainers.maralorn lib.maintainers.sternenseemann - ]; - }) {}; - - "pandoc_3_1_3" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base , base64, binary, blaze-html, blaze-markup, bytestring , case-insensitive, citeproc, commonmark, commonmark-extensions @@ -217885,14 +216867,14 @@ self: { , parsec, pretty, pretty-show, process, random, safe, scientific , SHA, skylighting, skylighting-core, split, syb, tagsoup, tasty , tasty-bench, tasty-golden, tasty-hunit, tasty-quickcheck - , temporary, texmath, text, text-conversions, time, typst - , unicode-collation, unicode-transforms, unix, vector, xml - , xml-conduit, xml-types, yaml, zip-archive, zlib + , temporary, texmath, text, text-conversions, time + , unicode-collation, unicode-transforms, unix, xml, xml-conduit + , xml-types, yaml, zip-archive, zlib }: mkDerivation { pname = "pandoc"; - version = "3.1.3"; - sha256 = "070rx611v1kg3gcvp267h68m0dh3zfi0v3r6r2lkadmfw45sxrvd"; + version = "3.0.1"; + sha256 = "0yxrcr589z1wbk1ng7qg6ni7zy1vm2v5fg5df639xgk1na4sn0jc"; configureFlags = [ "-f-trypandoc" ]; enableSeparateDataOutput = true; libraryHaskellDepends = [ @@ -217905,8 +216887,8 @@ self: { JuicyPixels mime-types mtl network network-uri pandoc-types parsec pretty pretty-show process random safe scientific SHA skylighting skylighting-core split syb tagsoup temporary texmath text - text-conversions time typst unicode-collation unicode-transforms - unix vector xml xml-conduit xml-types yaml zip-archive zlib + text-conversions time unicode-collation unicode-transforms unix xml + xml-conduit xml-types yaml zip-archive zlib ]; testHaskellDepends = [ base bytestring containers Diff directory doctemplates filepath @@ -217923,6 +216905,63 @@ self: { ''; description = "Conversion between markup formats"; license = lib.licenses.gpl2Plus; + maintainers = [ + lib.maintainers.maralorn lib.maintainers.sternenseemann + ]; + }) {}; + + "pandoc_3_1_6" = callPackage + ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base + , base64, binary, blaze-html, blaze-markup, bytestring + , case-insensitive, citeproc, commonmark, commonmark-extensions + , commonmark-pandoc, containers, crypton-connection, data-default + , deepseq, Diff, directory, doclayout, doctemplates, emojis + , exceptions, file-embed, filepath, Glob, gridtables + , haddock-library, http-client, http-client-tls, http-types, ipynb + , jira-wiki-markup, JuicyPixels, mime-types, mtl, network + , network-uri, pandoc-types, parsec, pretty, pretty-show, process + , random, safe, scientific, SHA, skylighting, skylighting-core + , split, syb, tagsoup, tasty, tasty-bench, tasty-golden + , tasty-hunit, tasty-quickcheck, temporary, texmath, text + , text-conversions, time, typst, unicode-collation + , unicode-transforms, unix, vector, xml, xml-conduit, xml-types + , yaml, zip-archive, zlib + }: + mkDerivation { + pname = "pandoc"; + version = "3.1.6"; + sha256 = "0d67n1gzx3bxvjgb5ql5h2fb1m6vk7v7c1sr795jvk67hkx340rv"; + configureFlags = [ "-f-trypandoc" ]; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson aeson-pretty array attoparsec base base64 binary blaze-html + blaze-markup bytestring case-insensitive citeproc commonmark + commonmark-extensions commonmark-pandoc containers + crypton-connection data-default deepseq directory doclayout + doctemplates emojis exceptions file-embed filepath Glob gridtables + haddock-library http-client http-client-tls http-types ipynb + jira-wiki-markup JuicyPixels mime-types mtl network network-uri + pandoc-types parsec pretty pretty-show process random safe + scientific SHA skylighting skylighting-core split syb tagsoup + temporary texmath text text-conversions time typst + unicode-collation unicode-transforms unix vector xml xml-conduit + xml-types yaml zip-archive zlib + ]; + testHaskellDepends = [ + base bytestring containers Diff directory doctemplates filepath + Glob mtl pandoc-types process tasty tasty-golden tasty-hunit + tasty-quickcheck temporary text time xml zip-archive + ]; + benchmarkHaskellDepends = [ + base bytestring deepseq mtl tasty-bench text + ]; + doHaddock = false; + postInstall = '' + mkdir -p $out/share/man/man1 + mv "man/"*.1 $out/share/man/man1/ + ''; + description = "Conversion between markup formats"; + license = lib.licenses.gpl2Plus; hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn lib.maintainers.sternenseemann @@ -217991,8 +217030,8 @@ self: { }: mkDerivation { pname = "pandoc-cli"; - version = "0.1.1"; - sha256 = "1mkcbi34mj0g7hd4mj81hg43w2phk90hykxyvwvqn2f11qmrchmf"; + version = "0.1.1.1"; + sha256 = "18qvgnzcklcckfpp1ahh3g1a5pdxp8ww7qq7apdq4xl2m959fh8z"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -218017,46 +217056,12 @@ self: { executableHaskellDepends = [ base pandoc-types ]; description = "A pandoc filter that provides a Markdown extension for columns"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-columns"; + broken = true; }) {}; "pandoc-crossref" = callPackage - ({ mkDerivation, base, containers, criterion, data-default, deepseq - , directory, filepath, gitrev, hspec, microlens, microlens-mtl - , microlens-th, mtl, open-browser, optparse-applicative, pandoc - , pandoc-types, syb, template-haskell, temporary, text, utility-ht - }: - mkDerivation { - pname = "pandoc-crossref"; - version = "0.3.14.0"; - sha256 = "1f55xz5r7h6vjjj0dsq5glavn0zjh02imi4mja8qbwn3rvi67l86"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - base containers data-default directory filepath microlens - microlens-mtl microlens-th mtl pandoc pandoc-types syb - template-haskell text utility-ht - ]; - executableHaskellDepends = [ - base deepseq gitrev open-browser optparse-applicative pandoc - pandoc-types template-haskell temporary text - ]; - testHaskellDepends = [ - base containers data-default directory filepath hspec microlens mtl - pandoc pandoc-types text - ]; - benchmarkHaskellDepends = [ - base criterion pandoc pandoc-types text - ]; - doHaddock = false; - description = "Pandoc filter for cross-references"; - license = lib.licenses.gpl2Only; - mainProgram = "pandoc-crossref"; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "pandoc-crossref_0_3_16_0" = callPackage ({ mkDerivation, base, containers, criterion, data-default, deepseq , directory, filepath, gitrev, hspec, microlens, microlens-ghc , microlens-mtl, microlens-th, mtl, open-browser @@ -218090,7 +217095,6 @@ self: { doHaddock = false; description = "Pandoc filter for cross-references"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-crossref"; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -218108,7 +217112,9 @@ self: { executableHaskellDepends = [ base csv pandoc pandoc-types ]; description = "Convert CSV to Pandoc Table Markdown"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-csv2table"; + broken = true; }) {}; "pandoc-dhall-decoder" = callPackage @@ -218145,9 +217151,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "A Pandoc filter for emphasizing code in fenced blocks"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-emphasize-code"; - broken = true; }) {}; "pandoc-filter-graphviz" = callPackage @@ -218286,7 +217290,9 @@ self: { executableHaskellDepends = [ base directory pandoc-types ]; description = "Pandoc filter to include files, with image path and heading level adjustment"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-include-plus"; + broken = true; }) {}; "pandoc-japanese-filters" = callPackage @@ -218334,7 +217340,9 @@ self: { executableHaskellDepends = [ base pandoc-types ]; description = "A pandoc filter that provides a Markdown extension to wrap text in table cells"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-linear-table"; + broken = true; }) {}; "pandoc-link-context" = callPackage @@ -218348,6 +217356,8 @@ self: { ]; description = "Extract \"contextual links\" from Pandoc"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pandoc-logic-proof" = callPackage @@ -218362,7 +217372,9 @@ self: { executableHaskellDepends = [ base pandoc-types ]; description = "A pandoc filter that provides a Markdown extension for logic proofs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-logic-proof"; + broken = true; }) {}; "pandoc-lua-engine" = callPackage @@ -218376,8 +217388,8 @@ self: { }: mkDerivation { pname = "pandoc-lua-engine"; - version = "0.2.0.1"; - sha256 = "1y1il2lx4bhpby6nk9wam84gmjq2knz4ynm28ckb27mgih99jf4a"; + version = "0.2.1"; + sha256 = "15vcfzl02pvly5wdrj16sw9jxj7lq5r68ri1xj3ii1mmzp9vamp5"; libraryHaskellDepends = [ aeson base bytestring citeproc containers data-default doclayout doctemplates exceptions hslua hslua-module-doclayout @@ -218391,33 +217403,9 @@ self: { ]; description = "Lua engine to power custom pandoc conversions"; license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-lua-marshal" = callPackage - ({ mkDerivation, base, bytestring, containers, exceptions, hslua - , hslua-marshalling, lua, pandoc-types, QuickCheck, safe, tasty - , tasty-hunit, tasty-lua, tasty-quickcheck, text - }: - mkDerivation { - pname = "pandoc-lua-marshal"; - version = "0.1.7"; - sha256 = "0pn9b7f8dln049k76zb4znscl01qms751y1ln4j8irs50rc1b55j"; - libraryHaskellDepends = [ - base bytestring containers exceptions hslua hslua-marshalling lua - pandoc-types safe text - ]; - testHaskellDepends = [ - base bytestring containers exceptions hslua hslua-marshalling lua - pandoc-types QuickCheck safe tasty tasty-hunit tasty-lua - tasty-quickcheck text - ]; - description = "Use pandoc types in Lua"; - license = lib.licenses.mit; - }) {}; - - "pandoc-lua-marshal_0_2_2" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, exceptions , hslua, hslua-list, hslua-marshalling, lua, pandoc-types , QuickCheck, safe, tasty, tasty-hunit, tasty-lua, tasty-quickcheck @@ -218438,7 +217426,6 @@ self: { ]; description = "Use pandoc types in Lua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "pandoc-markdown-ghci-filter" = callPackage @@ -218520,41 +217507,6 @@ self: { }) {}; "pandoc-plot" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, criterion - , data-default, directory, filepath, gitrev, hashable - , hspec-expectations, lifted-async, lifted-base, mtl - , optparse-applicative, pandoc, pandoc-types, shakespeare, tagsoup - , tasty, tasty-hspec, tasty-hunit, template-haskell, text - , typed-process, unix, yaml - }: - mkDerivation { - pname = "pandoc-plot"; - version = "1.5.5"; - sha256 = "1gcs6sh8fhlmaiha5wn60z2s5an7gnawgkyzlalf8grwnjqkm77h"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base bytestring containers data-default directory filepath - hashable lifted-async lifted-base mtl pandoc pandoc-types - shakespeare tagsoup template-haskell text typed-process unix yaml - ]; - executableHaskellDepends = [ - base containers directory filepath gitrev optparse-applicative - pandoc pandoc-types template-haskell text typed-process - ]; - testHaskellDepends = [ - base containers directory filepath hspec-expectations pandoc-types - tasty tasty-hspec tasty-hunit text - ]; - benchmarkHaskellDepends = [ - base criterion pandoc-types template-haskell text - ]; - description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice"; - license = lib.licenses.gpl2Plus; - mainProgram = "pandoc-plot"; - }) {}; - - "pandoc-plot_1_7_0" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, data-default , directory, filepath, gitrev, hashable, hspec-expectations , lifted-async, lifted-base, mtl, optparse-applicative, pandoc @@ -218582,7 +217534,6 @@ self: { ]; description = "A Pandoc filter to include figures generated from code blocks using your plotting toolkit of choice"; license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-plot"; }) {}; @@ -218630,7 +217581,9 @@ self: { executableHaskellDepends = [ base pandoc pandoc-types ]; description = "Pandoc filter to extract only the code blocks"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-select-code"; + broken = true; }) {}; "pandoc-server" = callPackage @@ -218640,8 +217593,8 @@ self: { }: mkDerivation { pname = "pandoc-server"; - version = "0.1"; - sha256 = "1l0nvzq4p06lsn3q5krkddgl9qf5lv7s8siqhpvnz8gjzdnxi12q"; + version = "0.1.0.1"; + sha256 = "18vz5fmgp3xlb053as958l3w8frxh4zwzqxycyhy68zs9bpimcpr"; libraryHaskellDepends = [ aeson base base64 bytestring containers data-default doctemplates pandoc pandoc-types servant-server skylighting text @@ -218649,8 +217602,6 @@ self: { ]; description = "Pandoc document conversion as an HTTP servant-server"; license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "pandoc-sidenote" = callPackage @@ -218688,32 +217639,59 @@ self: { "pandoc-symreg" = callPackage ({ mkDerivation, attoparsec, attoparsec-expr, base, bytestring, mtl - , optparse-applicative, srtree, srtree-eqsat + , optparse-applicative, srtree }: mkDerivation { pname = "pandoc-symreg"; - version = "0.2.1.1"; - sha256 = "1qzz3xc77ak6fvxvdanq1iy9nz2brwlixmjqlbwcjx0568qqcy7l"; + version = "0.2.0.0"; + sha256 = "0ick0m8iz85hvvy4kfpqnghj2dx30qx12q546xaj7b0lqj4gf4mw"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ attoparsec attoparsec-expr base bytestring mtl optparse-applicative - srtree srtree-eqsat + srtree ]; executableHaskellDepends = [ attoparsec attoparsec-expr base bytestring mtl optparse-applicative - srtree srtree-eqsat + srtree ]; testHaskellDepends = [ attoparsec attoparsec-expr base bytestring mtl optparse-applicative - srtree srtree-eqsat + srtree + ]; + description = "A tool to convert symbolic regression expressions into different formats"; + license = lib.licenses.gpl3Only; + mainProgram = "pandoc-symreg"; + }) {}; + + "pandoc-symreg_0_2_1_3" = callPackage + ({ mkDerivation, attoparsec, attoparsec-expr, base, bytestring + , containers, deriving-compat, hegg, ieee754, mtl + , optparse-applicative, srtree + }: + mkDerivation { + pname = "pandoc-symreg"; + version = "0.2.1.3"; + sha256 = "0ybaf0jixdxjs3xw9cr1r578fmrjlkdqy5h2xd1a9gw1ghy5vp80"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + attoparsec attoparsec-expr base bytestring containers + deriving-compat hegg ieee754 mtl optparse-applicative srtree + ]; + executableHaskellDepends = [ + attoparsec attoparsec-expr base bytestring containers + deriving-compat hegg ieee754 mtl optparse-applicative srtree + ]; + testHaskellDepends = [ + attoparsec attoparsec-expr base bytestring containers + deriving-compat hegg ieee754 mtl optparse-applicative srtree ]; description = "A tool to convert symbolic regression expressions into different formats"; license = lib.licenses.gpl3Only; hydraPlatforms = lib.platforms.none; mainProgram = "pandoc-symreg"; - broken = true; - }) {srtree-eqsat = null;}; + }) {}; "pandoc-throw" = callPackage ({ mkDerivation, base, exceptions, pandoc }: @@ -218728,51 +217706,28 @@ self: { "pandoc-types" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, criterion - , deepseq, ghc-prim, HUnit, QuickCheck, string-qq, syb + , deepseq, ghc-prim, HUnit, QuickCheck, syb, template-haskell , test-framework, test-framework-hunit, test-framework-quickcheck2 , text, transformers }: mkDerivation { pname = "pandoc-types"; - version = "1.22.2.1"; - sha256 = "17b5c4b9jmx2gca1wk9vlnvvlzdw21qiqc0bpikkkiv7kl99drsc"; + version = "1.23.0.1"; + sha256 = "0ilxjlibxqj6h627wak7k17r69743hzwgl2qgr2wigk3j9a3fmji"; libraryHaskellDepends = [ aeson base bytestring containers deepseq ghc-prim QuickCheck syb text transformers ]; testHaskellDepends = [ - aeson base bytestring containers HUnit QuickCheck string-qq syb - test-framework test-framework-hunit test-framework-quickcheck2 text + aeson base bytestring containers HUnit QuickCheck syb + template-haskell test-framework test-framework-hunit + test-framework-quickcheck2 text ]; benchmarkHaskellDepends = [ base criterion text ]; description = "Types for representing a structured document"; license = lib.licenses.bsd3; }) {}; - "pandoc-types_1_23" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, criterion - , deepseq, ghc-prim, HUnit, QuickCheck, string-qq, syb - , test-framework, test-framework-hunit, test-framework-quickcheck2 - , text, transformers - }: - mkDerivation { - pname = "pandoc-types"; - version = "1.23"; - sha256 = "0b8na6516rkwx3b7la58zwpmjia7hvljswzw0nds7h0r090j2rsy"; - libraryHaskellDepends = [ - aeson base bytestring containers deepseq ghc-prim QuickCheck syb - text transformers - ]; - testHaskellDepends = [ - aeson base bytestring containers HUnit QuickCheck string-qq syb - test-framework test-framework-hunit test-framework-quickcheck2 text - ]; - benchmarkHaskellDepends = [ base criterion text ]; - description = "Types for representing a structured document"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "pandoc-unlit" = callPackage ({ mkDerivation, base, pandoc }: mkDerivation { @@ -219077,8 +218032,10 @@ self: { }: mkDerivation { pname = "pantry"; - version = "0.5.7"; - sha256 = "1cck09972pv2kz6kpg631rxfqwy92g4ibngfjy0bkp2xfadcg6ci"; + version = "0.8.3"; + sha256 = "0kn7p8xlb5bx7bvmnd14xyf0gsx2xfi8mwlbvpxdk06dfb81w582"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ aeson ansi-terminal base bytestring Cabal casa-client casa-types conduit conduit-extra containers cryptonite cryptonite-conduit @@ -219104,45 +218061,50 @@ self: { license = lib.licenses.bsd3; }) {}; - "pantry_0_8_2_2" = callPackage - ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal - , casa-client, casa-types, conduit, conduit-extra, containers - , cryptonite, cryptonite-conduit, digest, exceptions, filelock - , generic-deriving, hackage-security, hedgehog, hpack, hspec - , http-client, http-client-tls, http-conduit, http-download - , http-types, memory, mtl, network-uri, path, path-io, persistent - , persistent-sqlite, persistent-template, primitive, QuickCheck - , raw-strings-qq, resourcet, rio, rio-orphans, rio-prettyprint + "pantry_0_9_1" = callPackage + ({ mkDerivation, aeson, aeson-warning-parser, ansi-terminal, base + , bytestring, Cabal, casa-client, casa-types, companion, conduit + , conduit-extra, containers, cryptonite, cryptonite-conduit, digest + , exceptions, filelock, generic-deriving, hackage-security + , hedgehog, hpack, hspec, hspec-discover, http-client + , http-client-tls, http-conduit, http-download, http-types, memory + , mtl, network-uri, path, path-io, persistent, persistent-sqlite + , persistent-template, primitive, QuickCheck, raw-strings-qq + , resourcet, rio, rio-orphans, rio-prettyprint, static-bytes , tar-conduit, text, text-metrics, time, transformers, unix-compat , unliftio, unordered-containers, vector, yaml, zip-archive }: mkDerivation { pname = "pantry"; - version = "0.8.2.2"; - sha256 = "0gmwymas93g41gzgf11h1vfkn22h56y14rxvcgcg646y7lz0fhlg"; + version = "0.9.1"; + sha256 = "05rn8ib4215rdsh5jzi9a0s920zp7i4vq47af4zvmaji17bn6nnp"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson ansi-terminal base bytestring Cabal casa-client casa-types - conduit conduit-extra containers cryptonite cryptonite-conduit - digest filelock generic-deriving hackage-security hpack http-client - http-client-tls http-conduit http-download http-types memory mtl - network-uri path path-io persistent persistent-sqlite - persistent-template primitive resourcet rio rio-orphans - rio-prettyprint tar-conduit text text-metrics time transformers - unix-compat unliftio unordered-containers vector yaml zip-archive - ]; - testHaskellDepends = [ - aeson ansi-terminal base bytestring Cabal casa-client casa-types - conduit conduit-extra containers cryptonite cryptonite-conduit - digest exceptions filelock generic-deriving hackage-security - hedgehog hpack hspec http-client http-client-tls http-conduit + aeson aeson-warning-parser ansi-terminal base bytestring Cabal + casa-client casa-types companion conduit conduit-extra containers + cryptonite cryptonite-conduit digest filelock generic-deriving + hackage-security hpack http-client http-client-tls http-conduit http-download http-types memory mtl network-uri path path-io persistent persistent-sqlite persistent-template primitive - QuickCheck raw-strings-qq resourcet rio rio-orphans rio-prettyprint - tar-conduit text text-metrics time transformers unix-compat - unliftio unordered-containers vector yaml zip-archive + resourcet rio rio-orphans rio-prettyprint static-bytes tar-conduit + text text-metrics time transformers unix-compat unliftio + unordered-containers vector yaml zip-archive ]; + testHaskellDepends = [ + aeson aeson-warning-parser ansi-terminal base bytestring Cabal + casa-client casa-types companion conduit conduit-extra containers + cryptonite cryptonite-conduit digest exceptions filelock + generic-deriving hackage-security hedgehog hpack hspec http-client + http-client-tls http-conduit http-download http-types memory mtl + network-uri path path-io persistent persistent-sqlite + persistent-template primitive QuickCheck raw-strings-qq resourcet + rio rio-orphans rio-prettyprint static-bytes tar-conduit text + text-metrics time transformers unix-compat unliftio + unordered-containers vector yaml zip-archive + ]; + testToolDepends = [ hspec-discover ]; + doHaddock = false; description = "Content addressable Haskell package management"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -219838,10 +218800,8 @@ self: { }: mkDerivation { pname = "paramtree"; - version = "0.1.1.1"; - sha256 = "0ls9wzmz5lk7gyl8lx9cjs49zpwhrv955fs5q6ypv7bpbvjbchs1"; - revision = "3"; - editedCabalFile = "1nd342xk0sm9dlh5915b9kbksyd87wpji1mw8m8phm8d72prcxmi"; + version = "0.1.2"; + sha256 = "0qb0l68b5yldypik20fxf8rdxhkrqywvvk4n6pk6g7wnvyxvadrn"; libraryHaskellDepends = [ base containers ]; testHaskellDepends = [ base bytestring tasty tasty-golden tasty-hunit temporary @@ -220626,6 +219586,8 @@ self: { ]; description = "Parser combinators with slicing, error recovery, and syntax highlighting"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "parsley" = callPackage @@ -220824,8 +219786,10 @@ self: { ({ mkDerivation, base, hedgehog }: mkDerivation { pname = "partial-semigroup"; - version = "0.6.0.1"; - sha256 = "1zzpv5b860k22wng7qa0pcj129vgzm2vxda5x1f26f9vc0bm8q18"; + version = "0.6.0.2"; + sha256 = "08q8p6iyvnk4gbp3i876bz8j0nx8gk5ybi2lkif45sxm5gl37q5x"; + revision = "1"; + editedCabalFile = "1m1z8dqgqwpnq5pnn42ycp1sh8viq3kb15xzw16vb2g09kjc0hff"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base hedgehog ]; description = "A partial binary associative operator"; @@ -220836,8 +219800,8 @@ self: { ({ mkDerivation, base, hedgehog, partial-semigroup }: mkDerivation { pname = "partial-semigroup-hedgehog"; - version = "0.6.0.14"; - sha256 = "1f5c2z8ivmdbdy5s2f4q3pbrb4k53503zwsdc8c5drm34wrvim3b"; + version = "0.6.0.15"; + sha256 = "09sfs80119anxgykhndkk3yjdgsqm52ij34rijpa8mxvpi7wgcyx"; libraryHaskellDepends = [ base hedgehog partial-semigroup ]; description = "Property testing for partial semigroups using Hedgehog"; license = lib.licenses.asl20; @@ -221162,8 +220126,8 @@ self: { }: mkDerivation { pname = "patat"; - version = "0.8.8.0"; - sha256 = "13y2cj01yl1pq9gdbzjq1mc4qp8ljnmf3hdb13sc5058y0054zy1"; + version = "0.8.9.0"; + sha256 = "1lis3ifji30vxhgaw211z8g6v0sjag4fpsnh2x8zw20h2phiwdm0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -221372,29 +220336,11 @@ self: { libraryHaskellDepends = [ base formatting path ]; description = "Formatting for path"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "path-io" = callPackage - ({ mkDerivation, base, containers, directory, dlist, exceptions - , filepath, hspec, path, temporary, time, transformers, unix-compat - }: - mkDerivation { - pname = "path-io"; - version = "1.7.0"; - sha256 = "1jr1inh3x0a42rdh4q0jipbw8jsprdza1j5xkzd7nxcq0a143g9l"; - libraryHaskellDepends = [ - base containers directory dlist exceptions filepath path temporary - time transformers unix-compat - ]; - testHaskellDepends = [ - base directory exceptions filepath hspec path transformers - unix-compat - ]; - description = "Interface to ‘directory’ package for users of ‘path’"; - license = lib.licenses.bsd3; - }) {}; - - "path-io_1_8_1" = callPackage ({ mkDerivation, base, containers, directory, dlist, exceptions , filepath, hspec, path, temporary, time, transformers, unix-compat }: @@ -221412,7 +220358,6 @@ self: { ]; description = "Interface to ‘directory’ package for users of ‘path’"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "path-like" = callPackage @@ -221445,8 +220390,8 @@ self: { ({ mkDerivation, base, bytestring, path, safe-exceptions, text }: mkDerivation { pname = "path-text-utf8"; - version = "0.0.1.11"; - sha256 = "1dxqbcwsr3ayijssm7wr6z96p3vrwrfqhr15zhg7m3i2ad44wz8c"; + version = "0.0.1.12"; + sha256 = "1q56hrvi865jxx0w9k5xkh20yr9iy808ylqhpc6plqnqbhydwiyb"; libraryHaskellDepends = [ base bytestring path safe-exceptions text ]; @@ -221454,6 +220399,22 @@ self: { license = lib.licenses.asl20; }) {}; + "path-text-utf8_0_0_2_0" = callPackage + ({ mkDerivation, base, bytestring, file-io, filepath, path + , safe-exceptions, text + }: + mkDerivation { + pname = "path-text-utf8"; + version = "0.0.2.0"; + sha256 = "1cxkrm6gzq25z6xnq7nnpxcx21bpfx1mrz6n8qqisg4r36dskxsg"; + libraryHaskellDepends = [ + base bytestring file-io filepath path safe-exceptions text + ]; + description = "Read and write UTF-8 text files"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + }) {}; + "path-tree" = callPackage ({ mkDerivation, base, containers, relude }: mkDerivation { @@ -221588,8 +220549,8 @@ self: { }: mkDerivation { pname = "patrol"; - version = "1.0.0.4"; - sha256 = "0pjczxpjjlzl1d56yqg07lgj5k2w1gx0krsjpkg1xar36iis5m2f"; + version = "1.0.0.5"; + sha256 = "1nkni4zridr6y6q158f332kv93a828pimq6xwa6644hh4r1gxb25"; libraryHaskellDepends = [ aeson base bytestring case-insensitive containers exceptions http-client http-types network-uri text time uuid @@ -222123,32 +221084,6 @@ self: { }) {}; "pcre2" = callPackage - ({ mkDerivation, base, containers, criterion, hspec, microlens - , microlens-platform, mtl, pcre-light, regex-pcre-builtin - , template-haskell, text - }: - mkDerivation { - pname = "pcre2"; - version = "2.1.1.1"; - sha256 = "1593grzraqpam646s08fi3wgwnaib3lcgyj5m7xqpbfrzyil8wsq"; - libraryHaskellDepends = [ - base containers microlens mtl template-haskell text - ]; - testHaskellDepends = [ - base containers hspec microlens microlens-platform mtl - template-haskell text - ]; - benchmarkHaskellDepends = [ - base containers criterion microlens microlens-platform mtl - pcre-light regex-pcre-builtin template-haskell text - ]; - description = "Regular expressions via the PCRE2 C library (included)"; - license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "pcre2_2_2_1" = callPackage ({ mkDerivation, base, containers, criterion, hspec, microlens , microlens-platform, mtl, pcre-light, regex-pcre-builtin , template-haskell, text @@ -222859,8 +221794,8 @@ self: { ({ mkDerivation, base, leancheck }: mkDerivation { pname = "percent-format"; - version = "0.0.2"; - sha256 = "0nlfva8ldvq169q76ng2f23bdnyzc6q8a7bq4lgwr9ypw96i503f"; + version = "0.0.4"; + sha256 = "0plzn3c35iikc3xd5wcd5svkizy9x6v488cf5vxx5aj4hzmp6wmr"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base leancheck ]; description = "simple printf-style string formatting"; @@ -222907,6 +221842,7 @@ self: { benchmarkToolDepends = [ cpphs ]; description = "Find duplicate images"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "phash"; }) {}; @@ -222946,8 +221882,8 @@ self: { }: mkDerivation { pname = "peregrin"; - version = "0.3.3"; - sha256 = "1m7s8ws47g9icf9rfi8sk51bjwpbz5av17lbsnfg2cz3gji0977w"; + version = "0.4.0"; + sha256 = "1i9zc3cq5pl3zffm5n5ijnvcp22cx945n0sfr5xxdm91drg42b4d"; libraryHaskellDepends = [ base bytestring postgresql-simple text ]; testHaskellDepends = [ base hspec pg-harness-client postgresql-simple resource-pool text @@ -223340,6 +222276,8 @@ self: { ]; description = "Minimal serialization library with focus on performance"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persist-state" = callPackage @@ -223435,46 +222373,10 @@ self: { }: mkDerivation { pname = "persistent"; - version = "2.13.3.5"; - sha256 = "0z69yvk0rd29dp5qdhi4p587b891y90azrzzpa3g10cxp3gyywvm"; - revision = "3"; - editedCabalFile = "0kyipwaspzah6f88s51d61kr8i9g05grm2g0lnnw28jp06nggg5d"; - libraryHaskellDepends = [ - aeson attoparsec base base64-bytestring blaze-html bytestring - conduit containers fast-logger http-api-data lift-type monad-logger - mtl path-pieces resource-pool resourcet scientific silently - template-haskell text th-lift-instances time transformers unliftio - unliftio-core unordered-containers vault vector - ]; - testHaskellDepends = [ - aeson attoparsec base base64-bytestring blaze-html bytestring - conduit containers fast-logger hspec http-api-data monad-logger mtl - path-pieces QuickCheck quickcheck-instances resource-pool resourcet - scientific shakespeare silently template-haskell text - th-lift-instances time transformers unliftio unliftio-core - unordered-containers vector - ]; - benchmarkHaskellDepends = [ - base criterion deepseq file-embed template-haskell text - ]; - description = "Type-safe, multi-backend data serialization"; - license = lib.licenses.mit; - maintainers = [ lib.maintainers.psibi ]; - }) {}; - - "persistent_2_14_5_0" = callPackage - ({ mkDerivation, aeson, attoparsec, base, base64-bytestring - , blaze-html, bytestring, conduit, containers, criterion, deepseq - , fast-logger, file-embed, hspec, http-api-data, lift-type - , monad-logger, mtl, path-pieces, QuickCheck, quickcheck-instances - , resource-pool, resourcet, scientific, shakespeare, silently - , template-haskell, text, th-lift-instances, time, transformers - , unliftio, unliftio-core, unordered-containers, vault, vector - }: - mkDerivation { - pname = "persistent"; - version = "2.14.5.0"; - sha256 = "1vj67j2r1wc26fz1zk1l0f2b41bkazcz3f509amanmhjwwiqlq84"; + version = "2.14.5.1"; + sha256 = "0sv4naw17rdg9mh1q2jba5qdjcx296z6nf409d1i3ihw8r31xq5w"; + revision = "1"; + editedCabalFile = "0in8mijqrrnzlr11640nwwgm836xw9v6lyw4iaqi3qf7zpdlf8zr"; libraryHaskellDepends = [ aeson attoparsec base base64-bytestring blaze-html bytestring conduit containers deepseq fast-logger http-api-data lift-type @@ -223495,7 +222397,6 @@ self: { ]; description = "Type-safe, multi-backend data serialization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.psibi ]; }) {}; @@ -223810,10 +222711,11 @@ self: { "persistent-mtl" = callPackage ({ mkDerivation, base, bytestring, conduit, containers, esqueleto - , explainable-predicates, monad-logger, persistent + , exceptions, explainable-predicates, monad-logger, mtl, persistent , persistent-postgresql, persistent-sqlite, persistent-template , resource-pool, resourcet, tasty, tasty-autocollect, tasty-golden - , tasty-hunit, text, unliftio + , tasty-hunit, text, transformers, unliftio, unliftio-core + , unliftio-pool }: mkDerivation { pname = "persistent-mtl"; @@ -223821,6 +222723,11 @@ self: { sha256 = "17sxwa8p95nrkacjr1wnpihwfq121z1pkyh1nvlfjy76b4aalqhi"; revision = "3"; editedCabalFile = "1slwcn2iafg1gffhj02hlbgpv2v719f26a608bli2hkd9v96s720"; + libraryHaskellDepends = [ + base conduit containers exceptions monad-logger mtl persistent + resource-pool resourcet text transformers unliftio unliftio-core + unliftio-pool + ]; testHaskellDepends = [ base bytestring conduit containers esqueleto explainable-predicates monad-logger persistent persistent-postgresql persistent-sqlite @@ -223996,6 +222903,8 @@ self: { ]; description = "Memory-constant streaming of Persistent entities from PostgreSQL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "persistent-protobuf" = callPackage @@ -224016,27 +222925,6 @@ self: { }) {}; "persistent-qq" = callPackage - ({ mkDerivation, aeson, base, bytestring, fast-logger - , haskell-src-meta, hspec, HUnit, monad-logger, mtl, persistent - , persistent-sqlite, resourcet, template-haskell, text, unliftio - }: - mkDerivation { - pname = "persistent-qq"; - version = "2.12.0.2"; - sha256 = "0pzlhwl4h9q358zc6d0m5zv0ii2yhf2lzw0a3v2spfc1ch4a014a"; - libraryHaskellDepends = [ - base haskell-src-meta mtl persistent template-haskell text - ]; - testHaskellDepends = [ - aeson base bytestring fast-logger haskell-src-meta hspec HUnit - monad-logger mtl persistent persistent-sqlite resourcet - template-haskell text unliftio - ]; - description = "Provides a quasi-quoter for raw SQL for persistent"; - license = lib.licenses.mit; - }) {}; - - "persistent-qq_2_12_0_5" = callPackage ({ mkDerivation, aeson, base, bytestring, fast-logger , haskell-src-meta, hspec, HUnit, monad-logger, mtl, persistent , persistent-sqlite, resourcet, template-haskell, text, unliftio @@ -224055,7 +222943,6 @@ self: { ]; description = "Provides a quasi-quoter for raw SQL for persistent"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "persistent-ratelimit" = callPackage @@ -224080,8 +222967,8 @@ self: { pname = "persistent-redis"; version = "2.13.0.1"; sha256 = "1p03bwsldi3w4vsig1krnilhpbkkhzrm240jbx22q514922kgjr9"; - revision = "1"; - editedCabalFile = "0k383hvfpd0s38a8fmr2zad3f10lvz7sj969ainx9fd7hf550br2"; + revision = "2"; + editedCabalFile = "0dcj03k07gb3spp0zllc0h0p57xwxa7x9vsm0zszqvks76y85f9m"; libraryHaskellDepends = [ aeson base binary bytestring hedis http-api-data mtl path-pieces persistent scientific text time transformers utf8-string @@ -224240,29 +223127,6 @@ self: { }) {}; "persistent-test" = callPackage - ({ mkDerivation, aeson, base, blaze-html, bytestring, conduit - , containers, exceptions, hspec, hspec-expectations, http-api-data - , HUnit, monad-control, monad-logger, mtl, path-pieces, persistent - , QuickCheck, quickcheck-instances, random, resourcet, text, time - , transformers, transformers-base, unliftio, unliftio-core - , unordered-containers - }: - mkDerivation { - pname = "persistent-test"; - version = "2.13.1.2"; - sha256 = "0cah2gyp5lm9hipm3wvcxnl14cmq51dajzcw3wcf9xd19sbm4k49"; - libraryHaskellDepends = [ - aeson base blaze-html bytestring conduit containers exceptions - hspec hspec-expectations http-api-data HUnit monad-control - monad-logger mtl path-pieces persistent QuickCheck - quickcheck-instances random resourcet text time transformers - transformers-base unliftio unliftio-core unordered-containers - ]; - description = "Tests for Persistent"; - license = lib.licenses.mit; - }) {}; - - "persistent-test_2_13_1_3" = callPackage ({ mkDerivation, aeson, base, blaze-html, bytestring, conduit , containers, exceptions, hspec, hspec-expectations, http-api-data , HUnit, monad-control, monad-logger, mtl, path-pieces, persistent @@ -224283,7 +223147,6 @@ self: { ]; description = "Tests for Persistent"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "persistent-typed-db" = callPackage @@ -224482,28 +223345,26 @@ self: { "pg-entity" = callPackage ({ mkDerivation, aeson, base, bytestring, colourista, containers - , exceptions, hedgehog, monad-control, mtl, optics-core, parsec - , pg-transact, postgresql-simple, postgresql-simple-migration - , resource-pool, safe-exceptions, tasty, tasty-hunit - , template-haskell, text, text-display, text-manipulate, time - , tmp-postgres, uuid, vector + , envparse, hedgehog, mtl, optics-core, parsec, pg-transact + , postgresql-migration, postgresql-simple, resource-pool + , safe-exceptions, tasty, tasty-hunit, template-haskell, text + , text-display, text-manipulate, time, uuid, vector }: mkDerivation { pname = "pg-entity"; - version = "0.0.4.2"; - sha256 = "0rdmdrch9q4sz23svsr52ymkllvfxi6kgc7mrfr0zdarah2sc8ip"; + version = "0.0.4.3"; + sha256 = "02dna5mq2jj988kdwi7shrx8xr5w4bi0g3bwbn1zmay2x8rn9zv3"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base bytestring colourista exceptions monad-control parsec - pg-transact postgresql-simple resource-pool safe-exceptions - template-haskell text text-display text-manipulate time uuid vector + base bytestring colourista parsec pg-transact postgresql-simple + resource-pool template-haskell text text-display text-manipulate + time uuid vector ]; testHaskellDepends = [ - aeson base containers hedgehog mtl optics-core pg-transact - postgresql-simple postgresql-simple-migration resource-pool - safe-exceptions tasty tasty-hunit text time tmp-postgres uuid - vector + aeson base bytestring containers envparse hedgehog mtl optics-core + pg-transact postgresql-migration postgresql-simple resource-pool + safe-exceptions tasty tasty-hunit text time uuid vector ]; description = "A pleasant PostgreSQL layer"; license = lib.licenses.mit; @@ -224856,33 +223717,6 @@ self: { }) {pHash = null;}; "phatsort" = callPackage - ({ mkDerivation, ansi-wl-pprint, base, directory, filepath, HMock - , MonadRandom, optparse-applicative, random-shuffle, tasty - , tasty-hunit, transformers, unix-compat - }: - mkDerivation { - pname = "phatsort"; - version = "0.5.0.1"; - sha256 = "14czx4s3ywfcxbw8lr60i3cdk62rcfr7m1v98mx3qm1gjinll5js"; - revision = "3"; - editedCabalFile = "087sz6ngczal2fp29gmiid52ypa1z99f8j8059p0wbjixs66hd39"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base directory filepath MonadRandom random-shuffle transformers - unix-compat - ]; - executableHaskellDepends = [ - ansi-wl-pprint base optparse-applicative - ]; - testHaskellDepends = [ - base HMock MonadRandom tasty tasty-hunit transformers - ]; - description = "FAT filesystem sort utility"; - license = lib.licenses.mit; - }) {}; - - "phatsort_0_6_0_0" = callPackage ({ mkDerivation, ansi-wl-pprint, base, directory, filepath, HMock , MonadRandom, optparse-applicative, random-shuffle, tasty , tasty-hunit, transformers, unix-compat @@ -224945,18 +223779,20 @@ self: { , phladiprelio-general-shared, phonetic-languages-constraints-array , phonetic-languages-permutations-array , phonetic-languages-phonetics-basics - , phonetic-languages-simplified-base, rhythmic-sequences + , phonetic-languages-simplified-base, rev-scientific + , rhythmic-sequences }: mkDerivation { pname = "phladiprelio-general-simple"; - version = "0.6.0.0"; - sha256 = "0wagsvc2wf6qk46lvvs84zb1cn8qvhvvwghc2qzs6bdk1jv8nk1a"; + version = "0.6.2.0"; + sha256 = "01l0cc82c3ndx0fwsslj74nqs4ippa6mw86lvbkb3mvcvn85ncj8"; libraryHaskellDepends = [ base cli-arguments directory halfsplit phladiprelio-general-shared phonetic-languages-constraints-array phonetic-languages-permutations-array phonetic-languages-phonetics-basics - phonetic-languages-simplified-base rhythmic-sequences + phonetic-languages-simplified-base rev-scientific + rhythmic-sequences ]; description = "A generalized functionality of PhLADiPreLiO for different languages that uses hash algorithms"; license = lib.licenses.mit; @@ -224996,22 +223832,30 @@ self: { , phonetic-languages-constraints-array , phonetic-languages-permutations-array , phonetic-languages-simplified-base - , phonetic-languages-ukrainian-array, rhythmic-sequences - , ukrainian-phonetics-basic-array + , phonetic-languages-ukrainian-array, rev-scientific + , rhythmic-sequences, ukrainian-phonetics-basic-array }: mkDerivation { pname = "phladiprelio-ukrainian-simple"; - version = "0.7.0.0"; - sha256 = "1x68wygghy825nigyqpi1lfqd89vdgiy91zdsvyzg42bdwraskjv"; - isLibrary = false; + version = "0.8.1.0"; + sha256 = "1alqcxbfirffaxcfp3hykh3vwpf4yr1kj7maipgj7p7az45arqy5"; + isLibrary = true; isExecutable = true; + libraryHaskellDepends = [ + base cli-arguments directory halfsplit + phladiprelio-ukrainian-shared phonetic-languages-constraints-array + phonetic-languages-permutations-array + phonetic-languages-simplified-base + phonetic-languages-ukrainian-array rev-scientific + rhythmic-sequences ukrainian-phonetics-basic-array + ]; executableHaskellDepends = [ base cli-arguments directory halfsplit phladiprelio-ukrainian-shared phonetic-languages-constraints-array phonetic-languages-permutations-array phonetic-languages-simplified-base - phonetic-languages-ukrainian-array rhythmic-sequences - ukrainian-phonetics-basic-array + phonetic-languages-ukrainian-array rev-scientific + rhythmic-sequences ukrainian-phonetics-basic-array ]; description = "A PhLADiPreLiO implementation for Ukrainian that uses hashes"; license = lib.licenses.mit; @@ -225065,7 +223909,9 @@ self: { ]; description = "Haskell Debug Adapter for Visual Studio Code"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "phoityne-vscode"; + broken = true; }) {}; "phone-metadata" = callPackage @@ -225360,8 +224206,8 @@ self: { }: mkDerivation { pname = "phonetic-languages-simplified-base"; - version = "0.7.0.0"; - sha256 = "0866pf3hyzhf2zygkk47n9yzm2z3mdm2asyq6fr8a34qrc9yyc4p"; + version = "0.7.1.0"; + sha256 = "1rjmkrlcfgv3n14y5rmg0sxnq409m3jxrjxvz8hznqprjalwkc79"; libraryHaskellDepends = [ base phonetic-languages-basis phonetic-languages-permutations-array subG @@ -226349,8 +225195,8 @@ self: { }: mkDerivation { pname = "ping"; - version = "0.1.0.4"; - sha256 = "0kj2fh6079xy20mk6ikjvmyb19zf21nglblhzazcmcbk921bmffm"; + version = "0.1.0.5"; + sha256 = "11zcdrji1m1b9rhi10fv4pr2cs488c13qb5nggi7abhkavzvxbzb"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -226414,8 +225260,8 @@ self: { }: mkDerivation { pname = "pinned-warnings"; - version = "0.1.0.14"; - sha256 = "167q5byrk6w69zalwlr6j6f7qqi83ykjbvdw95nd2yi7y76yq8yp"; + version = "0.1.0.15"; + sha256 = "11pyl3jj5myav19qky7hdbk39zfavj9gq3q911c4257lmd6480kp"; libraryHaskellDepends = [ base bytestring containers directory ghc time transformers ]; @@ -226585,25 +225431,6 @@ self: { }) {}; "pipes-attoparsec" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, HUnit, mmorph, pipes - , pipes-parse, tasty, tasty-hunit, text, transformers - }: - mkDerivation { - pname = "pipes-attoparsec"; - version = "0.5.1.5"; - sha256 = "1zfaj6jxmld95xi4yxyrj1wl31dqfw464ffyrm54rg4x513b97py"; - libraryHaskellDepends = [ - attoparsec base bytestring pipes pipes-parse text transformers - ]; - testHaskellDepends = [ - attoparsec base HUnit mmorph pipes pipes-parse tasty tasty-hunit - text transformers - ]; - description = "Attoparsec and Pipes integration"; - license = lib.licenses.bsd3; - }) {}; - - "pipes-attoparsec_0_6_0" = callPackage ({ mkDerivation, attoparsec, base, bytestring, HUnit, mmorph, pipes , pipes-parse, tasty, tasty-hunit, text, transformers }: @@ -226620,7 +225447,6 @@ self: { ]; description = "Attoparsec and Pipes integration"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "pipes-attoparsec-streaming" = callPackage @@ -226697,6 +225523,8 @@ self: { testHaskellDepends = [ base bytestring mtl pipes QuickCheck ]; description = "Pipes to group by any delimiter (such as lines with carriage returns)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-brotli" = callPackage @@ -227234,6 +226062,8 @@ self: { ]; description = "Pipes for grouping by lines with carriage returns"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pipes-lzma" = callPackage @@ -227255,7 +226085,9 @@ self: { ]; description = "LZMA compressors and decompressors for the Pipes package"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "pipes-lzma-unxz"; + broken = true; }) {}; "pipes-misc" = callPackage @@ -227912,6 +226744,7 @@ self: { description = "Haskell game engine like fantasy console"; license = lib.licenses.mit; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; mainProgram = "piyo-exe"; }) {}; @@ -229048,8 +227881,8 @@ self: { }: mkDerivation { pname = "pointfree"; - version = "1.1.1.10"; - sha256 = "14q5anaxhqwqhz3gc2vbs8hqnijg02s3py5kyifmwlh1smnx5ls2"; + version = "1.1.1.11"; + sha256 = "17xaxmyys7x1l3v3a72fdkb8klr0xp0mnh6aspfa7ysakagblnf0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -229670,45 +228503,14 @@ self: { pname = "polyparse"; version = "1.13"; sha256 = "0yvhg718dlksiw3v27m2d8m1sn4r4f5s0p56zq3lynhy1sc74k0w"; - revision = "6"; - editedCabalFile = "0xrmzz7p2akgdyr7gm54yvq83lm9qixcrk72ia2w9xcs2r4b76vz"; + revision = "7"; + editedCabalFile = "197q2c1nb38yn6cbcnj9dn03anwqrwf94bh03mpldw1w2vapd4ay"; libraryHaskellDepends = [ base bytestring text ]; description = "A variety of alternative parser combinator libraries"; license = "LGPL"; }) {}; "polysemy" = callPackage - ({ mkDerivation, async, base, Cabal, cabal-doctest, containers - , criterion, doctest, first-class-families, free, freer-simple - , hspec, hspec-discover, inspection-testing, mtl, QuickCheck, stm - , syb, template-haskell, th-abstraction, transformers, type-errors - , unagi-chan - }: - mkDerivation { - pname = "polysemy"; - version = "1.7.1.0"; - sha256 = "09629gyjdp567dsqk0mgzzk5glrwnpn0cwanank5z3zkqg05d5ac"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - async base containers first-class-families mtl QuickCheck stm syb - template-haskell th-abstraction transformers type-errors unagi-chan - ]; - testHaskellDepends = [ - async base containers doctest first-class-families hspec - inspection-testing mtl QuickCheck stm syb template-haskell - th-abstraction transformers type-errors unagi-chan - ]; - testToolDepends = [ hspec-discover ]; - benchmarkHaskellDepends = [ - async base containers criterion first-class-families free - freer-simple mtl QuickCheck stm syb template-haskell th-abstraction - transformers type-errors unagi-chan - ]; - description = "Higher-order, low-boilerplate free monads"; - license = lib.licenses.bsd3; - }) {}; - - "polysemy_1_9_1_0" = callPackage ({ mkDerivation, async, base, Cabal, cabal-doctest, containers , doctest, first-class-families, hspec, hspec-discover , inspection-testing, mtl, stm, syb, template-haskell @@ -229731,7 +228533,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Higher-order, low-boilerplate free monads"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "polysemy-RandomFu" = callPackage @@ -229896,6 +228697,7 @@ self: { ]; description = "Extra Input and Output functions for polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-fs" = callPackage @@ -229928,6 +228730,7 @@ self: { ]; description = "Run a KVStore as a filesystem in polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-hasql" = callPackage @@ -229986,8 +228789,8 @@ self: { }: mkDerivation { pname = "polysemy-http"; - version = "0.11.0.0"; - sha256 = "09w6kjby09dkq8rdynl6ha193jalvxnx9hkmy5lgdmkn0wb1aj6g"; + version = "0.12.0.0"; + sha256 = "016z753yk9ix8vqbmkll67pp2w2qznnbbayvi7x8q6cwm464cavq"; libraryHaskellDepends = [ aeson base case-insensitive exon http-client http-client-tls http-types polysemy polysemy-plugin prelate time @@ -230033,6 +228836,8 @@ self: { libraryHaskellDepends = [ base containers polysemy ]; description = "KVStore effect for polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polysemy-kvstore-jsonfile" = callPackage @@ -230142,6 +228947,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Primitive functions and data types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polysemy-methodology" = callPackage @@ -230156,6 +228963,7 @@ self: { ]; description = "Domain modelling algebra for polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-methodology-co-log" = callPackage @@ -230222,6 +229030,7 @@ self: { libraryHaskellDepends = [ base optics polysemy polysemy-zoo ]; description = "Optics for Polysemy"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-path" = callPackage @@ -230379,6 +229188,8 @@ self: { libraryHaskellDepends = [ base polysemy ]; description = "Run several effects at once, taken from the polysemy-zoo"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "polysemy-socket" = callPackage @@ -230443,6 +229254,7 @@ self: { libraryHaskellDepends = [ base polysemy polysemy-methodology ]; description = "Uncontrolled toy effect for polysemy"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "polysemy-video" = callPackage @@ -230493,11 +229305,11 @@ self: { }: mkDerivation { pname = "polysemy-webserver"; - version = "0.2.1.1"; - sha256 = "126c4bw0gj9knvqn67yldzy90cp08hmc70ip85vsfl3njd0ayj33"; + version = "0.2.1.2"; + sha256 = "0psxcrd4pbvnp8g8yijy967w4d9pxjjsihj727wzg8xlsrm20d54"; libraryHaskellDepends = [ - base bytestring http-types polysemy polysemy-plugin wai - wai-websockets warp websockets + base bytestring http-types polysemy wai wai-websockets warp + websockets ]; testHaskellDepends = [ base bytestring hspec http-conduit http-types polysemy @@ -230530,6 +229342,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 @@ -230604,6 +229418,8 @@ self: { testHaskellDepends = [ base ]; description = "Creation and application of polyvariadic functions"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pomaps" = callPackage @@ -230791,6 +229607,8 @@ self: { ]; description = "XEPs implementation on top of pontarius-xmpp"; license = "unknown"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pontarius-xpmn" = callPackage @@ -230937,6 +229755,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 @@ -231360,6 +230180,8 @@ self: { ]; description = "A product-of-sums generics library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "poseidon" = callPackage @@ -231407,17 +230229,17 @@ self: { }) {}; "posit" = callPackage - ({ mkDerivation, base, data-dword, deepseq, random, scientific - , vector, weigh + ({ mkDerivation, base, Chart, Chart-cairo, data-dword, deepseq + , random, scientific, vector, weigh }: mkDerivation { pname = "posit"; - version = "2022.0.1.0"; - sha256 = "0gqrc0gq9d9wb94r8nm81b2yzmnvivqc8ppni59a1k1v95m3lb6c"; + version = "2022.0.1.4"; + sha256 = "0sqs9ya0jvviwcd7ggclz09amzgkdkvakkr2pszmd6zh96q07nnw"; libraryHaskellDepends = [ base data-dword deepseq random scientific ]; - testHaskellDepends = [ base ]; + testHaskellDepends = [ base Chart Chart-cairo ]; benchmarkHaskellDepends = [ base vector weigh ]; description = "Posit Numbers"; license = lib.licenses.bsd3; @@ -231477,26 +230299,25 @@ self: { "posix-api" = callPackage ({ mkDerivation, base, byte-order, byteslice, primitive , primitive-addr, primitive-offset, primitive-unlifted, run-st - , systemd, tasty, tasty-hunit + , tasty, tasty-hunit, text-short }: mkDerivation { pname = "posix-api"; - version = "0.4.0.0"; - sha256 = "0j4iz6llg8qgi5jfg51asimw3qwzwlacj6ac0rm0a2g0756wf7mv"; - revision = "1"; - editedCabalFile = "0plx34kwsrym9n93k4vp319qiks39sasdnzjkzxx2rvcl0snvpxb"; + version = "0.6.0.1"; + sha256 = "0c39ghbnimsl4m9gn8lsr09ii0xn4ahqbid74jiig1cw931y0xap"; libraryHaskellDepends = [ base byte-order byteslice primitive primitive-addr primitive-offset - primitive-unlifted run-st + primitive-unlifted run-st text-short ]; - librarySystemDepends = [ systemd ]; testHaskellDepends = [ base primitive primitive-unlifted tasty tasty-hunit ]; description = "posix bindings"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; - }) {inherit (pkgs) systemd;}; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; "posix-error-codes" = callPackage ({ mkDerivation, base }: @@ -231633,7 +230454,9 @@ self: { ]; description = "Sleep tracker for X11, using XScreenSaver extension and manual input"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "posplyu"; + broken = true; }) {}; "possible" = callPackage @@ -231842,6 +230665,8 @@ self: { ]; description = "Types for easy adding postgresql configuration to your program"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "postgresql-connector" = callPackage @@ -232203,10 +231028,8 @@ self: { }: mkDerivation { pname = "postgresql-simple"; - version = "0.6.4"; - sha256 = "0rz2bklxp4pvbxb2w49h5p6pbwabn6d5d4j4mrya4fpa0d13k43d"; - revision = "8"; - editedCabalFile = "1qavb3qs1g307pc19k9y3yvqp0c1srwsplijvayn9ldp0bxdy6q8"; + version = "0.6.5.1"; + sha256 = "0v0v34a5p6as8zv96dgjk082lq9p5iij1p0jnz8wcyfjfc5l2qf8"; libraryHaskellDepends = [ aeson attoparsec base bytestring bytestring-builder case-insensitive containers hashable Only postgresql-libpq @@ -232224,38 +231047,6 @@ self: { maintainers = [ lib.maintainers.maralorn ]; }) {}; - "postgresql-simple_0_6_5" = callPackage - ({ mkDerivation, aeson, attoparsec, base, base16-bytestring - , bytestring, bytestring-builder, case-insensitive, containers - , cryptohash-md5, filepath, hashable, HUnit, inspection-testing - , Only, postgresql-libpq, scientific, tasty, tasty-golden - , tasty-hunit, template-haskell, text, time-compat, transformers - , uuid-types, vector - }: - mkDerivation { - pname = "postgresql-simple"; - version = "0.6.5"; - sha256 = "15jy8lp9200whyxk421yw3m671cjz41cnv2j8wll1giblyr3m9gx"; - revision = "1"; - editedCabalFile = "0yiqbac742vyhnd9kz390amkfa1dshqm76hf9nsam27cq7h7m7i5"; - libraryHaskellDepends = [ - aeson attoparsec base bytestring bytestring-builder - case-insensitive containers hashable Only postgresql-libpq - scientific template-haskell text time-compat transformers - uuid-types vector - ]; - testHaskellDepends = [ - aeson base base16-bytestring bytestring case-insensitive containers - cryptohash-md5 filepath HUnit inspection-testing postgresql-libpq - tasty tasty-golden tasty-hunit text time-compat vector - ]; - benchmarkHaskellDepends = [ base vector ]; - description = "Mid-Level PostgreSQL client library"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - "postgresql-simple-bind" = callPackage ({ mkDerivation, attoparsec, base, bytestring, data-default , exceptions, heredoc, hspec, postgresql-simple, template-haskell @@ -232621,6 +231412,37 @@ self: { license = lib.licenses.bsd3; }) {}; + "postgresql-typed_0_6_2_4" = callPackage + ({ mkDerivation, aeson, array, attoparsec, base, binary, bytestring + , containers, convertible, criterion, crypton, crypton-x509 + , crypton-x509-store, crypton-x509-validation, data-default + , haskell-src-meta, HDBC, HUnit, memory, network, old-locale + , postgresql-binary, QuickCheck, scientific, template-haskell, text + , time, tls, utf8-string, uuid + }: + mkDerivation { + pname = "postgresql-typed"; + version = "0.6.2.4"; + sha256 = "1wdwdghgnh6fip1pi220vnksc2g302g9v2wv2xi9yb0prs29xmsm"; + libraryHaskellDepends = [ + aeson array attoparsec base binary bytestring containers crypton + crypton-x509 crypton-x509-store crypton-x509-validation + data-default haskell-src-meta HDBC memory network old-locale + postgresql-binary scientific template-haskell text time tls + utf8-string uuid + ]; + testHaskellDepends = [ + base bytestring containers convertible HDBC HUnit network + QuickCheck time tls + ]; + benchmarkHaskellDepends = [ + base bytestring criterion network time tls + ]; + description = "PostgreSQL interface with compile-time SQL type checking, optional HDBC backend"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "postgresql-typed-lifted" = callPackage ({ mkDerivation, base, base-unicode-symbols, bytestring, exceptions , lens, monad-control, postgresql-typed, transformers-base @@ -232681,6 +231503,7 @@ self: { ]; description = "REST API for any Postgres database"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "postgrest"; }) {}; @@ -232767,8 +231590,8 @@ self: { }: mkDerivation { pname = "postmark-streams"; - version = "0.1.0.3"; - sha256 = "1qcyh34rjfgjxi6cs7jrfhr1qdp2chngga1p71jxisbgfd7rk2b4"; + version = "0.1.0.4"; + sha256 = "0kqsjr9qrp6hbvn4z7qfmig014fn9z606dl78f9b79fvx8qq9bij"; libraryHaskellDepends = [ aeson attoparsec base base64-bytestring binary bytestring http-streams io-streams text time @@ -233507,23 +232330,6 @@ self: { }) {}; "prefix-units" = callPackage - ({ mkDerivation, base, Cabal, HUnit, QuickCheck, test-framework - , test-framework-hunit, test-framework-quickcheck2 - }: - mkDerivation { - pname = "prefix-units"; - version = "0.2.0"; - sha256 = "1173fj11rb42l239xj8j0q12dclvspxrbc984r503gd54zwbs2h5"; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ - base Cabal HUnit QuickCheck test-framework test-framework-hunit - test-framework-quickcheck2 - ]; - description = "A basic library for SI/binary prefix units"; - license = lib.licenses.bsd3; - }) {}; - - "prefix-units_0_3_0_1" = callPackage ({ mkDerivation, base, Cabal, deepseq, HUnit, QuickCheck , test-framework, test-framework-hunit, test-framework-quickcheck2 }: @@ -233540,7 +232346,6 @@ self: { ]; description = "A basic library for SI/IEC prefix units"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "prefork" = callPackage @@ -233591,16 +232396,16 @@ self: { ({ mkDerivation, aeson, base, exon, extra, generic-lens, incipit , microlens, microlens-ghc, polysemy-chronos, polysemy-conc , polysemy-log, polysemy-process, polysemy-resume, polysemy-time - , template-haskell + , template-haskell, zeugma }: mkDerivation { pname = "prelate"; - version = "0.5.1.0"; - sha256 = "1hrak2qylnd6dgla0zs9623qnlcyz7lm5mkiw6nqqzh66zn4yxqc"; + version = "0.6.0.0"; + sha256 = "1scwlszwk0gscxwlpn31k1iqillfy0agp0pqpxnfp1z1krma5mjj"; libraryHaskellDepends = [ aeson base exon extra generic-lens incipit microlens microlens-ghc polysemy-chronos polysemy-conc polysemy-log polysemy-process - polysemy-resume polysemy-time template-haskell + polysemy-resume polysemy-time template-haskell zeugma ]; description = "A Prelude"; license = "BSD-2-Clause-Patent"; @@ -233965,6 +232770,7 @@ self: { ]; description = "Pretty printing a diff of two values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "pretty-display" = callPackage @@ -234059,6 +232865,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Tracking and highlighting of locations in source files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pretty-ncols" = callPackage @@ -234424,8 +233232,8 @@ self: { pname = "prettyprinter-lucid"; version = "0.1.0.1"; sha256 = "0m8dbxzs22zbahpr6r1frlfqyw581wyg92vswm3gi2qqpj406djh"; - revision = "2"; - editedCabalFile = "1npha7497c9zgwjnncd0jxmrrsywpsd47h5kimg8zf2z56bgsl7s"; + revision = "3"; + editedCabalFile = "01ngq4fx3d5xpy0kxfragajjp746dhighsvmcyjwyb65w1z8fflq"; libraryHaskellDepends = [ base lucid prettyprinter text ]; description = "A prettyprinter backend for lucid"; license = lib.licenses.bsd3; @@ -234658,29 +233466,6 @@ self: { }) {inherit (pkgs) primesieve;}; "primitive" = callPackage - ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck - , quickcheck-classes-base, tagged, tasty, tasty-bench - , tasty-quickcheck, transformers, transformers-compat - }: - mkDerivation { - pname = "primitive"; - version = "0.7.3.0"; - sha256 = "1p01fmw8yi578rvwicrlpbfkbfsv7fbnzb88a7vggrhygykgs31w"; - revision = "2"; - editedCabalFile = "0xh1m8nybz760c71gm1w9fga25y2rys1211q77v6wagdsas634yf"; - libraryHaskellDepends = [ base deepseq transformers ]; - testHaskellDepends = [ - base base-orphans ghc-prim QuickCheck quickcheck-classes-base - tagged tasty tasty-quickcheck transformers transformers-compat - ]; - benchmarkHaskellDepends = [ - base deepseq tasty-bench transformers - ]; - description = "Primitive memory-related operations"; - license = lib.licenses.bsd3; - }) {}; - - "primitive_0_7_4_0" = callPackage ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck , quickcheck-classes-base, tagged, tasty, tasty-bench , tasty-quickcheck, template-haskell, transformers @@ -234688,10 +233473,8 @@ self: { }: mkDerivation { pname = "primitive"; - version = "0.7.4.0"; - sha256 = "1mddh42i6xg02z315c4lg3zsxlr3wziwnpzh2nhzdcifh716sbav"; - revision = "1"; - editedCabalFile = "0av20kv9ib795qr62yzby5l46vhkifzc6fdj8cppzsfwnfbyvw62"; + version = "0.8.0.0"; + sha256 = "0pwr5g3bra5m2zjm14pj98klqj2qrjcfasgd3rcrp7vq98dw4lsm"; libraryHaskellDepends = [ base deepseq template-haskell transformers ]; @@ -234704,32 +233487,6 @@ self: { ]; description = "Primitive memory-related operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - - "primitive_0_8_0_0" = callPackage - ({ mkDerivation, base, base-orphans, data-array-byte, deepseq - , ghc-prim, QuickCheck, quickcheck-classes-base, tagged, tasty - , tasty-bench, tasty-quickcheck, template-haskell, transformers - , transformers-compat - }: - mkDerivation { - pname = "primitive"; - version = "0.8.0.0"; - sha256 = "0pwr5g3bra5m2zjm14pj98klqj2qrjcfasgd3rcrp7vq98dw4lsm"; - libraryHaskellDepends = [ - base data-array-byte deepseq template-haskell transformers - ]; - testHaskellDepends = [ - base base-orphans ghc-prim QuickCheck quickcheck-classes-base - tagged tasty tasty-quickcheck transformers transformers-compat - ]; - benchmarkHaskellDepends = [ - base deepseq tasty-bench transformers - ]; - description = "Primitive memory-related operations"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "primitive-addr" = callPackage @@ -234768,6 +233525,8 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "primitive functions with bounds-checking"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-containers" = callPackage @@ -234778,8 +233537,8 @@ self: { }: mkDerivation { pname = "primitive-containers"; - version = "0.4.1"; - sha256 = "1gi4fbxdhlzdyi9nnfmfyxl012hs5bam2kgvv8240mq5kxgimf06"; + version = "0.5.1"; + sha256 = "057x0l6zyhffim37v8q63ancwg8jl2sfn8hmrwy3kmn9cnh2zw94"; libraryHaskellDepends = [ base contiguous deepseq hashable primitive primitive-sort primitive-unlifted @@ -234817,8 +233576,8 @@ self: { }: mkDerivation { pname = "primitive-extras"; - version = "0.10.1.6"; - sha256 = "1lxb5yfpxj038fs7l5jjj3i4k9frjnlbki5kjgf0mbpcyfv6s0rr"; + version = "0.10.1.7"; + sha256 = "0z3l1hcnqbzz14k3j4ylfh48v048l0y9waa6k447x8vqrkbrzm56"; libraryHaskellDepends = [ base bytestring cereal deferred-folds focus foldl list-t primitive primitive-unlifted profunctors vector @@ -234897,6 +233656,19 @@ self: { libraryHaskellDepends = [ base primitive ]; description = "Unboxed variables for `Prim` values"; license = lib.licenses.cc0; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + + "primitive-serial" = callPackage + ({ mkDerivation, base, bytestring, cpu }: + mkDerivation { + pname = "primitive-serial"; + version = "0.1"; + sha256 = "108vkngsq8xfxwgz45xnh07d6iids48wk9bm3mgk1q1sw8bb6zda"; + libraryHaskellDepends = [ base bytestring cpu ]; + description = "Serialisation of primitive types"; + license = lib.licenses.bsd2; }) {}; "primitive-simd" = callPackage @@ -234924,6 +233696,8 @@ self: { libraryHaskellDepends = [ base primitive primitive-unlifted ]; description = "Slices of primitive arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "primitive-sort" = callPackage @@ -234990,6 +233764,26 @@ self: { license = lib.licenses.bsd3; }) {}; + "primitive-unlifted_2_1_0_0" = callPackage + ({ mkDerivation, array, base, bytestring, primitive, QuickCheck + , quickcheck-classes-base, stm, tasty, tasty-quickcheck, text-short + }: + mkDerivation { + pname = "primitive-unlifted"; + version = "2.1.0.0"; + sha256 = "07ix39sraijgajprpzdbnl67m8ghixxbqg93k4m02k1gi83j2d31"; + libraryHaskellDepends = [ + array base bytestring primitive text-short + ]; + testHaskellDepends = [ + base primitive QuickCheck quickcheck-classes-base stm tasty + tasty-quickcheck + ]; + description = "Primitive GHC types with unlifted types inside"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "primula-board" = callPackage ({ mkDerivation, base, ConfigFile, containers, directory, happstack , happstack-helpers, happstack-server, happstack-state, hsp @@ -235290,6 +234084,8 @@ self: { doHaddock = false; description = "Abstract syntax for writing documents"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pro-source" = callPackage @@ -235311,6 +234107,8 @@ self: { ]; description = "Utilities for tracking source locations"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prob" = callPackage @@ -235901,7 +234699,9 @@ self: { ]; description = "Treemap visualiser for GHC prof files"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "profiteur"; + broken = true; }) {}; "profunctor-arrows" = callPackage @@ -236158,8 +234958,8 @@ self: { }: mkDerivation { pname = "project-m36"; - version = "0.9.6"; - sha256 = "067z934phddvi7r4kp3b1ykfz62vak395j9wlwm36m9rn526ih8g"; + version = "0.9.7"; + sha256 = "0jybyl0nwyfzb8hfhik4cmipnk9xrnq3zw1917k2hc3qzfs162b4"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -236411,6 +235211,8 @@ self: { ]; description = "Prometheus Haskell Client"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "prometheus-client" = callPackage @@ -236524,6 +235326,7 @@ self: { ]; description = "Instrument a wai application with various metrics"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "prometheus-wai-middleware-example"; }) {}; @@ -236632,6 +235435,8 @@ self: { ]; description = "Conveniences for using Hedgehog as a unit test runner"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "propane" = callPackage @@ -236852,7 +235657,7 @@ self: { "proteaaudio" = callPackage ({ mkDerivation, base, bytestring, c2hs, libpulse, libpulse-simple - , libpulseaudio + , libpulseaudio, system-cxx-std-lib }: mkDerivation { pname = "proteaaudio"; @@ -236860,7 +235665,7 @@ self: { sha256 = "1vgrwx36liqkshrfqkrb38nsbq84a6fbnmn0p2v0y76iccd2shid"; isLibrary = true; isExecutable = true; - libraryHaskellDepends = [ base bytestring ]; + libraryHaskellDepends = [ base bytestring system-cxx-std-lib ]; librarySystemDepends = [ libpulseaudio ]; libraryPkgconfigDepends = [ libpulse libpulse-simple ]; libraryToolDepends = [ c2hs ]; @@ -236872,21 +235677,20 @@ self: { inherit (pkgs) libpulseaudio;}; "proteaaudio-sdl" = callPackage - ({ mkDerivation, base, bytestring, c2hs, SDL2 }: + ({ mkDerivation, base, bytestring, c2hs, SDL2, system-cxx-std-lib + }: mkDerivation { pname = "proteaaudio-sdl"; version = "0.9.3"; sha256 = "117fn2a5821ifl4yv94bwiylbnbhriqgjdl9c4685z98m0n9ryap"; isLibrary = true; isExecutable = true; - libraryHaskellDepends = [ base bytestring ]; + libraryHaskellDepends = [ base bytestring system-cxx-std-lib ]; librarySystemDepends = [ SDL2 ]; libraryPkgconfigDepends = [ SDL2 ]; libraryToolDepends = [ c2hs ]; description = "Simple audio library for SDL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) SDL2;}; "proteome" = callPackage @@ -236956,6 +235760,8 @@ self: { ]; description = "Arbitrary instances for proto-lens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "proto-lens-combinators" = callPackage @@ -237043,6 +235849,7 @@ self: { libraryToolDepends = [ proto-lens-protoc protobuf ]; description = "Basic protocol buffer message types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) protobuf;}; "proto-lens-protoc" = callPackage @@ -237064,6 +235871,7 @@ self: { ]; description = "Protocol buffer compiler for the proto-lens library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "proto-lens-protoc"; }) {inherit (pkgs) protobuf;}; @@ -237097,34 +235905,37 @@ self: { ]; description = "Cabal support for codegen with proto-lens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "proto3-suite" = callPackage ({ mkDerivation, aeson, aeson-pretty, attoparsec, base , base64-bytestring, binary, bytestring, cereal, containers - , contravariant, deepseq, doctest, filepath, foldl + , contravariant, deepseq, dhall, doctest, filepath, foldl , generic-arbitrary, hashable, haskell-src, hedgehog - , insert-ordered-containers, lens, mtl, neat-interpolation - , optparse-applicative, optparse-generic, parsec, parsers, pretty - , pretty-show, proto3-wire, QuickCheck, quickcheck-instances - , range-set-list, safe, swagger2, system-filepath, tasty - , tasty-hedgehog, tasty-hunit, tasty-quickcheck, text, time - , transformers, turtle, vector + , insert-ordered-containers, large-generics, large-records, lens + , mtl, neat-interpolation, optparse-applicative, optparse-generic + , parsec, parsers, pretty, pretty-show, proto3-wire, QuickCheck + , quickcheck-instances, range-set-list, safe, split, swagger2 + , system-filepath, tasty, tasty-hedgehog, tasty-hunit + , tasty-quickcheck, text, text-short, time, transformers, turtle + , vector }: mkDerivation { pname = "proto3-suite"; - version = "0.5.1"; - sha256 = "0dgcmifz7p3g4gnyjnfm8gh48l3yhpixklscmfrv027lnc0awi6r"; + version = "0.6.0"; + sha256 = "041hjvhfdbr3lzlzrnz444pqdr3qwjx5d4kf890h4dm5mks4hi5j"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; libraryHaskellDepends = [ aeson aeson-pretty attoparsec base base64-bytestring binary - bytestring cereal containers contravariant deepseq filepath foldl - hashable haskell-src insert-ordered-containers lens mtl - neat-interpolation parsec parsers pretty pretty-show proto3-wire - QuickCheck quickcheck-instances safe swagger2 system-filepath text - time transformers turtle vector + bytestring cereal containers contravariant deepseq dhall filepath + foldl hashable haskell-src insert-ordered-containers large-generics + large-records lens mtl neat-interpolation parsec parsers pretty + pretty-show proto3-wire QuickCheck quickcheck-instances safe split + swagger2 system-filepath text text-short time transformers turtle + vector ]; executableHaskellDepends = [ base containers mtl optparse-applicative optparse-generic @@ -237132,9 +235943,10 @@ self: { ]; testHaskellDepends = [ aeson attoparsec base base64-bytestring bytestring cereal - containers deepseq doctest generic-arbitrary hedgehog mtl - pretty-show proto3-wire QuickCheck swagger2 tasty tasty-hedgehog - tasty-hunit tasty-quickcheck text transformers turtle vector + containers deepseq doctest generic-arbitrary hedgehog + large-generics large-records mtl parsec pretty pretty-show + proto3-wire QuickCheck swagger2 tasty tasty-hedgehog tasty-hunit + tasty-quickcheck text text-short transformers turtle vector ]; description = "A higher-level API to the proto3-wire library"; license = lib.licenses.asl20; @@ -237768,7 +236580,9 @@ self: { executableHaskellDepends = [ base text ]; description = "A Haskell Implementation of the Porter Stemmer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "pstemmer-test-exe"; + broken = true; }) {}; "psx" = callPackage @@ -237896,21 +236710,6 @@ self: { }) {}; "ptr-poker" = callPackage - ({ mkDerivation, base, bytestring, gauge, hedgehog, numeric-limits - , rerebase, scientific, text - }: - mkDerivation { - pname = "ptr-poker"; - version = "0.1.2.8"; - sha256 = "10bbfw0jdzvds4j6qcgppn4l7xflqa2578w6sqmz807mwr563f8c"; - libraryHaskellDepends = [ base bytestring scientific text ]; - testHaskellDepends = [ hedgehog numeric-limits rerebase ]; - benchmarkHaskellDepends = [ gauge rerebase ]; - description = "Pointer poking action construction and composition toolkit"; - license = lib.licenses.mit; - }) {}; - - "ptr-poker_0_1_2_13" = callPackage ({ mkDerivation, base, bytestring, criterion, hedgehog , isomorphism-class, numeric-limits, rerebase, scientific, text }: @@ -237925,7 +236724,6 @@ self: { benchmarkHaskellDepends = [ criterion rerebase ]; description = "Pointer poking action construction and composition toolkit"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "ptrdiff" = callPackage @@ -238503,8 +237301,8 @@ self: { executableHaskellDepends = [ base ]; description = "Nix backend for PureScript. Transpile PureScript code to Nix."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "purenix"; - maintainers = [ lib.maintainers.cdepillabout ]; }) {}; "purescheme-wai-routing-core" = callPackage @@ -238548,8 +237346,8 @@ self: { }: mkDerivation { pname = "purescript"; - version = "0.15.9"; - sha256 = "1i9wszs5kwwq0l8l4if05y8xc8fih10assrdj8q1ipr0hx3zjawm"; + version = "0.15.10"; + sha256 = "08pashk8pm4yjsaq2g94sqa2yd3rfq9fwpxa9qccvjv6in9zybf1"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -238594,6 +237392,7 @@ self: { doCheck = false; description = "PureScript Programming Language Compiler"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "purs"; }) {}; @@ -238617,26 +237416,6 @@ self: { }) {}; "purescript-bridge" = callPackage - ({ mkDerivation, base, containers, directory, filepath - , generic-deriving, hspec, hspec-expectations-pretty-diff, lens - , mtl, text, transformers - }: - mkDerivation { - pname = "purescript-bridge"; - version = "0.14.0.0"; - sha256 = "1gplvmkx2c8ksk25wdinhwwbmqa5czbd4nwdgn4sa9ci10f2i4a3"; - libraryHaskellDepends = [ - base containers directory filepath generic-deriving lens mtl text - transformers - ]; - testHaskellDepends = [ - base containers hspec hspec-expectations-pretty-diff text - ]; - description = "Generate PureScript data types from Haskell data types"; - license = lib.licenses.bsd3; - }) {}; - - "purescript-bridge_0_15_0_0" = callPackage ({ mkDerivation, base, containers, directory, filepath , generic-deriving, hspec, hspec-expectations-pretty-diff, lens , mtl, text, transformers @@ -238654,7 +237433,6 @@ self: { ]; description = "Generate PureScript data types from Haskell data types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "purescript-bundle-fast" = callPackage @@ -238789,6 +237567,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Build server rendered, interactive websites"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "push-notifications" = callPackage @@ -238859,6 +237639,7 @@ self: { testHaskellDepends = [ aeson base hspec ]; description = "Send push notifications to mobile iOS devices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "sendapn"; }) {}; @@ -238962,8 +237743,8 @@ self: { }: mkDerivation { pname = "pusher-http-haskell"; - version = "2.1.0.13"; - sha256 = "0cpi0fpijimhmgzis6ghij5ascadlhwdwmanaap0zjpr8n7wwv15"; + version = "2.1.0.15"; + sha256 = "1h88xbx9wvbay5pg82329amsrbkgmm8whf96jknzjk3gd6h952fg"; libraryHaskellDepends = [ aeson base base16-bytestring bytestring cryptonite hashable http-client http-client-tls http-types memory text time @@ -239178,6 +237959,8 @@ self: { ]; description = "Fast persistent vectors"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "pvss" = callPackage @@ -240339,6 +239122,7 @@ self: { description = "QUIC"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quick-generator" = callPackage @@ -240509,17 +239293,21 @@ self: { sha256 = "0qdjls949kmcv8wj3a27p4dz8nb1dq4i99zizkw7qyqn47r9ccxd"; libraryHaskellDepends = [ base QuickCheck unfoldable-restricted ]; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-dynamic" = callPackage ({ mkDerivation, base, containers, mtl, QuickCheck, random }: mkDerivation { pname = "quickcheck-dynamic"; - version = "3.1.0"; - sha256 = "01vav51fdzvbw9i4zkknx3dwla1p2da8v07kr4brlb3vbdb3c1kf"; + version = "3.1.1"; + sha256 = "0vpf98a2zqqrn96cdwfbgjlf61grn6rb5aylm7ywjwcqmi3bwzkn"; libraryHaskellDepends = [ base containers mtl QuickCheck random ]; description = "A library for stateful property-based testing"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "quickcheck-enum-instances" = callPackage @@ -240534,6 +239322,30 @@ self: { }) {}; "quickcheck-groups" = callPackage + ({ mkDerivation, base, groups, hspec, hspec-discover, pretty-show + , QuickCheck, quickcheck-classes, quickcheck-instances + , semigroupoids + }: + mkDerivation { + pname = "quickcheck-groups"; + version = "0.0.0.0"; + sha256 = "0ranwc1p7ps4f1ivbaxz18h98f3jh29hfw94zi11a27zqdyfscbg"; + libraryHaskellDepends = [ + base groups pretty-show QuickCheck quickcheck-classes + quickcheck-instances semigroupoids + ]; + testHaskellDepends = [ + base groups hspec QuickCheck quickcheck-classes + ]; + testToolDepends = [ hspec-discover ]; + doHaddock = false; + description = "Testing group class instances with QuickCheck"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + + "quickcheck-groups_0_0_1_0" = callPackage ({ mkDerivation, base, groups, hspec, hspec-discover, pretty-show , QuickCheck, quickcheck-classes, quickcheck-instances , semigroupoids @@ -240573,11 +239385,10 @@ self: { "quickcheck-instances" = callPackage ({ mkDerivation, array, base, bytestring, case-insensitive - , containers, data-array-byte, data-fix, hashable - , integer-logarithms, old-time, OneTuple, primitive, QuickCheck - , scientific, splitmix, strict, tagged, text, text-short, these - , time, time-compat, transformers, transformers-compat - , unordered-containers, uuid-types, vector + , containers, data-fix, hashable, integer-logarithms, old-time + , OneTuple, primitive, QuickCheck, scientific, splitmix, strict + , tagged, text, text-short, these, time, time-compat, transformers + , transformers-compat, unordered-containers, uuid-types, vector }: mkDerivation { pname = "quickcheck-instances"; @@ -240586,15 +239397,14 @@ self: { revision = "2"; editedCabalFile = "118xy4z4dy4bpkzsp98daiv3l4n5j7ph9my0saca7cqjybqwkcip"; libraryHaskellDepends = [ - array base bytestring case-insensitive containers data-array-byte - data-fix hashable integer-logarithms old-time OneTuple primitive - QuickCheck scientific splitmix strict tagged text text-short these - time time-compat transformers transformers-compat - unordered-containers uuid-types vector + array base bytestring case-insensitive containers data-fix hashable + integer-logarithms old-time OneTuple primitive QuickCheck + scientific splitmix strict tagged text text-short these time + time-compat transformers transformers-compat unordered-containers + uuid-types vector ]; testHaskellDepends = [ - base containers data-array-byte primitive QuickCheck tagged - uuid-types + base containers primitive QuickCheck tagged uuid-types ]; benchmarkHaskellDepends = [ base bytestring QuickCheck ]; description = "Common quickcheck instances"; @@ -240635,6 +239445,33 @@ self: { }) {}; "quickcheck-monoid-subclasses" = callPackage + ({ mkDerivation, base, bytestring, commutative-semigroups + , containers, hspec, hspec-discover, monoid-subclasses, pretty-show + , QuickCheck, quickcheck-classes, quickcheck-instances + , semigroupoids, text, vector + }: + mkDerivation { + pname = "quickcheck-monoid-subclasses"; + version = "0.1.0.0"; + sha256 = "19q4h9s1m72vd0yrk7a9ikjik17hcrcnpgy461zw2zkijg68a0sm"; + libraryHaskellDepends = [ + base containers monoid-subclasses pretty-show QuickCheck + quickcheck-classes quickcheck-instances semigroupoids + ]; + testHaskellDepends = [ + base bytestring commutative-semigroups containers hspec + monoid-subclasses QuickCheck quickcheck-classes + quickcheck-instances text vector + ]; + testToolDepends = [ hspec-discover ]; + doHaddock = false; + description = "Testing monoid subclass instances with QuickCheck"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + + "quickcheck-monoid-subclasses_0_3_0_0" = callPackage ({ mkDerivation, base, bytestring, commutative-semigroups , containers, hspec, hspec-discover, monoid-subclasses, pretty-show , QuickCheck, quickcheck-classes, quickcheck-instances @@ -241734,6 +240571,7 @@ self: { executableHaskellDepends = [ base ]; description = "A library and program to create QIF files from Rabobank CSV exports"; license = "GPL"; + hydraPlatforms = lib.platforms.none; mainProgram = "rabocsv2qif"; }) {}; @@ -242384,6 +241222,8 @@ self: { benchmarkHaskellDepends = [ base criterion random vector ]; description = "Uniform draws of partitions and cycle-partitions, with thinning"; license = lib.licenses.gpl3Plus; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "random-derive" = callPackage @@ -242712,19 +241552,6 @@ self: { }) {}; "ranged-list" = callPackage - ({ mkDerivation, base, doctest, typecheck-plugin-nat-simple }: - mkDerivation { - pname = "ranged-list"; - version = "0.1.2.0"; - sha256 = "0ry2l6379g1q8y22hziqscsxv134k26a28aqvlxjyliqkx707b9i"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ base typecheck-plugin-nat-simple ]; - testHaskellDepends = [ base doctest typecheck-plugin-nat-simple ]; - description = "The list like structure whose length or range of length can be specified"; - license = lib.licenses.bsd3; - }) {}; - - "ranged-list_0_1_2_1" = callPackage ({ mkDerivation, base, doctest, typecheck-plugin-nat-simple }: mkDerivation { pname = "ranged-list"; @@ -242735,7 +241562,6 @@ self: { testHaskellDepends = [ base doctest typecheck-plugin-nat-simple ]; description = "The list like structure whose length or range of length can be specified"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "rangemin" = callPackage @@ -242829,8 +241655,8 @@ self: { }: mkDerivation { pname = "rank2classes"; - version = "1.4.6"; - sha256 = "09wpjan20m6icrw7v41dn85kapy6ijz2mm17iw2pp51c4h9c09ci"; + version = "1.5.2"; + sha256 = "1qhb6ijziq3g58qs3b22k1cg8601a4vd4vaka6cq0ny5x8x54b8v"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ base data-functor-logistic distributive template-haskell @@ -242844,29 +241670,6 @@ self: { license = lib.licenses.bsd3; }) {}; - "rank2classes_1_5_1" = callPackage - ({ mkDerivation, base, Cabal, cabal-doctest, data-functor-logistic - , distributive, doctest, markdown-unlit, tasty, tasty-hunit - , template-haskell, transformers - }: - mkDerivation { - pname = "rank2classes"; - version = "1.5.1"; - sha256 = "1wpzjfc37wdly0kg1vzk56x2cb7z2v14dwr2a9bmfh8z601q48dj"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - base data-functor-logistic distributive template-haskell - transformers - ]; - testHaskellDepends = [ - base data-functor-logistic distributive doctest tasty tasty-hunit - ]; - testToolDepends = [ markdown-unlit ]; - description = "standard type constructor class hierarchy, only with methods of rank 2 types"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "rapid" = callPackage ({ mkDerivation, async, base, containers, foreign-store, stm }: mkDerivation { @@ -242880,6 +241683,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 @@ -243137,8 +241942,8 @@ self: { pname = "rasterific-svg"; version = "0.3.3.2"; sha256 = "1i0pl1hin1ipi3l0074ywd1khacpbvz3x0frx0j0hmbfiv4n3nq2"; - revision = "2"; - editedCabalFile = "1938sp9m0yi7ypxk74bzrbkp9b4yk6hsaqhlhbraf9yb7w61228v"; + revision = "3"; + editedCabalFile = "18h0q07pgw370piwymqjjnph8wgkb33x1n79annhjl1bfz29v3dc"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -243173,8 +241978,8 @@ self: { }: mkDerivation { pname = "ratel"; - version = "2.0.0.8"; - sha256 = "0sbh3q4ddsk3fbmvkhcrnp4q0d0san78nnjgplrwz4qq1zk4bp00"; + version = "2.0.0.9"; + sha256 = "06zvz041ylpxmipydq1g3lli1w61dbq8dnmqgy2iga8jhd7dif48"; libraryHaskellDepends = [ aeson base bytestring case-insensitive containers http-client http-client-tls http-types uuid @@ -243331,8 +242136,8 @@ self: { }: mkDerivation { pname = "rattletrap"; - version = "11.2.14"; - sha256 = "0r879vbdhv77l14wzv03s8hlhmmzzfl6igkwnclr9lq8ncbafrxm"; + version = "12.0.3"; + sha256 = "11hfw1w59cidv253r0vby8qm7wmqcyram3rp03348zfyaajgcdnl"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -243348,14 +242153,14 @@ self: { broken = true; }) {}; - "rattletrap_12_0_3" = callPackage + "rattletrap_12_1_1" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring , containers, filepath, http-client, http-client-tls, text }: mkDerivation { pname = "rattletrap"; - version = "12.0.3"; - sha256 = "11hfw1w59cidv253r0vby8qm7wmqcyram3rp03348zfyaajgcdnl"; + version = "12.1.1"; + sha256 = "0dmc3zbvrcszp4xgb0fivi2yp4dvi3dj1kmi1kx9dwv12r8is1f9"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -243380,6 +242185,8 @@ self: { pname = "raven-haskell"; version = "0.1.4.1"; sha256 = "0977rwafdwljz3444asvjsikpwc89diahmmzl9f5xc8dzfqcnzay"; + revision = "1"; + editedCabalFile = "1107g5f6sr7sjxnh2d3g727ncfqni6dsvda5hr99fh86vhm2g1wi"; libraryHaskellDepends = [ aeson base bytestring http-conduit mtl network random resourcet text time unordered-containers uuid-types @@ -243706,7 +242513,9 @@ self: { benchmarkHaskellDepends = [ base criterion deepseq text ]; description = "A library for RDF processing in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "rdf4h"; + broken = true; }) {}; "rdioh" = callPackage @@ -244631,10 +243440,8 @@ self: { }: mkDerivation { pname = "rebase"; - version = "1.16.1"; - sha256 = "0mb1x5p3lvfhxsrnmkhsv6f4rd1cxp6m3qg6kyz30svrbwxsvvkz"; - revision = "1"; - editedCabalFile = "1igpk9gz54jfvf5m69xcp7hl567c4lkbmwhzylcbx0i1n0pd7i2n"; + version = "1.19"; + sha256 = "02yvxdvjwb3dlwwb85i0sbadfjqxyv86pxkzylxidpw5qxb2g0ji"; libraryHaskellDepends = [ base bifunctors bytestring comonad containers contravariant deepseq dlist either groups hashable invariant mtl profunctors scientific @@ -244708,6 +243515,8 @@ self: { testHaskellDepends = [ base hspec primitive ]; description = "SmallArray-based extensible records for small-scale fast reads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "recaptcha" = callPackage @@ -244946,8 +243755,8 @@ self: { }: mkDerivation { pname = "records-sop"; - version = "0.1.1.0"; - sha256 = "01h6brqrpk5yhddi0cx2a9cv2dvri81xzx5ny616nfgy4fn9pfdl"; + version = "0.1.1.1"; + sha256 = "02rm4q65rr9w25jgvwqqcc3hv43w0xn22qba3kyihixkis8ckrmd"; libraryHaskellDepends = [ base deepseq generics-sop ghc-prim ]; testHaskellDepends = [ base deepseq generics-sop hspec should-not-typecheck @@ -245114,20 +243923,6 @@ self: { }) {}; "recv" = callPackage - ({ mkDerivation, base, bytestring, hspec, hspec-discover, network - }: - mkDerivation { - pname = "recv"; - version = "0.0.0"; - sha256 = "1yz9b95m9yxcwbbwdvp288y47ycn4yq9g7ixlw0sf98h5rjp4s2w"; - libraryHaskellDepends = [ base bytestring network ]; - testHaskellDepends = [ base bytestring hspec network ]; - testToolDepends = [ hspec-discover ]; - description = "Efficient netowrk recv"; - license = lib.licenses.bsd3; - }) {}; - - "recv_0_1_0" = callPackage ({ mkDerivation, base, bytestring, hspec, hspec-discover, network }: mkDerivation { @@ -245139,7 +243934,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Efficient network recv"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "red-black-record" = callPackage @@ -245193,31 +243987,6 @@ self: { }) {}; "redact" = callPackage - ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, directory - , explainable-predicates, HMock, optparse-applicative, tasty - , tasty-hunit, text - }: - mkDerivation { - pname = "redact"; - version = "0.4.0.0"; - sha256 = "0q0sqsqajv8mvz76b9xy40z22j6cbacwn76rwhns5wwj5kwli829"; - revision = "1"; - editedCabalFile = "0gdvbz483f8sbl1f1iqcm7n5srk09dxz401dpzjc59gyzg0j3a7s"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ ansi-terminal base text ]; - executableHaskellDepends = [ - ansi-terminal ansi-wl-pprint base directory optparse-applicative - ]; - testHaskellDepends = [ - ansi-terminal base explainable-predicates HMock tasty tasty-hunit - ]; - description = "hide secret text on the terminal"; - license = lib.licenses.mit; - mainProgram = "redact"; - }) {}; - - "redact_0_5_0_0" = callPackage ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, directory , explainable-predicates, HMock, optparse-applicative, tasty , tasty-hunit, text @@ -245317,8 +244086,8 @@ self: { }: mkDerivation { pname = "redis-glob"; - version = "0.1.0.4"; - sha256 = "0w1w76ldiaxk4irgazm6xv5s60zvyyvjfsxbpa3b0aq4jgw49gh5"; + version = "0.1.0.5"; + sha256 = "1qj95mwywlhpb6g284gnxwv1fy367ck3kd5vk2mkwpg1wrkkrqkd"; libraryHaskellDepends = [ ascii-char base bytestring megaparsec ]; testHaskellDepends = [ ascii-char ascii-superset base bytestring hspec QuickCheck @@ -245397,6 +244166,7 @@ self: { ]; description = "REdis Serialization Protocol (RESP) implementation"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "redis-schema" = callPackage @@ -245509,8 +244279,8 @@ self: { pname = "reducers"; version = "3.12.4"; sha256 = "0hsycdir52jdijnnvc77jj971fjrrc722v952wr62ivrvx2zarn0"; - revision = "3"; - editedCabalFile = "00xd4pyg0p4z0alyg1zy193jc3smq50y73dkafiphd73rzszxy9g"; + revision = "4"; + editedCabalFile = "13wxljk7mn8bna1xv2965lnbizjh6c7cz813jk8r62msskn4xkbj"; libraryHaskellDepends = [ array base bytestring containers fingertree hashable semigroupoids text transformers unordered-containers @@ -245742,6 +244512,7 @@ self: { testHaskellDepends = [ base QuickCheck ]; description = "Refinement types with static and runtime checking"; license = lib.licenses.mit; + maintainers = [ lib.maintainers.raehik ]; }) {}; "refined-http-api-data" = callPackage @@ -245786,6 +244557,7 @@ self: { testHaskellDepends = [ base QuickCheck refined ]; description = "Refinement types with static and runtime checking (+ Refined1)"; license = lib.licenses.mit; + maintainers = [ lib.maintainers.raehik ]; }) {}; "refinery" = callPackage @@ -245851,22 +244623,22 @@ self: { ({ mkDerivation, base, bifunctors, commutative-semigroups, comonad , constraints, constraints-extras, containers, criterion , data-default, deepseq, dependent-map, dependent-sum, directory - , exception-transformers, filemanip, filepath, haskell-src-exts - , haskell-src-meta, hlint, hspec, lens, loch-th, MemoTrie, mmorph - , monad-control, monoidal-containers, mtl, patch, prim-uniq - , primitive, process, proctest, profunctors, random, ref-tf - , reflection, semialign, semigroupoids, split, stm, syb + , exception-transformers, exceptions, filemanip, filepath + , haskell-src-exts, haskell-src-meta, hlint, hspec, lens, loch-th + , MemoTrie, mmorph, monad-control, monoidal-containers, mtl, patch + , prim-uniq, primitive, process, proctest, profunctors, random + , ref-tf, reflection, semialign, semigroupoids, split, stm, syb , template-haskell, text, these, these-lens, time, transformers , unbounded-delays, witherable }: mkDerivation { pname = "reflex"; - version = "0.8.2.2"; - sha256 = "1add5bcsyq2k02w2q0ifbyfcvcic1hmjdbgxg8ajd5riam0lhb16"; + version = "0.9.2.0"; + sha256 = "009i2f4j4jhzk58z57rbbrpq9s4x4zsb4zd6y3yy7rhr97374ps3"; libraryHaskellDepends = [ base bifunctors commutative-semigroups comonad constraints constraints-extras containers data-default dependent-map - dependent-sum exception-transformers haskell-src-exts + dependent-sum exception-transformers exceptions haskell-src-exts haskell-src-meta lens MemoTrie mmorph monad-control monoidal-containers mtl patch prim-uniq primitive profunctors random ref-tf reflection semialign semigroupoids stm syb @@ -245888,48 +244660,6 @@ self: { license = lib.licenses.bsd3; }) {}; - "reflex_0_9_0_1" = callPackage - ({ mkDerivation, base, bifunctors, commutative-semigroups, comonad - , constraints, constraints-extras, containers, criterion - , data-default, deepseq, dependent-map, dependent-sum, directory - , exception-transformers, filemanip, filepath, haskell-src-exts - , haskell-src-meta, hlint, hspec, lens, loch-th, MemoTrie, mmorph - , monad-control, monoidal-containers, mtl, patch, prim-uniq - , primitive, process, proctest, profunctors, random, ref-tf - , reflection, semialign, semigroupoids, split, stm, syb - , template-haskell, text, these, these-lens, time, transformers - , unbounded-delays, witherable - }: - mkDerivation { - pname = "reflex"; - version = "0.9.0.1"; - sha256 = "1r7mjpg73clp1jqxpakvmiah55kbm6q54kcy9y84abn20wy98swi"; - libraryHaskellDepends = [ - base bifunctors commutative-semigroups comonad constraints - constraints-extras containers data-default dependent-map - dependent-sum exception-transformers haskell-src-exts - haskell-src-meta lens MemoTrie mmorph monad-control - monoidal-containers mtl patch prim-uniq primitive profunctors - random ref-tf reflection semialign semigroupoids stm syb - template-haskell these time transformers unbounded-delays - witherable - ]; - testHaskellDepends = [ - base bifunctors commutative-semigroups constraints - constraints-extras containers deepseq dependent-map dependent-sum - directory filemanip filepath hlint hspec lens monoidal-containers - mtl patch proctest ref-tf semialign split text these these-lens - transformers witherable - ]; - benchmarkHaskellDepends = [ - base containers criterion deepseq dependent-map dependent-sum - loch-th mtl primitive process ref-tf split stm time transformers - ]; - description = "Higher-order Functional Reactive Programming"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "reflex-animation" = callPackage ({ mkDerivation, base, bifunctors, containers, profunctors, reflex , reflex-transformers, semigroups, vector-space @@ -246205,6 +244935,8 @@ self: { ]; description = "Render Pandoc documents to HTML using reflex-dom"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reflex-dom-retractable" = callPackage @@ -246342,27 +245074,29 @@ self: { }) {}; "reflex-ghci" = callPackage - ({ mkDerivation, base, bytestring, directory, filepath, fsnotify - , optparse-applicative, process, reflex, reflex-fsnotify - , reflex-process, reflex-vty, regex-tdfa, temporary, text, unix - , vty + ({ mkDerivation, base, bytestring, containers, directory, filepath + , fsnotify, optparse-applicative, process, reflex, reflex-fsnotify + , reflex-process, reflex-vty, regex-tdfa, semialign, temporary + , text, these, unix, vty }: mkDerivation { pname = "reflex-ghci"; - version = "0.1.5.4"; - sha256 = "0qp50yscpik3hb2dhga4x9w40vji34hklvcjksnd1a1d512jh485"; + version = "0.2.0.0"; + sha256 = "1j8hb81b8889dsqg5x2p52fizzfp61bxicd3m4vyx6ay9hjgq917"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base bytestring directory filepath fsnotify process reflex - reflex-fsnotify reflex-process reflex-vty regex-tdfa text unix vty + base bytestring containers directory filepath fsnotify process + reflex reflex-fsnotify reflex-process reflex-vty regex-tdfa + semialign text these unix vty ]; executableHaskellDepends = [ base optparse-applicative process reflex reflex-process reflex-vty text vty ]; testHaskellDepends = [ - base directory process reflex reflex-process temporary + base bytestring containers directory filepath process reflex + reflex-process temporary ]; description = "A GHCi widget library for use in reflex applications"; license = lib.licenses.bsd3; @@ -246579,10 +245313,10 @@ self: { }: mkDerivation { pname = "reflex-process"; - version = "0.3.1.2"; - sha256 = "0casszkah49b6n36ymh5ffyhbz1161z5vrlpwisn1r1wb68idm3j"; - revision = "2"; - editedCabalFile = "1vkdpi6yapgy6xksdwqkz926hjjbd9v07q9p7fx0nnbjg6yxg437"; + version = "0.3.2.0"; + sha256 = "1ijlp762ckyxqpjkax692zmzk1b0ziafbiid4351lvk6n4sy5n56"; + revision = "1"; + editedCabalFile = "1akmqvsvdip4vlsl170yg6l3rndgbcq8m5wlsl889dr7z9wis6rm"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -246664,20 +245398,20 @@ self: { "reflex-vty" = callPackage ({ mkDerivation, base, bimap, containers, data-default - , dependent-map, dependent-sum, exception-transformers, extra - , hspec, mmorph, mtl, ordered-containers, primitive, ref-tf, reflex - , stm, text, time, transformers, vty + , dependent-map, dependent-sum, exception-transformers, exceptions + , extra, hspec, mmorph, mtl, ordered-containers, primitive, ref-tf + , reflex, stm, text, time, transformers, vty }: mkDerivation { pname = "reflex-vty"; - version = "0.4.1.1"; - sha256 = "0s9f5v6nnm9g058rlq5k2x5ak8hpgxsmc9l3hcbvgm9l0979mr74"; + version = "0.5.1.0"; + sha256 = "0icq92xgk720k4q3qm6ib1p8xj1kqcxd64j3zsva23np9pql4sh1"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base bimap containers data-default dependent-map dependent-sum - exception-transformers mmorph mtl ordered-containers primitive - ref-tf reflex stm text time transformers vty + exception-transformers exceptions mmorph mtl ordered-containers + primitive ref-tf reflex stm text time transformers vty ]; executableHaskellDepends = [ base containers reflex text time transformers vty @@ -246725,6 +245459,8 @@ self: { ]; description = "Add support for using Hamlet with Reform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reform-happstack" = callPackage @@ -246751,6 +245487,8 @@ self: { libraryHaskellDepends = [ base hsp hsx2hs reform text ]; description = "Add support for using HSP with Reform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reform-lucid" = callPackage @@ -246762,6 +245500,8 @@ self: { libraryHaskellDepends = [ base lucid path-pieces reform text ]; description = "Add support for using lucid with Reform"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reformat" = callPackage @@ -246975,8 +245715,8 @@ self: { pname = "regex-base"; version = "0.94.0.2"; sha256 = "1w9fxad1dwi040r3db9i2cjhhrl86p3hngj13ixbcnqgb27l16bv"; - revision = "1"; - editedCabalFile = "1k2gzjm7xz69f7zr08wh2wzb5dhb659cvimsvx0g9p8cf5f45x2g"; + revision = "2"; + editedCabalFile = "1q1h2001s1mpsp0yvpfb63d59xxsbgzing0h7h5qwpppz49w6xis"; libraryHaskellDepends = [ array base bytestring containers text ]; description = "Common \"Text.Regex.*\" API for Regex matching"; license = lib.licenses.bsd3; @@ -247192,8 +245932,8 @@ self: { pname = "regex-pcre-builtin"; version = "0.95.2.3.8.44"; sha256 = "0pn55ssrwr05c9sa9jvp0knvzjksz04wn3pmzf5dz4xgbyjadkna"; - revision = "3"; - editedCabalFile = "071s6k97z0wiqx5rga360awgj0a031gqm725835xxszdz36w0mbv"; + revision = "4"; + editedCabalFile = "1gzczx15v4yjxm2b787qjgc64n284d2jx33vn484j6cndjfjx58r"; libraryHaskellDepends = [ array base bytestring containers regex-base text ]; @@ -247241,8 +245981,8 @@ self: { pname = "regex-posix"; version = "0.96.0.1"; sha256 = "1715b57z67q4hg0jz44wkxrxi3v7n5iagw6gw48pf8hr34wpr0n7"; - revision = "1"; - editedCabalFile = "1x5xkfddn3llxk4fngqbd8njssrwb7jlp0a0jxfrgdivbava9fwx"; + revision = "2"; + editedCabalFile = "1f2n45hv9m7vsc7b7izkiavn56rwi2p3vy392601ak17qqnclyfl"; libraryHaskellDepends = [ array base bytestring containers regex-base ]; @@ -247309,6 +246049,8 @@ self: { pname = "regex-tdfa"; version = "1.3.2.1"; sha256 = "15c2gc7c0y2xv9sm586jvys2kx1dc18lzfvjzad5mm2d4yszi2sw"; + revision = "1"; + editedCabalFile = "1005mqjhq2blz8kqxmk84xajyqd85n91j9nraw6jrwfv11vxfvxa"; libraryHaskellDepends = [ array base bytestring containers mtl parsec regex-base text ]; @@ -247693,35 +246435,6 @@ self: { }) {}; "registry" = callPackage - ({ mkDerivation, async, base, bytestring, containers, directory - , exceptions, generic-lens, hashable, hedgehog, io-memoize, mmorph - , MonadRandom, mtl, multimap, protolude, random, resourcet - , semigroupoids, semigroups, tasty, tasty-discover, tasty-hedgehog - , tasty-th, template-haskell, text, transformers-base, universum - }: - mkDerivation { - pname = "registry"; - version = "0.3.3.4"; - sha256 = "1x5ilikd9xxdhkzvvm5mklxrzx8vbyzzji4rqnw8lsgrxpzwca9d"; - libraryHaskellDepends = [ - base containers exceptions hashable mmorph mtl protolude resourcet - semigroupoids semigroups template-haskell text transformers-base - ]; - testHaskellDepends = [ - async base bytestring containers directory exceptions generic-lens - hashable hedgehog io-memoize mmorph MonadRandom mtl multimap - protolude random resourcet semigroupoids semigroups tasty - tasty-discover tasty-hedgehog tasty-th template-haskell text - transformers-base universum - ]; - testToolDepends = [ tasty-discover ]; - description = "data structure for assembling components"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "registry_0_6_0_0" = callPackage ({ mkDerivation, async, base, bytestring, containers, directory , exceptions, generic-lens, hashable, hedgehog, io-memoize, mmorph , MonadRandom, mtl, multimap, protolude, random, resourcet @@ -247753,29 +246466,6 @@ self: { }) {}; "registry-aeson" = callPackage - ({ mkDerivation, aeson, base, bytestring, containers, hedgehog - , protolude, registry, registry-hedgehog, tasty, template-haskell - , text, time, transformers, unordered-containers, vector - }: - mkDerivation { - pname = "registry-aeson"; - version = "0.2.3.3"; - sha256 = "03wh6sl921hsqk32749y4gklpfjxjbhyw0dwk0zw6ja28jzpny7g"; - libraryHaskellDepends = [ - aeson base bytestring containers protolude registry - template-haskell text transformers unordered-containers vector - ]; - testHaskellDepends = [ - aeson base bytestring containers hedgehog protolude registry - registry-hedgehog tasty template-haskell text time transformers - unordered-containers vector - ]; - description = "Aeson encoders / decoders"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - - "registry-aeson_0_3_0_0" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, hedgehog , protolude, registry, registry-hedgehog, string-qq, tasty , template-haskell, text, time, transformers, unordered-containers @@ -247800,32 +246490,6 @@ self: { }) {}; "registry-hedgehog" = callPackage - ({ mkDerivation, base, containers, hedgehog, mmorph, multimap - , protolude, registry, tasty, tasty-discover, tasty-hedgehog - , tasty-th, template-haskell, text, transformers, universum - , unordered-containers - }: - mkDerivation { - pname = "registry-hedgehog"; - version = "0.7.2.0"; - sha256 = "07lynkbwcjjlhh7v7rxa7s1b3m3vh1lfamdq4iwqy8b54p7fybs5"; - libraryHaskellDepends = [ - base containers hedgehog mmorph multimap protolude registry tasty - tasty-discover tasty-hedgehog tasty-th template-haskell text - transformers universum unordered-containers - ]; - testHaskellDepends = [ - base containers hedgehog mmorph multimap protolude registry tasty - tasty-discover tasty-hedgehog tasty-th template-haskell text - transformers universum unordered-containers - ]; - testToolDepends = [ tasty-discover ]; - description = "utilities to work with Hedgehog generators and `registry`"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - - "registry-hedgehog_0_8_0_0" = callPackage ({ mkDerivation, base, containers, hedgehog, mmorph, multimap , protolude, registry, tasty, tasty-discover, tasty-hedgehog , tasty-th, template-haskell, text, transformers, universum @@ -247852,34 +246516,6 @@ self: { }) {}; "registry-hedgehog-aeson" = callPackage - ({ mkDerivation, aeson, base, containers, hedgehog, mmorph - , multimap, protolude, registry, registry-hedgehog, scientific - , tasty, tasty-discover, tasty-hedgehog, tasty-th, template-haskell - , text, transformers, universum, unordered-containers, vector - }: - mkDerivation { - pname = "registry-hedgehog-aeson"; - version = "0.2.0.0"; - sha256 = "1rizwqyj6cmkbmvcir9spnxrpbx22gxiqdd6qlqxc9bdnvgk29i9"; - libraryHaskellDepends = [ - aeson base containers hedgehog mmorph multimap protolude registry - scientific tasty tasty-discover tasty-hedgehog tasty-th - template-haskell text transformers universum unordered-containers - vector - ]; - testHaskellDepends = [ - aeson base containers hedgehog mmorph multimap protolude registry - registry-hedgehog scientific tasty tasty-discover tasty-hedgehog - tasty-th template-haskell text transformers universum - unordered-containers vector - ]; - testToolDepends = [ tasty-discover ]; - description = "Hedgehog generators for Aeson"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - - "registry-hedgehog-aeson_0_3_0_0" = callPackage ({ mkDerivation, aeson, base, containers, hedgehog, mmorph , multimap, protolude, registry, registry-hedgehog, scientific , tasty, tasty-discover, tasty-hedgehog, tasty-th, template-haskell @@ -247930,31 +246566,6 @@ self: { }) {}; "registry-options" = callPackage - ({ mkDerivation, base, boxes, bytestring, containers, directory - , hedgehog, HsYAML, multimap, protolude, registry - , registry-hedgehog, tasty, template-haskell, text, th-lift, time - , transformers, unordered-containers, vector - }: - mkDerivation { - pname = "registry-options"; - version = "0.1.0.0"; - sha256 = "08sfywzq50w0psb9vgphyyqd2vi8irdj9xiqxpd613dpwh9gj1d7"; - libraryHaskellDepends = [ - base boxes bytestring containers HsYAML multimap protolude registry - template-haskell text th-lift transformers unordered-containers - vector - ]; - testHaskellDepends = [ - base boxes bytestring containers directory hedgehog HsYAML multimap - protolude registry registry-hedgehog tasty template-haskell text - th-lift time transformers unordered-containers vector - ]; - description = "application options parsing"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - - "registry-options_0_2_0_0" = callPackage ({ mkDerivation, base, boxes, bytestring, containers, directory , hedgehog, HsYAML, multimap, protolude, registry , registry-hedgehog, tasty, template-haskell, text, th-lift, time @@ -248431,8 +247042,10 @@ self: { executableHaskellDepends = [ base ]; description = "Automation of Haskell package release process"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; mainProgram = "releaser"; maintainers = [ lib.maintainers.maralorn ]; + broken = true; }) {}; "relevant-time" = callPackage @@ -248526,52 +247139,7 @@ self: { license = lib.licenses.agpl3Plus; }) {}; - "relude_0_7_0_0" = callPackage - ({ mkDerivation, base, bytestring, containers, deepseq, doctest - , gauge, ghc-prim, Glob, hashable, hedgehog, mtl, stm, text - , transformers, unordered-containers - }: - mkDerivation { - pname = "relude"; - version = "0.7.0.0"; - sha256 = "1gx1h3656wz80v72acqky88iv7a2shinfv6apzzyjxii8lc22jf7"; - libraryHaskellDepends = [ - base bytestring containers deepseq ghc-prim hashable mtl stm text - transformers unordered-containers - ]; - testHaskellDepends = [ - base bytestring containers doctest Glob hedgehog text - ]; - benchmarkHaskellDepends = [ base gauge unordered-containers ]; - description = "Safe, performant, user-friendly and lightweight Haskell Standard Library"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "relude" = callPackage - ({ mkDerivation, base, bytestring, containers, deepseq, doctest - , ghc-prim, Glob, hashable, hedgehog, mtl, stm, tasty-bench, text - , transformers, unordered-containers - }: - mkDerivation { - pname = "relude"; - version = "1.1.0.0"; - sha256 = "02dn99v2qmykj0l1qmn15k36hyxccy71b7iqavfk24zgjf5g07dm"; - libraryHaskellDepends = [ - base bytestring containers deepseq ghc-prim hashable mtl stm text - transformers unordered-containers - ]; - testHaskellDepends = [ - base bytestring containers doctest Glob hedgehog text - ]; - benchmarkHaskellDepends = [ - base tasty-bench unordered-containers - ]; - description = "Safe, performant, user-friendly and lightweight Haskell Standard Library"; - license = lib.licenses.mit; - }) {}; - - "relude_1_2_0_0" = callPackage ({ mkDerivation, base, bytestring, containers, deepseq, doctest , ghc-prim, Glob, hashable, hedgehog, mtl, stm, tasty-bench, text , transformers, unordered-containers @@ -248592,7 +247160,6 @@ self: { ]; description = "Safe, performant, user-friendly and lightweight Haskell Standard Library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "remark" = callPackage @@ -248868,6 +247435,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 @@ -248900,6 +247469,8 @@ self: { ]; description = "High performance, regular, shape polymorphic parallel arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "repa-algorithms" = callPackage @@ -248911,6 +247482,7 @@ self: { libraryHaskellDepends = [ base repa vector ]; description = "Algorithms using the Repa array library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-array" = callPackage @@ -249028,6 +247600,7 @@ self: { ]; description = "Perform fft with repa via FFTW"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-flow" = callPackage @@ -249062,6 +247635,7 @@ self: { ]; description = "Read and write Repa arrays in various formats"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-linear-algebra" = callPackage @@ -249142,6 +247716,7 @@ self: { ]; description = "Reading and writing sound files with repa arrays"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "repa-stream" = callPackage @@ -249213,21 +247788,6 @@ self: { }) {}; "replace-attoparsec" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, Cabal, parsers, text - }: - mkDerivation { - pname = "replace-attoparsec"; - version = "1.4.5.0"; - sha256 = "1mr7d6w5x6igsvl6mccchr2wbxxr5p86kpyxlbk7m17dplvwazcq"; - libraryHaskellDepends = [ attoparsec base bytestring text ]; - testHaskellDepends = [ - attoparsec base bytestring Cabal parsers text - ]; - description = "Find, replace, and split string patterns with Attoparsec parsers (instead of regex)"; - license = lib.licenses.bsd2; - }) {}; - - "replace-attoparsec_1_5_0_0" = callPackage ({ mkDerivation, attoparsec, base, bytestring, hspec, HUnit , parsers, text }: @@ -249241,27 +247801,9 @@ self: { ]; description = "Find, replace, split string patterns with Attoparsec parsers (instead of regex)"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "replace-megaparsec" = callPackage - ({ mkDerivation, base, bytestring, Cabal, megaparsec - , parser-combinators, text - }: - mkDerivation { - pname = "replace-megaparsec"; - version = "1.4.5.0"; - sha256 = "1n9ik81hd5xgcbzzjrdqxp34q4qg6nklbg36124amdr14id03ylg"; - libraryHaskellDepends = [ - base bytestring megaparsec parser-combinators text - ]; - testHaskellDepends = [ base bytestring Cabal megaparsec text ]; - description = "Find, replace, and split string patterns with Megaparsec parsers (instead of regex)"; - license = lib.licenses.bsd2; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "replace-megaparsec_1_5_0_1" = callPackage ({ mkDerivation, base, bytestring, hspec, megaparsec , parser-combinators, text }: @@ -249275,7 +247817,6 @@ self: { testHaskellDepends = [ base bytestring hspec megaparsec text ]; description = "Find, replace, split string patterns with Megaparsec parsers (instead of regex)"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -249470,6 +248011,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Scrap Your Reprinter"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "reproject" = callPackage @@ -249520,6 +248063,41 @@ self: { maintainers = [ lib.maintainers.maralorn ]; }) {}; + "req_3_13_1" = callPackage + ({ mkDerivation, aeson, authenticate-oauth, base, blaze-builder + , bytestring, case-insensitive, containers, crypton-connection + , exceptions, hspec, hspec-core, hspec-discover, http-api-data + , http-client, http-client-tls, http-types, modern-uri + , monad-control, mtl, QuickCheck, retry, template-haskell, text + , time, transformers, transformers-base, unliftio-core + }: + mkDerivation { + pname = "req"; + version = "3.13.1"; + sha256 = "0cprbfjvzh4fhn1vqyisqcqk236zdn765k6g7a8ssqgkiqaw8i8h"; + revision = "1"; + editedCabalFile = "08x6hs8hazxdypihql8ll90m5i8yrdz9y469s00zzkzwqh6j6xjp"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson authenticate-oauth base blaze-builder bytestring + case-insensitive containers crypton-connection exceptions + http-api-data http-client http-client-tls http-types modern-uri + monad-control mtl retry template-haskell text transformers + transformers-base unliftio-core + ]; + testHaskellDepends = [ + aeson base blaze-builder bytestring case-insensitive hspec + hspec-core http-api-data http-client http-types modern-uri + monad-control mtl QuickCheck retry template-haskell text time + ]; + testToolDepends = [ hspec-discover ]; + doCheck = false; + description = "HTTP client library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = [ lib.maintainers.maralorn ]; + }) {}; + "req-conduit" = callPackage ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec , hspec-discover, http-client, req, resourcet, temporary @@ -249529,8 +248107,8 @@ self: { pname = "req-conduit"; version = "1.0.1"; sha256 = "0zyy9j6iiz8z2jdx25vp77arfbmrck7bjndm3p4s9l9399c5bm62"; - revision = "1"; - editedCabalFile = "0gbm1c95ml7binmazn15737a8ls5p21f9d0d6pzc3fla0rz91ic1"; + revision = "2"; + editedCabalFile = "1p2sww990zrjazhkdapg92cnlcsqlzc5lm6qkswlnzlkagmsjj2x"; libraryHaskellDepends = [ base bytestring conduit http-client req resourcet transformers ]; @@ -249667,6 +248245,18 @@ self: { broken = true; }) {}; + "require-callstack" = callPackage + ({ mkDerivation, base }: + mkDerivation { + pname = "require-callstack"; + version = "0.1.0.0"; + sha256 = "0c51v7zyd8r7winsw7q5xvswk7r34awfyg471dnq4zq52rmwdvx5"; + libraryHaskellDepends = [ base ]; + testHaskellDepends = [ base ]; + description = "Propagate HasCallStack with constraints"; + license = lib.licenses.mit; + }) {}; + "requirements" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -249708,8 +248298,8 @@ self: { ({ mkDerivation, rebase }: mkDerivation { pname = "rerebase"; - version = "1.16.1"; - sha256 = "04pw2j4nh8x53axmfzp9d2plmiwxpxddgwcji0a8j24lkdyv8k32"; + version = "1.19"; + sha256 = "0lb84apgwxswx4y1k3n9l335qzzby96mcpsjlzfw116b3ayd3123"; libraryHaskellDepends = [ rebase ]; description = "Reexports from \"base\" with a bunch of other standard libraries"; license = lib.licenses.mit; @@ -249851,26 +248441,7 @@ self: { maintainers = [ lib.maintainers.thielema ]; }) {}; - "resolv_0_1_1_2" = callPackage - ({ mkDerivation, base, base16-bytestring, binary, bytestring - , containers, directory, filepath, tasty, tasty-hunit - }: - mkDerivation { - pname = "resolv"; - version = "0.1.1.2"; - sha256 = "0wczdy3vmpfcfwjn1m95bygc5d83m97xxmavhdvy5ayn8c402fp4"; - libraryHaskellDepends = [ - base base16-bytestring binary bytestring containers - ]; - testHaskellDepends = [ - base bytestring directory filepath tasty tasty-hunit - ]; - description = "Domain Name Service (DNS) lookup via the libresolv standard library routines"; - license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; - }) {}; - - "resolv" = callPackage + "resolv_0_1_2_0" = callPackage ({ mkDerivation, base, base16-bytestring, binary, bytestring , containers, directory, filepath, tasty, tasty-hunit }: @@ -249888,9 +248459,10 @@ self: { ]; description = "Domain Name Service (DNS) lookup via the libresolv standard library routines"; license = lib.licenses.gpl2Plus; + hydraPlatforms = lib.platforms.none; }) {}; - "resolv_0_2_0_2" = callPackage + "resolv" = callPackage ({ mkDerivation, base, base16-bytestring, binary, bytestring , containers, directory, filepath, tasty, tasty-hunit }: @@ -249898,6 +248470,8 @@ self: { pname = "resolv"; version = "0.2.0.2"; sha256 = "0jz798kliih4lb16s9bjk7sa9034x1qhyrr8z9sp6ahkz4yjh3c8"; + revision = "1"; + editedCabalFile = "0ijx9vlchgq7prbsk49hbr25aar3vc1m8xcgfbs95nvq6i3llax4"; libraryHaskellDepends = [ base base16-bytestring binary bytestring containers ]; @@ -249906,7 +248480,6 @@ self: { ]; description = "Domain Name Service (DNS) lookup via the libresolv standard library routines"; license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; }) {}; "resolve" = callPackage @@ -249997,22 +248570,6 @@ self: { }) {}; "resource-pool" = callPackage - ({ mkDerivation, base, hashable, monad-control, stm, time - , transformers, transformers-base, vector - }: - mkDerivation { - pname = "resource-pool"; - version = "0.2.3.2"; - sha256 = "04mw8b9djb14zp4rdi6h7mc3zizh597ffiinfbr4m0m8psifw9w6"; - libraryHaskellDepends = [ - base hashable monad-control stm time transformers transformers-base - vector - ]; - description = "A high-performance striped resource pooling implementation"; - license = lib.licenses.bsd3; - }) {}; - - "resource-pool_0_4_0_0" = callPackage ({ mkDerivation, base, hashable, primitive, time }: mkDerivation { pname = "resource-pool"; @@ -250021,7 +248578,6 @@ self: { libraryHaskellDepends = [ base hashable primitive time ]; description = "A high-performance striped resource pooling implementation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "resource-pool-catchio" = callPackage @@ -250069,6 +248625,8 @@ self: { ]; description = "A monadic interface for resource-pool"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "resource-simple" = callPackage @@ -250143,6 +248701,8 @@ self: { libraryHaskellDepends = [ base resource-pool resourcet ]; description = "A small library to convert a Pool into an Acquire"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "respond" = callPackage @@ -250297,13 +248857,14 @@ self: { }) {}; "rest-rewrite" = callPackage - ({ mkDerivation, base, containers, hashable, monad-loops, mtl - , parsec, process, QuickCheck, text, time, unordered-containers + ({ mkDerivation, base, containers, graphviz, hashable, monad-loops + , mtl, parsec, process, QuickCheck, text, time + , unordered-containers, z3 }: mkDerivation { pname = "rest-rewrite"; - version = "0.4.1"; - sha256 = "0h9s6s9wv8fgs6xi2fqdycybjl8si0w50mlk1zc62dmjdzwxy8dx"; + version = "0.4.2"; + sha256 = "0ask5cq3y5qqasrb3hsqbdzl779b60y3k0bmlq5q5d84i5z6d6ag"; libraryHaskellDepends = [ base containers hashable monad-loops mtl parsec process QuickCheck text time unordered-containers @@ -250312,12 +248873,12 @@ self: { base containers hashable mtl QuickCheck text time unordered-containers ]; + testSystemDepends = [ graphviz z3 ]; doHaddock = false; description = "Rewriting library with online termination checking"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; + maintainers = [ lib.maintainers.tbidne ]; + }) {inherit (pkgs) graphviz; inherit (pkgs) z3;}; "rest-snap" = callPackage ({ mkDerivation, base, base-compat, bytestring, case-insensitive @@ -250512,8 +249073,8 @@ self: { }: mkDerivation { pname = "ret"; - version = "0.2.1.0"; - sha256 = "08a3lscasgv5s4aksx55ns4qcfgm917zq3sxgp6m38xm50pzrjql"; + version = "0.2.2.0"; + sha256 = "1vab7xp0qfks3dramprphv02h09v5nnm9vpmih5yll9i3bqka4ji"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -250771,6 +249332,17 @@ self: { broken = true; }) {}; + "rev-scientific" = callPackage + ({ mkDerivation, base }: + mkDerivation { + pname = "rev-scientific"; + version = "0.2.1.0"; + sha256 = "110hbw4b8gbkgszc7d77rw9qpiwsz4lvsfbsb4cpw9fwzrcpvwnh"; + libraryHaskellDepends = [ base ]; + description = "A library to provide special kind of big numbers writing"; + license = lib.licenses.mit; + }) {}; + "rev-state" = callPackage ({ mkDerivation, base, mtl }: mkDerivation { @@ -251214,16 +249786,20 @@ self: { "rhine" = callPackage ({ mkDerivation, base, containers, deepseq, dunai, free - , MonadRandom, random, simple-affine-space, time, time-domain - , transformers, vector-sized + , monad-schedule, MonadRandom, random, simple-affine-space, tasty + , tasty-hunit, time, time-domain, transformers, vector-sized }: mkDerivation { pname = "rhine"; - version = "0.8.1.1"; - sha256 = "11y0qpx909z9dndlsavys8ssx2mk7526addqjwa6srmpw5556vc4"; + version = "1.0"; + sha256 = "0xyiiqlx516v78s240r740xdcmj678np8j16a1kg1f3xpxj7m6lp"; libraryHaskellDepends = [ - base containers deepseq dunai free MonadRandom random - simple-affine-space time time-domain transformers vector-sized + base containers deepseq dunai free monad-schedule MonadRandom + random simple-affine-space time time-domain transformers + vector-sized + ]; + testHaskellDepends = [ + base monad-schedule tasty tasty-hunit vector-sized ]; description = "Functional Reactive Programming with type-level clocks"; license = lib.licenses.bsd3; @@ -251238,8 +249814,8 @@ self: { }: mkDerivation { pname = "rhine-bayes"; - version = "0.8.1.1"; - sha256 = "1ck4x1bs0f0ag14z64vxigqmshf9b8jslv3lvydsjkdm9xvlsz78"; + version = "1.0"; + sha256 = "0g4y9i15mybi7md221a2mbw1dvilf469a2mcnvy5vd0bsx6xfw1y"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -251256,15 +249832,17 @@ self: { }) {}; "rhine-gloss" = callPackage - ({ mkDerivation, base, dunai, gloss, mmorph, rhine, transformers }: + ({ mkDerivation, base, dunai, gloss, mmorph, monad-schedule, rhine + , transformers + }: mkDerivation { pname = "rhine-gloss"; - version = "0.8.1.1"; - sha256 = "0difnslva0zz3wp7i9pcx5h34kx2a9g4743340k56fpbsm95yblf"; + version = "1.0"; + sha256 = "0kx1dqf1rz91im818dn9wvf7nlq8ic0vs5m17xhx349p4yjnk8fi"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base dunai gloss mmorph rhine transformers + base dunai gloss mmorph monad-schedule rhine transformers ]; executableHaskellDepends = [ base ]; description = "Gloss backend for Rhine"; @@ -251275,17 +249853,18 @@ self: { }) {}; "rhine-terminal" = callPackage - ({ mkDerivation, base, dunai, exceptions, hspec, rhine, stm - , terminal, text, time, transformers + ({ mkDerivation, base, dunai, exceptions, hspec, monad-schedule + , rhine, stm, terminal, text, time, transformers }: mkDerivation { pname = "rhine-terminal"; - version = "0.8.1.1"; - sha256 = "1dwsz6bz85zia9m5y26p7ynpq7x94ridlbcfs5r8cw4nm0f7sy95"; + version = "1.0"; + sha256 = "1i00vapdiqgsivwzpnb055iwxxx6626842jyr9w1ccrhib86y00y"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base dunai exceptions rhine terminal time transformers + base dunai exceptions monad-schedule rhine terminal time + transformers ]; executableHaskellDepends = [ base rhine terminal text time ]; testHaskellDepends = [ @@ -251865,22 +250444,6 @@ self: { }) {}; "rio-prettyprint" = callPackage - ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array - , base, Cabal, colour, mtl, path, rio, text - }: - mkDerivation { - pname = "rio-prettyprint"; - version = "0.1.3.0"; - sha256 = "0zlr8wnh38i3dxxfva91q9cwcsvqx0alf9fscn4c4545qhzw7a02"; - libraryHaskellDepends = [ - aeson annotated-wl-pprint ansi-terminal array base Cabal colour mtl - path rio text - ]; - description = "Pretty-printing for RIO"; - license = lib.licenses.bsd3; - }) {}; - - "rio-prettyprint_0_1_4_0" = callPackage ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array , base, Cabal, colour, mtl, path, rio, text }: @@ -251894,7 +250457,6 @@ self: { ]; description = "Pretty-printing for RIO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "rio-process-pool" = callPackage @@ -252203,6 +250765,8 @@ self: { ]; description = "A data type of run-length-encoded lists"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "rlglue" = callPackage @@ -252476,27 +251040,6 @@ self: { }) {}; "roc-id" = callPackage - ({ mkDerivation, base, generic-arbitrary, hspec, MonadRandom, Only - , QuickCheck, text, vector-sized - }: - mkDerivation { - pname = "roc-id"; - version = "0.1.0.0"; - sha256 = "0ac4hrl6qihrhcyx41rf0qnmf9bi848nhdgs71mq3i9gqbnxfi1i"; - libraryHaskellDepends = [ - base MonadRandom Only text vector-sized - ]; - testHaskellDepends = [ - base generic-arbitrary hspec MonadRandom Only QuickCheck text - vector-sized - ]; - description = "Implementation of the ROC National ID standard"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "roc-id_0_2_0_0" = callPackage ({ mkDerivation, base, hspec, MonadRandom, Only, QuickCheck, text , vector-sized }: @@ -253006,22 +251549,6 @@ self: { }) {}; "rope-utf16-splay" = callPackage - ({ mkDerivation, base, QuickCheck, tasty, tasty-hunit - , tasty-quickcheck, text - }: - mkDerivation { - pname = "rope-utf16-splay"; - version = "0.3.2.0"; - sha256 = "0yacy3iqx52nz2ja6fx5di7z3xjzakcmld2l1gixyawfvhavh17p"; - libraryHaskellDepends = [ base text ]; - testHaskellDepends = [ - base QuickCheck tasty tasty-hunit tasty-quickcheck text - ]; - description = "Ropes optimised for updating using UTF-16 code units and row/column pairs"; - license = lib.licenses.bsd3; - }) {}; - - "rope-utf16-splay_0_4_0_0" = callPackage ({ mkDerivation, base, QuickCheck, tasty, tasty-hunit , tasty-quickcheck, text }: @@ -253035,7 +251562,6 @@ self: { ]; description = "Ropes optimised for updating using UTF-16 code units and row/column pairs"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "rosa" = callPackage @@ -253234,7 +251760,9 @@ self: { testHaskellDepends = [ base ]; description = "ROS package system information"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "rospkg"; + broken = true; }) {}; "rosso" = callPackage @@ -253726,29 +252254,12 @@ self: { ]; description = "rpm-ostree update wrapper that caches change info"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "rpmostree-update"; + broken = true; }) {}; "rrb-vector" = callPackage - ({ mkDerivation, base, deepseq, indexed-traversable, primitive - , tasty, tasty-bench, tasty-quickcheck - }: - mkDerivation { - pname = "rrb-vector"; - version = "0.1.1.0"; - sha256 = "0awpx18qklxz5lscmj5ypl8paqja4r2xk4aqj0r181560j7arv3j"; - libraryHaskellDepends = [ - base deepseq indexed-traversable primitive - ]; - testHaskellDepends = [ - base deepseq indexed-traversable tasty tasty-quickcheck - ]; - benchmarkHaskellDepends = [ base primitive tasty-bench ]; - description = "Efficient RRB-Vectors"; - license = lib.licenses.bsd3; - }) {}; - - "rrb-vector_0_2_0_0" = callPackage ({ mkDerivation, base, deepseq, indexed-traversable, nothunks , primitive, quickcheck-classes-base, tasty, tasty-bench , tasty-quickcheck @@ -253767,7 +252278,6 @@ self: { benchmarkHaskellDepends = [ base tasty-bench ]; description = "Efficient RRB-Vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "rrule" = callPackage @@ -254103,6 +252613,8 @@ self: { description = "Binding to the C++ audio stretching library Rubber Band"; license = lib.licenses.gpl3Only; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) rubberband;}; "ruby-marshal" = callPackage @@ -254243,6 +252755,18 @@ self: { license = lib.licenses.bsd3; }) {}; + "run-st_0_1_3_2" = callPackage + ({ mkDerivation, base, primitive, primitive-unlifted }: + mkDerivation { + pname = "run-st"; + version = "0.1.3.2"; + sha256 = "1c3pl4fav5z04ixn4ny7zxrrkdy23wk7sk4xm8w5m1c73w0s5ngd"; + libraryHaskellDepends = [ base primitive primitive-unlifted ]; + description = "runST without boxing penalty"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "rungekutta" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -254485,21 +253009,27 @@ self: { }) {}; "rzk" = callPackage - ({ mkDerivation, array, base, bifunctors, mtl, template-haskell }: + ({ mkDerivation, aeson, array, base, bifunctors, bytestring + , doctest, Glob, mtl, optparse-generic, QuickCheck + , template-haskell, text + }: mkDerivation { pname = "rzk"; - version = "0.4.0"; - sha256 = "0525bzxsb7ckfmbm3jhd4zvds0r1pag6i4lyvmc293fskj0g4zqj"; + version = "0.5.3"; + sha256 = "1k9y8w00cw84k67lp425q3akci5qkvhm7lmr3jspsmhihfyif6lq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - array base bifunctors mtl template-haskell + aeson array base bifunctors bytestring mtl optparse-generic + template-haskell text ]; executableHaskellDepends = [ - array base bifunctors mtl template-haskell + aeson array base bifunctors bytestring mtl optparse-generic + template-haskell text ]; testHaskellDepends = [ - array base bifunctors mtl template-haskell + aeson array base bifunctors bytestring doctest Glob mtl + optparse-generic QuickCheck template-haskell text ]; description = "An experimental proof assistant for synthetic ∞-categories"; license = lib.licenses.bsd3; @@ -254760,8 +253290,8 @@ self: { }: mkDerivation { pname = "safe-exceptions"; - version = "0.1.7.3"; - sha256 = "1gxm61mccivrdz2qcfh5sim596nbrpapx0nli0bx7vx6z3c2ikli"; + version = "0.1.7.4"; + sha256 = "1xhyljfvf1zpr7gpi9xgqmi9xsiv5vcjz52gz65zyq4v1kaxhl9w"; libraryHaskellDepends = [ base deepseq exceptions transformers ]; testHaskellDepends = [ base hspec transformers void ]; description = "Safe, consistent, and easy exception handling"; @@ -254867,10 +253397,10 @@ self: { }: mkDerivation { pname = "safe-json"; - version = "1.1.3.1"; - sha256 = "1rwjlyw0ps29ks2lzji0pi0mz86ma5x0zyhpc1xg740s5592rjf9"; - revision = "1"; - editedCabalFile = "0mf2z0rfyyhscrx8cg0yjz87f7xm8bv68c6z1p0pj5kbfnz0pzqs"; + version = "1.1.4.0"; + sha256 = "01dr0fyqyjbg9cw9g1wgh8bl7y1gfjbzl6qza6lf2s4iisacb06p"; + revision = "2"; + editedCabalFile = "0aq81lqcg2ic6ncxw1rivyspxhcima3vss1ilh8iapbd05lyjbvs"; libraryHaskellDepends = [ aeson base bytestring containers dlist hashable scientific tasty tasty-hunit tasty-quickcheck text time unordered-containers @@ -255812,8 +254342,8 @@ self: { }: mkDerivation { pname = "sandwich"; - version = "0.1.4.0"; - sha256 = "01bw9pn78kspb2qp58k4dxrp21395zb7459mcw5gn3xkp8r2z634"; + version = "0.1.5.0"; + sha256 = "0bv18q6cpfm7f4yp71b6wgp8i4ikcwwp74kz6ih8pv5lgl59j2rj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -255892,8 +254422,8 @@ self: { }: mkDerivation { pname = "sandwich-slack"; - version = "0.1.1.0"; - sha256 = "1ffvkqxffyrl02w22xa3rg8y3lnsq57dhmprp9h6sgp5xwxyrhcb"; + version = "0.1.2.0"; + sha256 = "01fvqn5laby4hs8mb49kp88l9633kihqsxzv8ncqfaq4axgs07cf"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -255917,50 +254447,6 @@ self: { }) {}; "sandwich-webdriver" = callPackage - ({ mkDerivation, aeson, base, containers, data-default, directory - , exceptions, filepath, http-client, http-client-tls, http-conduit - , lifted-base, microlens, microlens-aeson, monad-control - , monad-logger, mtl, network, process, random, regex-compat, retry - , safe, safe-exceptions, sandwich, string-interpolate, temporary - , text, time, transformers, unix, unordered-containers, vector - , webdriver - }: - mkDerivation { - pname = "sandwich-webdriver"; - version = "0.1.2.0"; - sha256 = "146pck1kj5p8h6x8bv6iriicrjxsi0jbpirmscjhc4gg8nd0fmxm"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base containers data-default directory exceptions filepath - http-client http-client-tls http-conduit lifted-base microlens - microlens-aeson monad-control monad-logger mtl network process - random regex-compat retry safe safe-exceptions sandwich - string-interpolate temporary text time transformers unix - unordered-containers vector webdriver - ]; - executableHaskellDepends = [ - aeson base containers data-default directory exceptions filepath - http-client http-client-tls http-conduit lifted-base microlens - microlens-aeson monad-control monad-logger mtl network process - random regex-compat retry safe safe-exceptions sandwich - string-interpolate temporary text time transformers unix - unordered-containers vector webdriver - ]; - testHaskellDepends = [ - aeson base containers data-default directory exceptions filepath - http-client http-client-tls http-conduit lifted-base microlens - microlens-aeson monad-control monad-logger mtl network process - random regex-compat retry safe safe-exceptions sandwich - string-interpolate temporary text time transformers unix - unordered-containers vector webdriver - ]; - description = "Sandwich integration with Selenium WebDriver"; - license = lib.licenses.bsd3; - mainProgram = "sandwich-webdriver-exe"; - }) {}; - - "sandwich-webdriver_0_2_1_0" = callPackage ({ mkDerivation, aeson, base, containers, data-default, directory , exceptions, filepath, http-client, http-client-tls, http-conduit , lifted-base, microlens, microlens-aeson, monad-control @@ -255971,8 +254457,8 @@ self: { }: mkDerivation { pname = "sandwich-webdriver"; - version = "0.2.1.0"; - sha256 = "0f2g2d5ir0r5h2r9im3qq8g3lid3incj7x8w7gvy184b283yiyp8"; + version = "0.2.2.0"; + sha256 = "05wc57xm9f88nlkyna4j4q7j4w4iwa7f6diqb98mw5p9pgfknf3r"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -256001,7 +254487,6 @@ self: { ]; description = "Sandwich integration with Selenium WebDriver"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "sandwich-webdriver-exe"; }) {}; @@ -256236,6 +254721,25 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "saturn" = callPackage + ({ mkDerivation, base, containers, hspec, parsec, QuickCheck, text + , time + }: + mkDerivation { + pname = "saturn"; + version = "0.3.1.0"; + sha256 = "1n316hshlxnpkl7ivrgkkn4070b4ia48k6p9s4n5551rg2gkvbg1"; + libraryHaskellDepends = [ + base containers hspec parsec QuickCheck text time + ]; + testHaskellDepends = [ base hspec ]; + doHaddock = false; + description = "Handle POSIX cron schedules"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "satyros" = callPackage ({ mkDerivation, base, containers, extra, free, lens, mtl, random , vector @@ -256359,8 +254863,8 @@ self: { }: mkDerivation { pname = "sayable"; - version = "1.1.0.0"; - sha256 = "0xaw4x4v1ir88by5dsffdxb8rdy06czq6amlxkj2wix871hyvm5j"; + version = "1.1.1.0"; + sha256 = "0a44mx9mcjqx0mzrz3ppiwbn0gfcnrls4kczwppkh68lykbax68h"; libraryHaskellDepends = [ base bytestring exceptions prettyprinter text ]; @@ -256377,8 +254881,8 @@ self: { }: mkDerivation { pname = "sbp"; - version = "4.9.0"; - sha256 = "14p0a23kmn9z9l8rm9q94zgyx5p0wnjrgf51shk2magjg055llkb"; + version = "4.15.0"; + sha256 = "1x8gqrrds6ci2s33vrrmw5ndzj22k271zd0wsbvfqg7wpz8ry37f"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -256395,7 +254899,7 @@ self: { license = lib.licenses.mit; }) {}; - "sbp_4_15_0" = callPackage + "sbp_4_17_0" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, base , base64-bytestring, basic-prelude, binary, binary-conduit , bytestring, cmdargs, conduit, conduit-extra, data-binary-ieee754 @@ -256404,8 +254908,8 @@ self: { }: mkDerivation { pname = "sbp"; - version = "4.15.0"; - sha256 = "1x8gqrrds6ci2s33vrrmw5ndzj22k271zd0wsbvfqg7wpz8ry37f"; + version = "4.17.0"; + sha256 = "030qyqd5z0l7nd8q6qz0yr908szpagsy3p0l7jy7gzcx5dkcbmsx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -256474,37 +254978,6 @@ self: { }) {inherit (pkgs) z3;}; "sbv" = callPackage - ({ mkDerivation, array, async, base, bytestring, containers - , deepseq, directory, filepath, hlint, libBF, mtl, pretty, process - , QuickCheck, random, syb, tasty, tasty-bench, tasty-golden - , tasty-hunit, tasty-quickcheck, template-haskell, text, time - , transformers, uniplate, z3 - }: - mkDerivation { - pname = "sbv"; - version = "9.0"; - sha256 = "0r84ak8n8vqs1xbvxjzai828yr5msjyf5igf6qmn6f47m0mhf6cz"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - array async base containers deepseq directory filepath libBF mtl - pretty process QuickCheck random syb template-haskell text time - transformers uniplate - ]; - testHaskellDepends = [ - base bytestring containers directory filepath hlint mtl process - QuickCheck random tasty tasty-golden tasty-hunit tasty-quickcheck - ]; - testSystemDepends = [ z3 ]; - benchmarkHaskellDepends = [ - base deepseq filepath process random tasty tasty-bench time - ]; - description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {inherit (pkgs) z3;}; - - "sbv_10_2" = callPackage ({ mkDerivation, array, async, base, bytestring, containers , deepseq, directory, filepath, libBF, mtl, pretty, process , QuickCheck, random, syb, tasty, tasty-bench, tasty-golden @@ -256938,7 +255411,9 @@ self: { description = "Generates unique passwords for various websites from a single password"; license = lib.licenses.bsd3; platforms = lib.platforms.x86; + hydraPlatforms = lib.platforms.none; mainProgram = "scat"; + broken = true; }) {}; "scc" = callPackage @@ -257442,8 +255917,8 @@ self: { }: mkDerivation { pname = "scientific-notation"; - version = "0.1.5.0"; - sha256 = "0d9qg3m47np8qyip9f7bkcry7as9jsbg688fyy5idcz2nwzxnxqc"; + version = "0.1.6.0"; + sha256 = "041bj2kwxg744ndixs9z8r3y0xxwas9c4987m9qjgllwm1m729px"; libraryHaskellDepends = [ base bytebuild byteslice bytesmith bytestring natural-arithmetic primitive text-short word-compat @@ -257741,6 +256216,7 @@ self: { ]; description = "Html form validation using `ditto`"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "scotty-format" = callPackage @@ -258224,6 +256700,7 @@ self: { ]; description = "Multidimensional integration over simplices"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; }) {}; "scuttlebutt-types" = callPackage @@ -258445,7 +256922,9 @@ self: { executablePkgconfigDepends = [ SDL2 SDL2_gfx ]; description = "Haskell bindings to SDL2_gfx"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "sdl2-gfx-example"; + broken = true; }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_gfx;}; "sdl2-image" = callPackage @@ -258468,7 +256947,9 @@ self: { executablePkgconfigDepends = [ SDL2 SDL2_image ]; description = "Haskell bindings to SDL2_image"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "sdl2-image-example"; + broken = true; }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_image;}; "sdl2-mixer" = callPackage @@ -258493,6 +256974,8 @@ self: { description = "Haskell bindings to SDL2_mixer"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) SDL2_mixer;}; "sdl2-sprite" = callPackage @@ -258513,6 +256996,7 @@ self: { ]; description = "Sprite previewer/animator"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "sdl2-sprite"; }) {}; @@ -258534,6 +257018,8 @@ self: { description = "Bindings to SDL2_ttf"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;}; "sdnv" = callPackage @@ -258987,6 +257473,30 @@ self: { license = lib.licenses.mit; }) {inherit (pkgs) secp256k1;}; + "secp256k1-haskell_0_7_0" = callPackage + ({ mkDerivation, base, base16, bytestring, cereal, deepseq, entropy + , hashable, hspec, hspec-discover, HUnit, monad-par, mtl + , QuickCheck, secp256k1, string-conversions, unliftio-core + }: + mkDerivation { + pname = "secp256k1-haskell"; + version = "0.7.0"; + sha256 = "02q6czma7lm9xqbxbck87imssjsnhlb6wabj11qikgshxcisddwv"; + libraryHaskellDepends = [ + base base16 bytestring cereal deepseq entropy hashable QuickCheck + string-conversions unliftio-core + ]; + libraryPkgconfigDepends = [ secp256k1 ]; + testHaskellDepends = [ + base base16 bytestring cereal deepseq entropy hashable hspec HUnit + monad-par mtl QuickCheck string-conversions unliftio-core + ]; + testToolDepends = [ hspec-discover ]; + description = "Bindings for secp256k1"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {inherit (pkgs) secp256k1;}; + "secp256k1-legacy" = callPackage ({ mkDerivation, base, base16-bytestring, bytestring, Cabal, cereal , cryptohash, entropy, HUnit, mtl, QuickCheck, string-conversions @@ -259193,6 +257703,8 @@ self: { ]; description = "Multi-backend, high-level EDSL for interacting with SQL databases"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "selda-json" = callPackage @@ -259204,6 +257716,7 @@ self: { libraryHaskellDepends = [ aeson base bytestring selda text ]; description = "JSON support for the Selda database library"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "selda-postgresql" = callPackage @@ -259238,6 +257751,7 @@ self: { ]; description = "SQLite backend for the Selda database EDSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "select" = callPackage @@ -259263,18 +257777,6 @@ self: { }) {}; "selective" = callPackage - ({ mkDerivation, base, containers, QuickCheck, transformers }: - mkDerivation { - pname = "selective"; - version = "0.5"; - sha256 = "18wd5wn8xaw0ilx34j292l06cqn6r2rri1wvxng8ygd8141sizdh"; - libraryHaskellDepends = [ base containers transformers ]; - testHaskellDepends = [ base containers QuickCheck transformers ]; - description = "Selective applicative functors"; - license = lib.licenses.mit; - }) {}; - - "selective_0_7" = callPackage ({ mkDerivation, base, containers, QuickCheck, transformers }: mkDerivation { pname = "selective"; @@ -259286,7 +257788,6 @@ self: { testHaskellDepends = [ base containers QuickCheck transformers ]; description = "Selective applicative functors"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "selectors" = callPackage @@ -259348,6 +257849,8 @@ self: { pname = "self-extract"; version = "0.4.1"; sha256 = "1jhwarhab9mwgiv1rahn4spkpfqdnwfa31pwgjy1k9mw2xdxslgs"; + revision = "1"; + editedCabalFile = "1hsr2kk660a2d5lgrrrl1vb315hqlgkhz8wnpjc8f6gyjd30hr72"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -259484,26 +257987,6 @@ self: { }) {}; "semialign" = callPackage - ({ mkDerivation, base, containers, hashable, indexed-traversable - , indexed-traversable-instances, semigroupoids, tagged, these - , transformers, unordered-containers, vector - }: - mkDerivation { - pname = "semialign"; - version = "1.2.0.1"; - sha256 = "0ci1jpp37p1lzyjxc1bljd6zgg407qmkl9s36b50qjxf85q6j06r"; - revision = "3"; - editedCabalFile = "0dbcdnksik508i12arh3s6bis6779lx5f1df0jkc0bp797inhd7f"; - libraryHaskellDepends = [ - base containers hashable indexed-traversable - indexed-traversable-instances semigroupoids tagged these - transformers unordered-containers vector - ]; - description = "Align and Zip type-classes from the common Semialign ancestor"; - license = lib.licenses.bsd3; - }) {}; - - "semialign_1_3" = callPackage ({ mkDerivation, base, containers, hashable, indexed-traversable , indexed-traversable-instances, semigroupoids, tagged, these , transformers, unordered-containers, vector @@ -259519,7 +258002,6 @@ self: { ]; description = "Align and Zip type-classes from the common Semialign ancestor"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "semialign-extras" = callPackage @@ -259554,6 +258036,8 @@ self: { doHaddock = false; description = "SemialignWithIndex, i.e. izipWith and ialignWith"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semialign-optics" = callPackage @@ -259568,6 +258052,8 @@ self: { doHaddock = false; description = "SemialignWithIndex, i.e. izipWith and ialignWith"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "semibounded-lattices" = callPackage @@ -259968,6 +258454,7 @@ self: { ]; description = "Parser for the SentiWordNet tab-separated file"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "sentry" = callPackage @@ -260135,8 +258622,8 @@ self: { ({ mkDerivation, base, mtl, transformers }: mkDerivation { pname = "seqid"; - version = "0.6.2"; - sha256 = "07xxpdrr3lqqnzcxbync46c0kz3d2i7k4day630a6x6zmzpyay0i"; + version = "0.6.3"; + sha256 = "0ggqnnj4cp0vq9s59v17592bpkwy8z715y1jbb1m1mwddhd1c4rz"; libraryHaskellDepends = [ base mtl transformers ]; description = "Sequence ID production and consumption"; license = lib.licenses.bsd3; @@ -260224,29 +258711,6 @@ self: { }) {}; "sequence-formats" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, containers, errors - , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec - , pipes-bytestring, pipes-safe, tasty, tasty-hunit, transformers - , vector - }: - mkDerivation { - pname = "sequence-formats"; - version = "1.6.6.1"; - sha256 = "0qylf0nx0g7z3wr95bza5vpmmsd4q3mvp8xsc7g2pwvsdpgxz9c9"; - libraryHaskellDepends = [ - attoparsec base bytestring containers errors exceptions foldl - lens-family pipes pipes-attoparsec pipes-bytestring pipes-safe - transformers vector - ]; - testHaskellDepends = [ - base bytestring containers foldl hspec pipes pipes-safe tasty - tasty-hunit transformers vector - ]; - description = "A package with basic parsing utilities for several Bioinformatic data formats"; - license = lib.licenses.gpl3Only; - }) {}; - - "sequence-formats_1_7_1" = callPackage ({ mkDerivation, attoparsec, base, bytestring, containers, errors , exceptions, foldl, hspec, lens-family, pipes, pipes-attoparsec , pipes-bytestring, pipes-safe, tasty, tasty-hunit, transformers @@ -260267,38 +258731,9 @@ self: { ]; description = "A package with basic parsing utilities for several Bioinformatic data formats"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "sequenceTools" = callPackage - ({ mkDerivation, ansi-wl-pprint, base, bytestring, foldl, hspec - , lens-family, optparse-applicative, pipes, pipes-group - , pipes-ordered-zip, pipes-safe, random, sequence-formats, split - , transformers, vector - }: - mkDerivation { - pname = "sequenceTools"; - version = "1.5.2"; - sha256 = "1fbdsyszmkgwiv06145s76m22a60xmmgrhv9xfwc1691jjwwbdl3"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring optparse-applicative pipes random sequence-formats - vector - ]; - executableHaskellDepends = [ - ansi-wl-pprint base bytestring foldl lens-family - optparse-applicative pipes pipes-group pipes-ordered-zip pipes-safe - random sequence-formats split transformers vector - ]; - testHaskellDepends = [ - base bytestring hspec pipes sequence-formats vector - ]; - description = "A package with tools for processing DNA sequencing data"; - license = lib.licenses.gpl3Only; - }) {}; - - "sequenceTools_1_5_3_1" = callPackage ({ mkDerivation, ansi-wl-pprint, base, bytestring, foldl, hspec , lens-family, optparse-applicative, pipes, pipes-group , pipes-ordered-zip, pipes-safe, random, sequence-formats, split @@ -260324,7 +258759,6 @@ self: { ]; description = "A package with tools for processing DNA sequencing data"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "sequent-core" = callPackage @@ -260395,6 +258829,8 @@ self: { ]; description = "Interact with Serf via Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "serial" = callPackage @@ -260507,6 +258943,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 @@ -260612,8 +259050,8 @@ self: { pname = "servant"; version = "0.19.1"; sha256 = "1gk6j39rcjpjacs351lknhrwj86yr4ifyp3qwlmiig27dxqlig3q"; - revision = "1"; - editedCabalFile = "1w5ky216hf4qiy0gw815l1f6vp0cdd0sa3n43gr2il223fq775ja"; + revision = "2"; + editedCabalFile = "01232431a6asv5pd1rshnh1zix7mdjy56m5zr6gz4179619ggf47"; libraryHaskellDepends = [ aeson attoparsec base base-compat bifunctors bytestring case-insensitive constraints deepseq http-api-data http-media @@ -260629,6 +259067,36 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant_0_20" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base-compat, bifunctors + , bytestring, case-insensitive, constraints, deepseq, hspec + , hspec-discover, http-api-data, http-media, http-types, mmorph + , mtl, network-uri, QuickCheck, quickcheck-instances + , singleton-bool, sop-core, string-conversions, tagged, text + , transformers, vault + }: + mkDerivation { + pname = "servant"; + version = "0.20"; + sha256 = "09vmz4jy6968hq8bf2b43bzpca8h8sps1h2xqf9y6wcarxbws1pi"; + revision = "2"; + editedCabalFile = "1jwdj2n53gd29n75ylla61jidsw2wy8ddy03jhgw2ghzwnhkdpzi"; + libraryHaskellDepends = [ + aeson attoparsec base base-compat bifunctors bytestring + case-insensitive constraints deepseq http-api-data http-media + http-types mmorph mtl network-uri QuickCheck singleton-bool + sop-core string-conversions tagged text transformers vault + ]; + testHaskellDepends = [ + aeson base base-compat bytestring hspec http-media mtl QuickCheck + quickcheck-instances string-conversions text transformers + ]; + testToolDepends = [ hspec-discover ]; + description = "A family of combinators for defining webservices APIs"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-JuicyPixels" = callPackage ({ mkDerivation, base, bytestring, http-media, JuicyPixels, servant , servant-server, wai, warp @@ -260647,7 +259115,9 @@ self: { ]; description = "Servant support for JuicyPixels"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "image-conversion"; + broken = true; }) {}; "servant-aeson-specs" = callPackage @@ -260685,8 +259155,8 @@ self: { pname = "servant-auth"; version = "0.4.1.0"; sha256 = "08ggnlknhzdpf49zjm1qpzm12gckss7yr8chmzm6h6ycigz77ndd"; - revision = "5"; - editedCabalFile = "0azlfs9dvzcf2r3kbm76wmalyhg1w0vi9gc4xlwp8m2n509qhbda"; + revision = "7"; + editedCabalFile = "18ylz2071416hhiqy7n72dvpsfy2cmhsh5j96mmcmgx05fcpkswg"; libraryHaskellDepends = [ aeson base containers jose lens servant text unordered-containers ]; @@ -260703,10 +259173,10 @@ self: { }: mkDerivation { pname = "servant-auth-client"; - version = "0.4.1.0"; - sha256 = "16rmwdrx0qyqa821ipayczzl3gv8gvqgx8k9q8qaw19w87hwkh83"; - revision = "6"; - editedCabalFile = "0d6mi3w3gx9h21awf1gy2wx7dwh5l9ichww21a3p5rfd8a8swypf"; + version = "0.4.1.1"; + sha256 = "1fs00p15hz2lqspby2xg6h0zxmlljm6wgi0wk73a4gavyg26dgqq"; + revision = "1"; + editedCabalFile = "1ff5hcpc56w7q97myavmfrl5m8sv38mjcw83lgyy0g56d893svhw"; libraryHaskellDepends = [ base bytestring containers servant servant-auth servant-client-core ]; @@ -260761,8 +259231,8 @@ self: { pname = "servant-auth-docs"; version = "0.2.10.0"; sha256 = "0j1ynnrb6plrhpb2vzs2p7a9jb41llp0j1jwgap7hjhkwhyc7wxd"; - revision = "11"; - editedCabalFile = "1xk6j4l5jccwzk0xkiv6ny6w33g92wziacqvqgc5rvy2mzyff4fl"; + revision = "12"; + editedCabalFile = "14vihxy2zkyhg27fgyrg2zcvws7v12ypap48rv2l7h918gcyxs5v"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ base lens servant servant-auth servant-docs text @@ -260776,6 +259246,31 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-auth-docs_0_2_10_1" = callPackage + ({ mkDerivation, base, Cabal, cabal-doctest, doctest, hspec + , hspec-discover, lens, QuickCheck, servant, servant-auth + , servant-docs, template-haskell, text + }: + mkDerivation { + pname = "servant-auth-docs"; + version = "0.2.10.1"; + sha256 = "03dnh6x0y34npmv9w2f3hc9r1brlzf2rki6c6ngvwb3dvichhykv"; + revision = "1"; + editedCabalFile = "0l4y7cnbfhad9f3mfv6zzm9qm9gc6g8k4s9vgrvn78jdrpmbbxxr"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + base lens servant servant-auth servant-docs + ]; + testHaskellDepends = [ + base doctest hspec lens QuickCheck servant servant-auth + servant-docs template-haskell text + ]; + testToolDepends = [ hspec-discover ]; + description = "servant-docs/servant-auth compatibility"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-auth-hmac" = callPackage ({ mkDerivation, aeson, attoparsec, base, base64-bytestring , blaze-html, blaze-markup, bytestring, case-insensitive, cereal @@ -260824,10 +259319,10 @@ self: { }: mkDerivation { pname = "servant-auth-server"; - version = "0.4.7.0"; - sha256 = "1m145xxqg1xy7i1br9yfh3avwkb30zh808nr658ljl7j2imlknj2"; - revision = "4"; - editedCabalFile = "1qcgm2pqi5qjqk27632h69j8ishls6cby8gghvww73wi63fqii9n"; + version = "0.4.8.0"; + sha256 = "0drny9m2js619pkxxa1mxji5x4r46kpv3qnmswyrb3kc0ck5c2af"; + revision = "1"; + editedCabalFile = "0dff8ycslxv5zy74wiph27sscd2p3zkq09j043yy8mnaypmpn4xr"; libraryHaskellDepends = [ aeson base base64-bytestring blaze-builder bytestring case-insensitive cookie data-default-class entropy http-types jose @@ -260837,11 +259332,13 @@ self: { testHaskellDepends = [ aeson base bytestring case-insensitive hspec http-client http-types jose lens lens-aeson mtl QuickCheck servant servant-auth - servant-server time transformers wai warp wreq + servant-server text time transformers wai warp wreq ]; testToolDepends = [ hspec-discover markdown-unlit ]; description = "servant-server/servant-auth compatibility"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-auth-swagger" = callPackage @@ -260850,10 +259347,10 @@ self: { }: mkDerivation { pname = "servant-auth-swagger"; - version = "0.2.10.1"; - sha256 = "029nvb4wxwl98ah26bgcq1b7izrnvssxwn1682liimvsh4a8bady"; - revision = "8"; - editedCabalFile = "19hp58cf3avq3jnzhspsxkb7vml8ch3cw7dq8qy59xp1wgci6v5m"; + version = "0.2.10.2"; + sha256 = "0f4sn0xlsq8lcnyj0q978bamfav6jmfkkccrg2k5l7rndif4nmwg"; + revision = "1"; + editedCabalFile = "1b4qk84fxs3fn21i8cfcqynl6549rzswyybi613w7raaxgnidqrv"; libraryHaskellDepends = [ base lens servant servant-auth servant-swagger swagger2 text ]; @@ -261059,8 +259556,8 @@ self: { pname = "servant-blaze"; version = "0.9.1"; sha256 = "08fvy904mz5xjqda702kq4ch25m3nda1yhpp4g7i62j0jmxs2ji6"; - revision = "1"; - editedCabalFile = "1y38lzmh5jr3bix0cqrcx9zkjdr1598hz7rvpnm827qw0ln3cmra"; + revision = "2"; + editedCabalFile = "1bc933vfxwdcpgfxy34dkxpadv8j1j053rjxfl4lj0gajwxc5x48"; libraryHaskellDepends = [ base blaze-html http-media servant ]; testHaskellDepends = [ base blaze-html servant-server wai warp ]; description = "Blaze-html support for servant"; @@ -261172,8 +259669,8 @@ self: { pname = "servant-client"; version = "0.19"; sha256 = "1bdapsr6il0f019ss8wsxndpc8cd5czj40xczay5qhl7fqnxg5pa"; - revision = "5"; - editedCabalFile = "196r9jxf0inyqidhz1d1hwmgn10baszl6vcv1hybq55mzb147kqb"; + revision = "6"; + editedCabalFile = "0lakjnpvsiai08c5nddgzrnr0a139rr37cyq31hqcbwnsy553l1y"; libraryHaskellDepends = [ base base-compat bytestring containers deepseq exceptions http-client http-media http-types kan-extensions monad-control mtl @@ -261191,6 +259688,39 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-client_0_20" = callPackage + ({ mkDerivation, aeson, base, base-compat, bytestring, containers + , deepseq, entropy, exceptions, hspec, hspec-discover + , http-api-data, http-client, http-media, http-types, HUnit + , kan-extensions, markdown-unlit, monad-control, mtl, network + , QuickCheck, semigroupoids, servant, servant-client-core + , servant-server, sop-core, stm, text, time, transformers + , transformers-base, transformers-compat, wai, warp + }: + mkDerivation { + pname = "servant-client"; + version = "0.20"; + sha256 = "0xmjqc54yq5akhw5ydbx5k0c1pnrryma8nczwyzvwx4vazrk0pbn"; + revision = "1"; + editedCabalFile = "1bvj0rnnyqw3h70b94k9j21np5h0acxn4cla2gsv9zclhd99f4q6"; + libraryHaskellDepends = [ + base base-compat bytestring containers deepseq exceptions + http-client http-media http-types kan-extensions monad-control mtl + semigroupoids servant servant-client-core stm text time + transformers transformers-base transformers-compat + ]; + testHaskellDepends = [ + aeson base base-compat bytestring entropy hspec http-api-data + http-client http-types HUnit kan-extensions markdown-unlit mtl + network QuickCheck servant servant-client-core servant-server + sop-core stm text transformers transformers-compat wai warp + ]; + testToolDepends = [ hspec-discover markdown-unlit ]; + description = "Automatic derivation of querying functions for servant"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-client-core" = callPackage ({ mkDerivation, aeson, base, base-compat, base64-bytestring , bytestring, constraints, containers, deepseq, exceptions, free @@ -261216,6 +259746,32 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-client-core_0_20" = callPackage + ({ mkDerivation, aeson, base, base-compat, base64-bytestring + , bytestring, constraints, containers, deepseq, exceptions, free + , hspec, hspec-discover, http-media, http-types, network-uri + , QuickCheck, safe, servant, sop-core, template-haskell, text + , transformers + }: + mkDerivation { + pname = "servant-client-core"; + version = "0.20"; + sha256 = "012bdf3c44bqzb0ycns4pcxb0zidqqn7lpzz9316kiwy0wb4jx56"; + revision = "1"; + editedCabalFile = "0nkgan32s6v5s3sqk5wdw1m977gszwi8lnap5wrr3m47q7j4003l"; + libraryHaskellDepends = [ + aeson base base-compat base64-bytestring bytestring constraints + containers deepseq exceptions free http-media http-types + network-uri safe servant sop-core template-haskell text + transformers + ]; + testHaskellDepends = [ base base-compat deepseq hspec QuickCheck ]; + testToolDepends = [ hspec-discover ]; + description = "Core functionality and class for client function generation for servant APIs"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-client-js" = callPackage ({ mkDerivation, base, binary, bytestring, case-insensitive , containers, exceptions, http-media, http-types, jsaddle @@ -261281,6 +259837,8 @@ self: { ]; description = "Extra servant combinators for full WAI functionality"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-conduit" = callPackage @@ -261305,6 +259863,27 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-conduit_0_16" = callPackage + ({ mkDerivation, base, base-compat, bytestring, conduit + , http-client, http-media, mtl, resourcet, servant, servant-client + , servant-server, unliftio-core, wai, warp + }: + mkDerivation { + pname = "servant-conduit"; + version = "0.16"; + sha256 = "037vqqq5k2jm6s7gg2shb6iyvjfblsr41ifjpryfxmsib669vs9f"; + libraryHaskellDepends = [ + base bytestring conduit mtl resourcet servant unliftio-core + ]; + testHaskellDepends = [ + base base-compat bytestring conduit http-client http-media + resourcet servant servant-client servant-server wai warp + ]; + description = "Servant Stream support for conduit"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-csharp" = callPackage ({ mkDerivation, aeson, base, bytestring, directory, filepath , heredocs, http-types, lens, mtl, servant, servant-foreign @@ -261397,8 +259976,8 @@ self: { pname = "servant-docs"; version = "0.12"; sha256 = "0531jldq35sl1qlna0s1n8bakbsplg15611305dk48z80vcpa933"; - revision = "5"; - editedCabalFile = "191kb72gzyxr6w2a56775hhlckyg6ll9sasay7qqqg7mg7yvlfpn"; + revision = "6"; + editedCabalFile = "14lxzg47mqc02i1xy6przkwndvhx8a93l12v4ag3q9ziyj51ra5d"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -261418,6 +259997,36 @@ self: { mainProgram = "greet-docs"; }) {}; + "servant-docs_0_13" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring + , case-insensitive, hashable, http-media, http-types, lens, servant + , string-conversions, tasty, tasty-golden, tasty-hunit, text + , transformers, universe-base, unordered-containers + }: + mkDerivation { + pname = "servant-docs"; + version = "0.13"; + sha256 = "0i91my86bcnn0jckf2qlfyx1zfbg8w6959v7iim60s3mdx9yjp67"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base base-compat bytestring case-insensitive + hashable http-media http-types lens servant string-conversions text + universe-base unordered-containers + ]; + executableHaskellDepends = [ + aeson base lens servant string-conversions text + ]; + testHaskellDepends = [ + aeson base base-compat lens servant string-conversions tasty + tasty-golden tasty-hunit transformers + ]; + description = "generate API docs for your servant webservice"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "greet-docs"; + }) {}; + "servant-docs-simple" = callPackage ({ mkDerivation, aeson, aeson-pretty, base, bytestring, hspec , hspec-core, prettyprinter, raw-strings-qq, servant, text @@ -261646,8 +260255,8 @@ self: { pname = "servant-foreign"; version = "0.15.4"; sha256 = "0bznb73rbgfgkg7n4pxghkqsfca0yw9vak73c6w8sqvc2mjnc7mz"; - revision = "7"; - editedCabalFile = "1s1kxmfs0wzwx9mmlzw49a7x3bf0lm63cpn9bnbm3r12v7p01x71"; + revision = "8"; + editedCabalFile = "0dkcdch9m307ydziyh5gg2lnbjvh8p8k2qhwsgjsw9ss5sy0s9pf"; libraryHaskellDepends = [ base base-compat http-types lens servant text ]; @@ -261655,6 +260264,29 @@ self: { testToolDepends = [ hspec-discover ]; description = "Helpers for generating clients for servant APIs in any programming language"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + + "servant-foreign_0_16" = callPackage + ({ mkDerivation, base, base-compat, hspec, hspec-discover + , http-types, lens, servant, text + }: + mkDerivation { + pname = "servant-foreign"; + version = "0.16"; + sha256 = "15pir0x7dcyjmw71g4w00qgvcxyvhbkywzc3bvvaaprk5bjb3bmv"; + revision = "1"; + editedCabalFile = "17rnd7dnkj5p8jpbmlgysacrdxxhczd4ll8r5r3bpd56yhj8wm2c"; + libraryHaskellDepends = [ + base base-compat http-types lens servant text + ]; + testHaskellDepends = [ base hspec servant ]; + testToolDepends = [ hspec-discover ]; + description = "Helpers for generating clients for servant APIs in any programming language"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "servant-gdp" = callPackage @@ -261840,8 +260472,8 @@ self: { pname = "servant-http-streams"; version = "0.18.4"; sha256 = "15f24rcgz839cb38q4gs1liqrdyqjbazcqzjdxmv4307x072pv3a"; - revision = "6"; - editedCabalFile = "1nr0xdc21lwb12fi8nfgz8f3vm1xyl7pj28h17y51ybq84ydzljh"; + revision = "7"; + editedCabalFile = "1m7zdskz9dv51xzjw8bxwssfsir0fz0dsi9hx785fnc3a0lvvrlz"; libraryHaskellDepends = [ base base-compat bytestring case-insensitive containers deepseq exceptions http-common http-media http-streams http-types @@ -261859,6 +260491,44 @@ 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-http-streams_0_20" = callPackage + ({ mkDerivation, aeson, base, base-compat, bytestring + , case-insensitive, containers, deepseq, entropy, exceptions, hspec + , hspec-discover, http-api-data, http-common, http-media + , http-streams, http-types, HUnit, io-streams, kan-extensions + , markdown-unlit, monad-control, mtl, network, QuickCheck + , semigroupoids, servant, servant-client-core, servant-server, stm + , text, time, transformers, transformers-base, transformers-compat + , wai, warp + }: + mkDerivation { + pname = "servant-http-streams"; + version = "0.20"; + sha256 = "1pakvvw8m7dkwf8zfrh2gan1hs5zp4mgnn4bp0wiy49mc3zzlxwi"; + revision = "1"; + editedCabalFile = "19dficaknm55bgp2sccr9zgxir39cz35h41cgm1w86dxmxv2bzxy"; + libraryHaskellDepends = [ + base base-compat bytestring case-insensitive containers deepseq + exceptions http-common http-media http-streams http-types + io-streams kan-extensions monad-control mtl semigroupoids servant + servant-client-core text time transformers transformers-base + transformers-compat + ]; + testHaskellDepends = [ + aeson base base-compat bytestring deepseq entropy hspec + http-api-data http-streams http-types HUnit kan-extensions + markdown-unlit mtl network QuickCheck servant servant-client-core + servant-server stm text transformers transformers-compat wai warp + ]; + 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 @@ -261948,6 +260618,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Automatically derive javascript functions to query servant webservices"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-jsonrpc" = callPackage @@ -262056,6 +260727,25 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-machines_0_16" = callPackage + ({ mkDerivation, base, base-compat, bytestring, http-client + , http-media, machines, mtl, servant, servant-client + , servant-server, wai, warp + }: + mkDerivation { + pname = "servant-machines"; + version = "0.16"; + sha256 = "0c2cz96m9lbzr318i4vpy55y37xagh7sf1g0hvxbsvwhnzqa4532"; + libraryHaskellDepends = [ base bytestring machines mtl servant ]; + testHaskellDepends = [ + base base-compat bytestring http-client http-media machines servant + servant-client servant-server wai warp + ]; + description = "Servant Stream support for machines"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-match" = callPackage ({ mkDerivation, base, bytestring, hspec, http-types, network-uri , servant, text, utf8-string @@ -262147,6 +260837,7 @@ self: { ]; description = "multipart/form-data (e.g file upload) support for servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-multipart-api" = callPackage @@ -262189,6 +260880,7 @@ self: { ]; description = "multipart/form-data (e.g file upload) support for servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-named" = callPackage @@ -262310,8 +261002,8 @@ self: { pname = "servant-openapi3"; version = "2.0.1.6"; sha256 = "1hxz3n6l5l8p9s58sjilrn4lv1z17kfik0xdh05v5v1bzf0j2aij"; - revision = "3"; - editedCabalFile = "0pnj7ns6lk5jb2p7i7y2mdyi7bcvf0yj23fzzc3z532zj8a28vaq"; + revision = "4"; + editedCabalFile = "1x3pbd5bix864xiavhsq72965ffzalifix0hkdr5gahqfjk088dc"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ aeson aeson-pretty base base-compat bytestring hspec http-media @@ -262342,6 +261034,7 @@ self: { ]; description = "Provide responses to OPTIONS requests for Servant applications"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "servant-pagination" = callPackage @@ -262404,6 +261097,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-pipes_0_16" = callPackage + ({ mkDerivation, base, base-compat, bytestring, http-client + , http-media, monad-control, mtl, pipes, pipes-bytestring + , pipes-safe, servant, servant-client, servant-server, wai, warp + }: + mkDerivation { + pname = "servant-pipes"; + version = "0.16"; + sha256 = "00n2rmv4aar49247is2sgy58nal64lv05zci9lhkbgmmmi1hqd10"; + libraryHaskellDepends = [ + base bytestring monad-control mtl pipes pipes-safe servant + ]; + testHaskellDepends = [ + base base-compat bytestring http-client http-media pipes + pipes-bytestring pipes-safe servant servant-client servant-server + wai warp + ]; + description = "Servant Stream support for pipes"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-polysemy" = callPackage ({ mkDerivation, base, deepseq, http-client, http-client-tls, lens , mtl, polysemy, polysemy-plugin, polysemy-zoo, servant @@ -262427,6 +261142,7 @@ self: { ]; description = "Utilities for using servant in a polysemy stack"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-pool" = callPackage @@ -262808,6 +261524,7 @@ self: { testHaskellDepends = [ base doctest QuickCheck ]; description = "Generate a Ruby client from a Servant API with Net::HTTP"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "servant-scotty" = callPackage @@ -262860,8 +261577,8 @@ self: { }: mkDerivation { pname = "servant-serf"; - version = "0.3.1.3"; - sha256 = "0zlfy0xc4ssy7s68i6hddlkz41fa95490yhg19m1lvkqvc6mac2c"; + version = "0.3.1.4"; + sha256 = "0vl8bs8r0z8rb1v3pd79sbb00b9f7a7i1q85csr313wc9nss6y7p"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -262900,6 +261617,7 @@ self: { QuickCheck serialise servant text ]; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "example"; }) {}; @@ -262943,6 +261661,47 @@ self: { mainProgram = "greet"; }) {}; + "servant-server_0_20" = callPackage + ({ mkDerivation, aeson, base, base-compat, base64-bytestring + , bytestring, constraints, containers, directory, exceptions + , filepath, hspec, hspec-discover, hspec-wai, http-api-data + , http-media, http-types, monad-control, mtl, network, network-uri + , QuickCheck, resourcet, safe, servant, should-not-typecheck + , sop-core, string-conversions, tagged, temporary, text + , transformers, transformers-base, transformers-compat, wai + , wai-app-static, wai-extra, warp, word8 + }: + mkDerivation { + pname = "servant-server"; + version = "0.20"; + sha256 = "1gp8pslk2sspi5vzrl1nimndpif7jhgzlffi2mzf1ap1bdwgxchk"; + revision = "1"; + editedCabalFile = "0x7z23b3m22afczlnmajcmmcyq9dxvhlv71si0nniz9vzc45l2yb"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base base-compat base64-bytestring bytestring constraints + containers exceptions filepath http-api-data http-media http-types + monad-control mtl network network-uri resourcet servant sop-core + string-conversions tagged text transformers transformers-base wai + wai-app-static word8 + ]; + executableHaskellDepends = [ + aeson base base-compat servant text wai warp + ]; + testHaskellDepends = [ + aeson base base-compat base64-bytestring bytestring directory hspec + hspec-wai http-types mtl QuickCheck resourcet safe servant + should-not-typecheck sop-core string-conversions temporary text + transformers transformers-compat wai wai-extra + ]; + testToolDepends = [ hspec-discover ]; + description = "A family of combinators for defining webservices APIs and serving them"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "greet"; + }) {}; + "servant-server-namedargs" = callPackage ({ mkDerivation, base, bytestring, http-api-data, http-types, named , servant, servant-namedargs, servant-server, string-conversions @@ -263214,6 +261973,7 @@ self: { executableHaskellDepends = [ base purescript-bridge ]; description = "When REST is not enough ..."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "subscriber-psGenerator"; }) {}; @@ -263247,6 +262007,37 @@ self: { license = lib.licenses.bsd3; }) {}; + "servant-swagger_1_2" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring + , Cabal, cabal-doctest, directory, doctest, filepath, hspec + , hspec-discover, http-media, insert-ordered-containers, lens + , lens-aeson, QuickCheck, servant, singleton-bool, swagger2 + , template-haskell, text, time, unordered-containers, utf8-string + , vector + }: + mkDerivation { + pname = "servant-swagger"; + version = "1.2"; + sha256 = "1dim4vlsd9zcz3ra0qwvb4hlbj0iarxygz78ksw8nbvqgbym3zjh"; + revision = "1"; + editedCabalFile = "1l2459b88hsnz96zqp6iy51kcb0d6pnlf4dwa22vcimhg58vsk89"; + setupHaskellDepends = [ base Cabal cabal-doctest ]; + libraryHaskellDepends = [ + aeson aeson-pretty base base-compat bytestring hspec http-media + insert-ordered-containers lens QuickCheck servant singleton-bool + swagger2 text unordered-containers + ]; + testHaskellDepends = [ + aeson base base-compat directory doctest filepath hspec lens + lens-aeson QuickCheck servant swagger2 template-haskell text time + utf8-string vector + ]; + testToolDepends = [ hspec-discover ]; + description = "Generate a Swagger/OpenAPI/OAS 2.0 specification for your servant API."; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "servant-swagger-tags" = callPackage ({ mkDerivation, base, insert-ordered-containers, lens, servant , servant-mock, servant-server, servant-swagger, swagger2, text @@ -263272,6 +262063,8 @@ self: { pname = "servant-swagger-ui"; version = "0.3.5.5.0.0"; sha256 = "1sjgakdln2nx9ki13vk557rfqwqjksagl32q7y3m8mc9y9s80py7"; + revision = "1"; + editedCabalFile = "1gagm56yy19lbwkcfx9jz7lkhvqxka0xy5pzqks1k2kbz16v8vvs"; libraryHaskellDepends = [ aeson base bytestring file-embed-lzma servant servant-server servant-swagger-ui-core text @@ -263289,8 +262082,8 @@ self: { pname = "servant-swagger-ui-core"; version = "0.3.5"; sha256 = "0ckvrwrb3x39hfl2hixcj3fhibh0vqsh6y7n1lsm25yvzfrg02zd"; - revision = "6"; - editedCabalFile = "1lksxaxmw9ylimfkfcnqchrpqhmykhxa294kd2bwl1qs1rvyslfb"; + revision = "7"; + editedCabalFile = "157jdld3izr32m5fr2y7s8fw16hamh7hb8cm7ybry3fvmsj01zpc"; libraryHaskellDepends = [ aeson base blaze-markup bytestring http-media servant servant-blaze servant-server text transformers transformers-compat wai-app-static @@ -263307,8 +262100,8 @@ self: { pname = "servant-swagger-ui-jensoleg"; version = "0.3.4"; sha256 = "04s4syfmnjwa52xqm29x2sfi1ka6p7fpjff0pxry099rh0d59hkm"; - revision = "4"; - editedCabalFile = "145yljjkb4pmpkcic77qy99v0s4ijvzgsrpcwpjcmnmi5y8f39zm"; + revision = "5"; + editedCabalFile = "1yb32cgkhydc9gpr22yzqkgmf8d6kvgvb8ypsmp81aiq3v94r2ki"; libraryHaskellDepends = [ aeson base bytestring file-embed-lzma servant servant-server servant-swagger-ui-core text @@ -263325,8 +262118,8 @@ self: { pname = "servant-swagger-ui-redoc"; version = "0.3.4.1.22.3"; sha256 = "0ln2sz7ffhddk4dqvczpxb5g8f6bic7sandn5zifpz2jg7lgzy0f"; - revision = "4"; - editedCabalFile = "17spfmrwvj24hxd5sxysn6l3a449nw0ln2m6fslrr7wy4czp2kj5"; + revision = "5"; + editedCabalFile = "1jxsyi45892n4gg2ihhf66jarplvifm0hp66srzkc7lchhz9lzz2"; libraryHaskellDepends = [ aeson base bytestring file-embed-lzma servant servant-server servant-swagger-ui-core text @@ -263429,6 +262222,7 @@ self: { ]; description = "TypeScript client generation for Servant"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "servant-typescript-exe"; }) {}; @@ -263600,23 +262394,6 @@ self: { }) {}; "servant-xml" = callPackage - ({ mkDerivation, base, bytestring, http-media, servant, xmlbf - , xmlbf-xeno - }: - mkDerivation { - pname = "servant-xml"; - version = "1.0.1.4"; - sha256 = "0jzzw4bwjcnax53xx8yjfldd21zgbvynpagf1ikxpzq3sgqhdl2x"; - libraryHaskellDepends = [ - base bytestring http-media servant xmlbf xmlbf-xeno - ]; - description = "Servant support for the XML Content-Type"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "servant-xml_1_0_2" = callPackage ({ mkDerivation, base, bytestring, http-media, servant, xmlbf , xmlbf-xeno }: @@ -264464,7 +263241,9 @@ self: { testHaskellDepends = [ base data-default hspec megaparsec ]; description = "Simple s-expression parser"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "sexpr-parser-z3-demo"; + broken = true; }) {}; "sexpresso" = callPackage @@ -264896,7 +263675,7 @@ self: { license = lib.licenses.bsd3; }) {}; - "shake-cabal" = callPackage + "shake-cabal_0_2_2_2" = callPackage ({ mkDerivation, base, binary, Cabal, composition-prelude, deepseq , directory, filepath, hashable, shake }: @@ -264912,9 +263691,10 @@ self: { ]; description = "Shake library for use with cabal"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; - "shake-cabal_0_2_2_3" = callPackage + "shake-cabal" = callPackage ({ mkDerivation, base, binary, Cabal, composition-prelude, deepseq , directory, filepath, hashable, shake }: @@ -264928,7 +263708,6 @@ self: { ]; description = "Shake library for use with cabal"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "shake-cabal-build" = callPackage @@ -265176,6 +263955,7 @@ self: { ]; description = "Experimental extensions to shake-plus"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "shakebook" = callPackage @@ -265269,32 +264049,6 @@ self: { }) {}; "shakespeare" = callPackage - ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring - , containers, directory, exceptions, file-embed, ghc-prim, hspec - , HUnit, parsec, process, scientific, template-haskell, text - , th-lift, time, transformers, unordered-containers, vector - }: - mkDerivation { - pname = "shakespeare"; - version = "2.0.30"; - sha256 = "038yprj9yig2xbjs2pqsjzs4pl9ir2frdz9wn2pklc4kvdazx3aw"; - libraryHaskellDepends = [ - aeson base blaze-html blaze-markup bytestring containers directory - exceptions file-embed ghc-prim parsec process scientific - template-haskell text th-lift time transformers - unordered-containers vector - ]; - testHaskellDepends = [ - aeson base blaze-html blaze-markup bytestring containers directory - exceptions ghc-prim hspec HUnit parsec process template-haskell - text time transformers - ]; - description = "A toolkit for making compile-time interpolated templates"; - license = lib.licenses.mit; - maintainers = [ lib.maintainers.psibi ]; - }) {}; - - "shakespeare_2_1_0" = callPackage ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring , containers, directory, exceptions, file-embed, ghc-prim, hspec , HUnit, parsec, process, scientific, template-haskell, text @@ -265317,7 +264071,6 @@ self: { ]; description = "A toolkit for making compile-time interpolated templates"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.psibi ]; }) {}; @@ -265753,6 +264506,31 @@ self: { maintainers = [ lib.maintainers.thielema ]; }) {}; + "shellify" = callPackage + ({ mkDerivation, base, containers, data-default-class, directory + , extra, hspec, hspec-core, HStringTemplate, mtl, raw-strings-qq + , shake, text, unordered-containers + }: + mkDerivation { + pname = "shellify"; + version = "0.10.0.1"; + sha256 = "0wih7jl3za8cm62wk8zplyc94356ccrck1kri814z4pk7dav50lv"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers data-default-class directory extra HStringTemplate + mtl raw-strings-qq shake text unordered-containers + ]; + executableHaskellDepends = [ base raw-strings-qq text ]; + testHaskellDepends = [ base hspec hspec-core raw-strings-qq text ]; + description = "A tool for generating shell.nix files"; + license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + mainProgram = "shellify"; + maintainers = [ lib.maintainers.danielrolls ]; + broken = true; + }) {}; + "shellish" = callPackage ({ mkDerivation, base, bytestring, directory, filepath, mtl , process, strict, time, unix-compat @@ -265821,7 +264599,9 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "Out of the shell solution for scripting in Haskell"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; mainProgram = "readme"; + broken = true; }) {}; "shellout" = callPackage @@ -265848,6 +264628,8 @@ self: { pname = "shelltestrunner"; version = "1.9"; sha256 = "1a5kzqbwg6990249ypw0cx6cqj6663as1kbj8nzblcky8j6kbi6b"; + revision = "1"; + editedCabalFile = "148yc2b81dm2lwwrrqhxfdh6ww5k2hgvj4vpq67w0ax09l3rphn5"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -265873,31 +264655,6 @@ self: { }) {}; "shelly" = callPackage - ({ mkDerivation, async, base, bytestring, containers, directory - , enclosed-exceptions, exceptions, filepath, hspec, hspec-contrib - , HUnit, lifted-async, lifted-base, monad-control, mtl, process - , text, time, transformers, transformers-base, unix-compat - }: - mkDerivation { - pname = "shelly"; - version = "1.10.0.1"; - sha256 = "0nm3yg6mhgxj670xn18v4zvzzqxqv9b1r6psdmsppgqny1szqm3x"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - async base bytestring containers directory enclosed-exceptions - exceptions filepath lifted-async lifted-base monad-control mtl - process text time transformers transformers-base unix-compat - ]; - testHaskellDepends = [ - base bytestring directory filepath hspec hspec-contrib HUnit - lifted-async mtl text transformers unix-compat - ]; - description = "shell-like (systems) programming in Haskell"; - license = lib.licenses.bsd3; - }) {}; - - "shelly_1_12_1" = callPackage ({ mkDerivation, async, base, bytestring, containers, directory , enclosed-exceptions, exceptions, filepath, hspec, hspec-contrib , HUnit, lifted-async, lifted-base, monad-control, mtl, process @@ -265920,7 +264677,6 @@ self: { ]; description = "shell-like (systems) programming in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "shelly-extra" = callPackage @@ -265966,8 +264722,8 @@ self: { }: mkDerivation { pname = "shh"; - version = "0.7.2.1"; - sha256 = "1p46q07mdk9w6agm5ggy34r62fqw6zlx4d32pkby852piy7aknnv"; + version = "0.7.2.2"; + sha256 = "1y12a65wf4k2piq49k8v0j01py1vlfmlg4y8p6nxh80qcw46g6li"; isLibrary = true; isExecutable = true; setupHaskellDepends = [ base Cabal cabal-doctest ]; @@ -265994,6 +264750,8 @@ self: { pname = "shh-extras"; version = "0.1.0.2"; sha256 = "0yax761d0xgc8nqg8h7y69fb1mwf88w73sznh3kffhlaladavskx"; + revision = "1"; + editedCabalFile = "1rk56bpsdiyylay8kmgky2i4bvxs6xjc3xdc1yssb2qv74gcl8wq"; libraryHaskellDepends = [ base hostname shh time ]; testHaskellDepends = [ base tasty ]; description = "Utility functions for using shh"; @@ -266038,6 +264796,8 @@ self: { ]; description = "Run a sequence of functions on in-memory representations of files"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "shimmer" = callPackage @@ -266373,6 +265133,8 @@ self: { libraryHaskellDepends = [ base ]; description = "convert types into string values in haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "showdown" = callPackage @@ -266679,6 +265441,29 @@ self: { mainProgram = "sigma-ij"; }) {}; + "sigmacord" = callPackage + ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring + , containers, data-default, emoji, http-api-data, http-client + , iso8601-time, MonadRandom, mtl, network, req, safe-exceptions + , scientific, text, time, unliftio, unordered-containers + , websockets, wuss + }: + mkDerivation { + pname = "sigmacord"; + version = "1.0.0"; + sha256 = "0y6v35b7sx93nx3jccglylzzax6axb83yrv18h79zhjwh18vl9ch"; + libraryHaskellDepends = [ + aeson async base base64-bytestring bytestring containers + data-default emoji http-api-data http-client iso8601-time + MonadRandom mtl network req safe-exceptions scientific text time + unliftio unordered-containers websockets wuss + ]; + description = "Write Discord Bots in Haskell"; + license = "GPL"; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "sign" = callPackage ({ mkDerivation, base, containers, deepseq, hashable, HUnit , lattices, QuickCheck, tasty, tasty-hunit, tasty-quickcheck @@ -267034,23 +265819,6 @@ self: { }) {}; "simple-affine-space" = callPackage - ({ mkDerivation, base, deepseq, directory, filepath, hlint, process - , regex-posix - }: - mkDerivation { - pname = "simple-affine-space"; - version = "0.1.1"; - sha256 = "172yn8kispqbn6zrdn610mh3l728ffb6lwa1zk5qgwm0lfpx3849"; - libraryHaskellDepends = [ base deepseq ]; - testHaskellDepends = [ - base directory filepath hlint process regex-posix - ]; - description = "A simple library for affine and vector spaces"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.turion ]; - }) {}; - - "simple-affine-space_0_2_1" = callPackage ({ mkDerivation, base, deepseq, directory, filepath, hlint, process , regex-posix }: @@ -267064,7 +265832,6 @@ self: { ]; description = "A simple library for affine and vector spaces"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.turion ]; }) {}; @@ -267285,6 +266052,8 @@ self: { benchmarkHaskellDepends = [ base criterion mtl transformers ]; description = "A simple effect system that integrates with MTL"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-enumeration" = callPackage @@ -267544,6 +266313,8 @@ self: { libraryHaskellDepends = [ base formatting simple-media-timestamp ]; description = "Formatting for simple-media-timestamp"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-money" = callPackage @@ -267633,6 +266404,8 @@ self: { ]; description = "Simple parser combinators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "simple-pascal" = callPackage @@ -267693,17 +266466,6 @@ self: { }) {}; "simple-prompt" = callPackage - ({ mkDerivation, base, extra }: - mkDerivation { - pname = "simple-prompt"; - version = "0.1.0"; - sha256 = "0a027k5jywpq4hssrhghnci2s32hqhpnphmybwbccl1m18zpay5r"; - libraryHaskellDepends = [ base extra ]; - description = "Simple commandline text prompt functions"; - license = lib.licenses.bsd3; - }) {}; - - "simple-prompt_0_2_0_1" = callPackage ({ mkDerivation, base, exceptions, extra, haskeline, time }: mkDerivation { pname = "simple-prompt"; @@ -267712,7 +266474,6 @@ self: { libraryHaskellDepends = [ base exceptions extra haskeline time ]; description = "Simple commandline text prompt functions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "simple-reflect" = callPackage @@ -267740,25 +266501,6 @@ self: { }) {}; "simple-sendfile" = callPackage - ({ mkDerivation, base, bytestring, conduit, conduit-extra - , directory, hspec, hspec-discover, HUnit, network, process - , resourcet, unix - }: - mkDerivation { - pname = "simple-sendfile"; - version = "0.2.31"; - sha256 = "0q65dnvmwwcvpzhg3963s7yy404h4yrjgxvdbjy0grrs1qi6w1v6"; - libraryHaskellDepends = [ base bytestring network unix ]; - testHaskellDepends = [ - base bytestring conduit conduit-extra directory hspec HUnit network - process resourcet unix - ]; - testToolDepends = [ hspec-discover ]; - description = "Cross platform library for the sendfile system call"; - license = lib.licenses.bsd3; - }) {}; - - "simple-sendfile_0_2_32" = callPackage ({ mkDerivation, base, bytestring, conduit, conduit-extra , directory, easy-file, hspec, hspec-discover, HUnit, network , process, resourcet, unix @@ -267775,7 +266517,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Cross platform library for the sendfile system call"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "simple-server" = callPackage @@ -268488,20 +267229,6 @@ self: { }) {}; "singletons" = callPackage - ({ mkDerivation, base }: - mkDerivation { - pname = "singletons"; - version = "3.0.1"; - sha256 = "0lqg9wxh02z2sikpy88asm8g4sfrvyb66b7p76irsij31h0cxbnk"; - revision = "1"; - editedCabalFile = "0n3jr9jqz50ygaw80a9cx3g09w7w8bdlq9ssyap0a4990yxl8fbx"; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ base ]; - description = "Basic singleton types and definitions"; - license = lib.licenses.bsd3; - }) {}; - - "singletons_3_0_2" = callPackage ({ mkDerivation, base }: mkDerivation { pname = "singletons"; @@ -268513,7 +267240,6 @@ self: { testHaskellDepends = [ base ]; description = "Basic singleton types and definitions"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "singletons-base" = callPackage @@ -268523,10 +267249,8 @@ self: { }: mkDerivation { pname = "singletons-base"; - version = "3.1"; - sha256 = "1bsfbdbfwiq2nis3r95x06r0q9iypyz4hkvmgvk56bwj6421k7kd"; - revision = "1"; - editedCabalFile = "12p0xzmrkn2bjz6wf9i291bh47s9c0ziz6cvvja65vnzwd8l60ry"; + version = "3.1.1"; + sha256 = "0d32c1dmi8mlrli0927g3hy6gip4c9w0myza3x594nlb6cnwdj6f"; setupHaskellDepends = [ base Cabal directory filepath ]; libraryHaskellDepends = [ base pretty singletons singletons-th template-haskell text @@ -268564,24 +267288,6 @@ self: { }) {}; "singletons-presburger" = callPackage - ({ mkDerivation, base, ghc-typelits-presburger, mtl, reflection - , singletons, singletons-base - }: - mkDerivation { - pname = "singletons-presburger"; - version = "0.6.1.0"; - sha256 = "1s12g1qcdz035y2lzjivw2m2jm9hqvbwvgmxvahn4a2j89f4zgky"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base ghc-typelits-presburger mtl reflection singletons - singletons-base - ]; - description = "Presburger Arithmetic Solver for GHC Type-level natural numbers with Singletons package"; - license = lib.licenses.bsd3; - }) {}; - - "singletons-presburger_0_7_2_0" = callPackage ({ mkDerivation, base, ghc, ghc-typelits-presburger, mtl , reflection, singletons, singletons-base }: @@ -268597,7 +267303,6 @@ self: { ]; description = "Presburger Arithmetic Solver for GHC Type-level natural numbers with Singletons package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "singletons-th" = callPackage @@ -268606,10 +267311,8 @@ self: { }: mkDerivation { pname = "singletons-th"; - version = "3.1"; - sha256 = "1mhx7sadw7zxaf7qhryrhi4fiyf9v3jcaplkh1syaa7b4725dm7a"; - revision = "2"; - editedCabalFile = "19ac6s4k6yv0lfrhkmgpf000k32rpm91lngs4955158792pa6fi6"; + version = "3.1.1"; + sha256 = "1bp9abhbk6ad27p0ksqx2nhrkp6r9dgx20dzyl3bq1zf6nz92ss6"; libraryHaskellDepends = [ base containers ghc-boot-th mtl singletons syb template-haskell th-desugar th-orphans transformers @@ -268700,6 +267403,8 @@ self: { ]; description = "Nat singletons represented by Int"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "siphash" = callPackage @@ -268912,32 +267617,6 @@ self: { }) {}; "sized" = callPackage - ({ mkDerivation, base, constraints, containers, deepseq - , equational-reasoning, ghc-typelits-knownnat - , ghc-typelits-presburger, hashable, inspection-testing, lens - , mono-traversable, subcategories, tasty, tasty-expected-failure - , tasty-inspection-testing, template-haskell, th-lift, these - , type-natural, vector - }: - mkDerivation { - pname = "sized"; - version = "1.0.0.2"; - sha256 = "0l6miv6dw0j5fdkiig7a8akhphrpxs8ls6xdakzpbk53bdh0093n"; - libraryHaskellDepends = [ - base constraints containers deepseq equational-reasoning - ghc-typelits-knownnat ghc-typelits-presburger hashable lens - mono-traversable subcategories these type-natural vector - ]; - testHaskellDepends = [ - base containers inspection-testing mono-traversable subcategories - tasty tasty-expected-failure tasty-inspection-testing - template-haskell th-lift type-natural vector - ]; - description = "Sized sequence data-types"; - license = lib.licenses.bsd3; - }) {}; - - "sized_1_1_0_0" = callPackage ({ mkDerivation, base, constraints, containers, deepseq , equational-reasoning, ghc-typelits-knownnat , ghc-typelits-presburger, hashable, inspection-testing, lens @@ -268961,7 +267640,6 @@ self: { ]; description = "Sized sequence data-types"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "sized-grid" = callPackage @@ -269371,8 +268049,8 @@ self: { }: mkDerivation { pname = "skylighting"; - version = "0.13.2.1"; - sha256 = "0lq68cavdp73praa2h8cclgnrh53fqg9x4r6q3fsvnr8lbcb4x7h"; + version = "0.13.4"; + sha256 = "09v4da57ijzcaxhibrshw8fdxd0wq8adw44w9wh1rpn2l698gv4m"; configureFlags = [ "-fexecutable" ]; isLibrary = true; isExecutable = true; @@ -269389,6 +268067,33 @@ self: { mainProgram = "skylighting"; }) {}; + "skylighting_0_13_4_1" = callPackage + ({ mkDerivation, base, binary, blaze-html, bytestring, containers + , pretty-show, skylighting-core, skylighting-format-ansi + , skylighting-format-blaze-html, skylighting-format-context + , skylighting-format-latex, text + }: + mkDerivation { + pname = "skylighting"; + version = "0.13.4.1"; + sha256 = "091cjjv8y0y5pfz5fphyzs94nzslbz8j5i07ma6pfqd1bjrh9xzi"; + configureFlags = [ "-fexecutable" ]; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base binary containers skylighting-core skylighting-format-ansi + skylighting-format-blaze-html skylighting-format-context + skylighting-format-latex + ]; + executableHaskellDepends = [ + base blaze-html bytestring containers pretty-show text + ]; + description = "syntax highlighting library"; + license = lib.licenses.gpl2Only; + hydraPlatforms = lib.platforms.none; + mainProgram = "skylighting"; + }) {}; + "skylighting-core" = callPackage ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary , bytestring, case-insensitive, colour, containers, criterion, Diff @@ -269398,8 +268103,8 @@ self: { }: mkDerivation { pname = "skylighting-core"; - version = "0.13.2.1"; - sha256 = "1ib59w12f7mlh10nwj7404jv8x7z2r58g8a9ndr6ag8pxnf81054"; + version = "0.13.4"; + sha256 = "0n9v62fq7iwlz44hfz7zbsqplqkls8x7cb3fmm5xfw020adqjyyf"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -269419,6 +268124,37 @@ self: { license = lib.licenses.bsd3; }) {}; + "skylighting-core_0_13_4_1" = callPackage + ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary + , bytestring, case-insensitive, colour, containers, criterion, Diff + , directory, filepath, mtl, pretty-show, QuickCheck, safe, tasty + , tasty-golden, tasty-hunit, tasty-quickcheck, text, transformers + , utf8-string, xml-conduit + }: + mkDerivation { + pname = "skylighting-core"; + version = "0.13.4.1"; + sha256 = "1hz2r8qpkjf9m5fgpw39vqp3rq1cbkamxss65i40bqihbjzysm65"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson attoparsec base base64-bytestring binary bytestring + case-insensitive colour containers directory filepath mtl safe text + transformers utf8-string xml-conduit + ]; + testHaskellDepends = [ + aeson base bytestring containers Diff directory filepath + pretty-show QuickCheck tasty tasty-golden tasty-hunit + tasty-quickcheck text + ]; + benchmarkHaskellDepends = [ + base containers criterion filepath text + ]; + description = "syntax highlighting library"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "skylighting-extensions" = callPackage ({ mkDerivation, base, containers, skylighting, skylighting-modding , text @@ -270058,8 +268794,8 @@ self: { }: mkDerivation { pname = "slynx"; - version = "0.7.2.1"; - sha256 = "1jff263if0f3013qlh06dvmisnqvmlq2ld4rqb159x6vz59iablk"; + version = "0.7.2.2"; + sha256 = "1mg25s3vf6lkia0z1v9jxjkfjh8by68q18y9m3v50lg4xpc97f4y"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -270359,6 +269095,7 @@ self: { ]; description = "Haskell Behavior Tree Library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "smartword" = callPackage @@ -270456,6 +269193,8 @@ self: { ]; description = "Linear time row minima for totally monotone matrices"; license = "(BSD-2-Clause OR Apache-2.0)"; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smcdel" = callPackage @@ -270552,6 +269291,8 @@ self: { libraryHaskellDepends = [ base bytesmith primitive ]; description = "Parse arrays of tokens"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "smith-cli" = callPackage @@ -271026,29 +269767,27 @@ self: { "snap" = callPackage ({ mkDerivation, aeson, async, attoparsec, base, bytestring, cereal , clientsession, configurator, containers, deepseq, directory - , directory-tree, dlist, fail, filepath, hashable, heist - , http-streams, HUnit, lens, lifted-base, map-syntax, monad-control - , mtl, mwc-random, pwstore-fast, QuickCheck, smallcheck, snap-core + , directory-tree, dlist, filepath, hashable, heist, http-streams + , HUnit, lens, lifted-base, map-syntax, monad-control, mtl + , mwc-random, pwstore-fast, QuickCheck, smallcheck, snap-core , snap-server, stm, syb, test-framework, test-framework-hunit , test-framework-quickcheck2, test-framework-smallcheck, text, time , transformers, transformers-base, unordered-containers, xmlhtml }: mkDerivation { pname = "snap"; - version = "1.1.3.1"; - sha256 = "1zq7yz5w9ms8zm5z4c05awkdarqbmb7pp13y9c1x04qfd5ba4c47"; - revision = "2"; - editedCabalFile = "16rkb05mrvi7binynawkshsvikdvxqrv8bxxjcgs4k30arx39cz5"; + version = "1.1.3.2"; + sha256 = "11l7jhch504sbiqdqqjx89cav3qxhkgygvlacfvvl22sya1a4kaf"; libraryHaskellDepends = [ aeson attoparsec base bytestring cereal clientsession configurator - containers directory directory-tree dlist fail filepath hashable - heist lens lifted-base map-syntax monad-control mtl mwc-random + containers directory directory-tree dlist filepath hashable heist + lens lifted-base map-syntax monad-control mtl mwc-random pwstore-fast snap-core snap-server stm text time transformers transformers-base unordered-containers xmlhtml ]; testHaskellDepends = [ aeson async attoparsec base bytestring cereal clientsession - configurator containers deepseq directory directory-tree dlist fail + configurator containers deepseq directory directory-tree dlist filepath hashable heist http-streams HUnit lens lifted-base map-syntax monad-control mtl mwc-random pwstore-fast QuickCheck smallcheck snap-core snap-server stm syb test-framework @@ -271165,8 +269904,8 @@ self: { pname = "snap-core"; version = "1.0.5.1"; sha256 = "00h5xijkjvnhcgxpw3vmkpf5nwfpknqflvxgig6gvsy4wahc2157"; - revision = "1"; - editedCabalFile = "1hmkk9gxvrrs6ddf7l8i6ajdgdw4zgd103al67ggrh7whjyg2i0d"; + revision = "2"; + editedCabalFile = "0gpnjqvcgpbvv72m94q1qghs7dzrc10s0qdr71yar0zmv2j06pnj"; libraryHaskellDepends = [ attoparsec base bytestring bytestring-builder case-insensitive containers directory filepath hashable HUnit io-streams lifted-base @@ -271372,8 +270111,8 @@ self: { pname = "snap-server"; version = "1.1.2.1"; sha256 = "0znadz0av6k31s8d175904d2kajxayl38sva3dqh5ckdfkymfx54"; - revision = "1"; - editedCabalFile = "09ljp1m8lv2khp6m76sj96qa3gr5v19c5caz54jlvinj7k6bhhfm"; + revision = "2"; + editedCabalFile = "06nw6s7cmx0ap0v9qnjcrrnlrrm2px7msdc8rgv3l349rip34whl"; configureFlags = [ "-fopenssl" ]; isLibrary = true; isExecutable = true; @@ -272012,6 +270751,8 @@ self: { ]; description = "Automatic (re)compilation of purescript projects"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "snaplet-recaptcha" = callPackage @@ -272676,6 +271417,7 @@ self: { libraryHaskellDepends = [ base numeric-kinds type-compare ]; description = "Integer singletons with flexible representation"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "soap" = callPackage @@ -272931,10 +271673,8 @@ self: { }: mkDerivation { pname = "sockets"; - version = "0.6.1.0"; - sha256 = "0isnl0vzdm95fgpjpib6ivgwma8acyqc41020lqa3bdzx82whcsy"; - revision = "2"; - editedCabalFile = "12hk8gwffcrp8idx9zlc4c14k8x1d8r1c897m81fnmw6zc9ayl5c"; + version = "0.6.1.1"; + sha256 = "11d8naqwvsswqs27msir2qsbpgphyvxnq2fdmqc7vnydkgch91jk"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -273616,6 +272356,8 @@ self: { pname = "soxlib"; version = "0.0.3.2"; sha256 = "12pkalrwqcgz77wv948mkjldc57pj090rkrjw6k3xzqvsgvnrrpd"; + revision = "1"; + editedCabalFile = "0ah3v01wkm3q5shrd2wjlksxlszirmzgnapzfgbs5m3x9r1zmibh"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -274014,6 +272756,8 @@ self: { ]; description = "Numerical computing in native Haskell"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sparse-merkle-trees" = callPackage @@ -274038,6 +272782,8 @@ self: { ]; description = "Sparse Merkle trees with proofs of inclusion and exclusion"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sparse-tensor" = callPackage @@ -274224,6 +272970,8 @@ self: { ]; description = "SPDX license expression language, Extras"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "spdx-license" = callPackage @@ -274780,6 +273528,7 @@ self: { ]; description = "A parallel implementation of the Sorokina/Zeilfelder spline scheme"; license = lib.licenses.agpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "spline3"; }) {}; @@ -275034,6 +273783,44 @@ self: { license = lib.licenses.bsd3; }) {}; + "spotify" = callPackage + ({ mkDerivation, aeson, base, base64-bytestring, bytestring, Cabal + , composition, containers, directory, exceptions, extra, filepath + , http-api-data, http-client, http-client-tls, http-types, lucid + , monad-loops, mtl, pretty-simple, servant, servant-client + , servant-lucid, text, time, transformers, unordered-containers + }: + mkDerivation { + pname = "spotify"; + version = "0.1.0.1"; + sha256 = "0b1cpwcdkspzh43ybjizbi91wixc8wq82h01k18kl13jdipr79cc"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base base64-bytestring bytestring composition containers + directory exceptions extra filepath http-api-data http-client + http-client-tls http-types lucid monad-loops mtl pretty-simple + servant servant-client servant-lucid text time transformers + unordered-containers + ]; + executableHaskellDepends = [ + aeson base bytestring composition containers directory exceptions + extra filepath monad-loops mtl pretty-simple servant text time + transformers unordered-containers + ]; + testHaskellDepends = [ + aeson base bytestring Cabal composition containers directory + exceptions extra filepath monad-loops mtl pretty-simple servant + text time transformers unordered-containers + ]; + doHaddock = false; + description = "Spotify Web API"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + mainProgram = "examples"; + broken = true; + }) {}; + "spoty" = callPackage ({ mkDerivation, aeson, base, bytestring, lens, lens-aeson, pipes , text, unordered-containers, wreq @@ -275286,6 +274073,22 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "sqids" = callPackage + ({ mkDerivation, base, containers, hspec, mtl, split, text + , transformers + }: + mkDerivation { + pname = "sqids"; + version = "0.1.2.1"; + sha256 = "06m1vsmfgzn80r9gc8pgnzj4496lyyhk78gka63jzqzqi61cs7rh"; + libraryHaskellDepends = [ base containers mtl text transformers ]; + testHaskellDepends = [ base containers hspec mtl split text ]; + description = "A small library that lets you generate YouTube-looking IDs from numbers"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "sql-simple" = callPackage ({ mkDerivation, base, containers, exceptions, monad-control, text , transformers, transformers-base @@ -275567,14 +274370,15 @@ self: { "squares" = callPackage ({ mkDerivation, adjunctions, base, bifunctors, comonad - , distributive, profunctors + , distributive, kan-extensions, profunctors }: mkDerivation { pname = "squares"; - version = "0.1.1"; - sha256 = "1lql2qzyiffs09y3iw1wi190agjg49nic95n57jhzcixavk91fgn"; + version = "0.2.1"; + sha256 = "06bz93zfid5ya8zjcnf6qvdmjdw4d84yjmmw7y223i0083gpha7v"; libraryHaskellDepends = [ - adjunctions base bifunctors comonad distributive profunctors + adjunctions base bifunctors comonad distributive kan-extensions + profunctors ]; description = "The double category of Hask functors and profunctors"; license = lib.licenses.bsd3; @@ -275791,6 +274595,8 @@ self: { ]; description = "Attoparsec parser for the SRT format"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "srt-dhall" = callPackage @@ -275829,6 +274635,7 @@ self: { ]; description = "Format an SRT"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "srtree" = callPackage @@ -275837,8 +274644,8 @@ self: { }: mkDerivation { pname = "srtree"; - version = "1.0.0.4"; - sha256 = "0i1fflmqvm9hl1cxm4hddjfz1dyxd5nq2pmwmj467wbyjmmrpksv"; + version = "1.0.0.5"; + sha256 = "1gylgq29clddj8vdk0dd95prsvm64gsjf5hidc25dz64rjxmd2xi"; libraryHaskellDepends = [ base containers dlist mtl random vector ]; @@ -276109,6 +274916,8 @@ self: { libraryHaskellDepends = [ base gdp primitive ]; description = "shared heap regions between local mutable state threads"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stable-heap" = callPackage @@ -276205,10 +275014,8 @@ self: { }: mkDerivation { pname = "stache"; - version = "2.3.3"; - sha256 = "1naqj54qm59f04x310lvj4fsrp3xar1v643i79gp7h48kyn1c2vy"; - revision = "3"; - editedCabalFile = "0flizmaig3crrwfl88wxchw0g67r299hal70p2qrxnl36c84yd63"; + version = "2.3.4"; + sha256 = "0kgiyxws2kir8q8zrqkzmk103y7hl6nksxl70f6fy8m9fqkjga51"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -276233,104 +275040,6 @@ self: { }) {}; "stack" = callPackage - ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array - , async, attoparsec, base, base64-bytestring, bytestring, Cabal - , casa-client, casa-types, colour, conduit, conduit-extra - , containers, cryptonite, cryptonite-conduit, deepseq, directory - , echo, exceptions, extra, file-embed, filelock, filepath, fsnotify - , generic-deriving, hackage-security, hashable, hi-file-parser - , hpack, hpc, hspec, hspec-discover, http-client, http-client-tls - , http-conduit, http-download, http-types, memory, microlens - , mintty, mono-traversable, mtl, mustache, neat-interpolation - , network-uri, open-browser, optparse-applicative, pantry, path - , path-io, persistent, persistent-sqlite, persistent-template - , pretty, primitive, process, project-template, QuickCheck, random - , raw-strings-qq, retry, rio, rio-prettyprint, semigroups - , smallcheck, split, stm, streaming-commons, tar, template-haskell - , temporary, text, text-metrics, th-reify-many, time, tls - , transformers, typed-process, unicode-transforms, unix - , unix-compat, unliftio, unordered-containers, vector, yaml - , zip-archive, zlib - }: - mkDerivation { - pname = "stack"; - version = "2.9.1"; - sha256 = "01020dx89m07qmjs58vs2kidhkzq3106md08w6c65bzxvlf6kcwk"; - revision = "5"; - editedCabalFile = "01j3rp2bzgf7861wkm01zgk77bjb5466mw5mqydvphdxm4m4wgmd"; - configureFlags = [ - "-fdisable-git-info" "-fhide-dependency-versions" - "-fsupported-build" - ]; - isLibrary = true; - isExecutable = true; - setupHaskellDepends = [ base Cabal filepath ]; - libraryHaskellDepends = [ - aeson annotated-wl-pprint ansi-terminal array async attoparsec base - base64-bytestring bytestring Cabal casa-client casa-types colour - conduit conduit-extra containers cryptonite cryptonite-conduit - deepseq directory echo exceptions extra file-embed filelock - filepath fsnotify generic-deriving hackage-security hashable - hi-file-parser hpack hpc http-client http-client-tls http-conduit - http-download http-types memory microlens mintty mono-traversable - mtl mustache neat-interpolation network-uri open-browser - optparse-applicative pantry path path-io persistent - persistent-sqlite persistent-template pretty primitive process - project-template random retry rio rio-prettyprint semigroups split - stm streaming-commons tar template-haskell temporary text - text-metrics th-reify-many time tls transformers typed-process - unicode-transforms unix unix-compat unliftio unordered-containers - vector yaml zip-archive zlib - ]; - executableHaskellDepends = [ - aeson annotated-wl-pprint ansi-terminal array async attoparsec base - base64-bytestring bytestring Cabal casa-client casa-types colour - conduit conduit-extra containers cryptonite cryptonite-conduit - deepseq directory echo exceptions extra file-embed filelock - filepath fsnotify generic-deriving hackage-security hashable - hi-file-parser hpack hpc http-client http-client-tls http-conduit - http-download http-types memory microlens mintty mono-traversable - mtl mustache neat-interpolation network-uri open-browser - optparse-applicative pantry path path-io persistent - persistent-sqlite persistent-template pretty primitive process - project-template random retry rio rio-prettyprint semigroups split - stm streaming-commons tar template-haskell temporary text - text-metrics th-reify-many time tls transformers typed-process - unicode-transforms unix unix-compat unliftio unordered-containers - vector yaml zip-archive zlib - ]; - testHaskellDepends = [ - aeson annotated-wl-pprint ansi-terminal array async attoparsec base - base64-bytestring bytestring Cabal casa-client casa-types colour - conduit conduit-extra containers cryptonite cryptonite-conduit - deepseq directory echo exceptions extra file-embed filelock - filepath fsnotify generic-deriving hackage-security hashable - hi-file-parser hpack hpc hspec http-client http-client-tls - http-conduit http-download http-types memory microlens mintty - mono-traversable mtl mustache neat-interpolation network-uri - open-browser optparse-applicative pantry path path-io persistent - persistent-sqlite persistent-template pretty primitive process - project-template QuickCheck random raw-strings-qq retry rio - rio-prettyprint semigroups smallcheck split stm streaming-commons - tar template-haskell temporary text text-metrics th-reify-many time - tls transformers typed-process unicode-transforms unix unix-compat - unliftio unordered-containers vector yaml zip-archive zlib - ]; - testToolDepends = [ hspec-discover ]; - doCheck = false; - preCheck = "export HOME=$TMPDIR"; - postInstall = '' - exe=$out/bin/stack - mkdir -p $out/share/bash-completion/completions - $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack - ''; - description = "The Haskell Tool Stack"; - license = lib.licenses.bsd3; - mainProgram = "stack"; - maintainers = [ lib.maintainers.cdepillabout ]; - }) {}; - - "stack_2_11_1" = callPackage ({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, array , async, attoparsec, base, base64-bytestring, bytestring, Cabal , casa-client, casa-types, colour, conduit, conduit-extra @@ -276421,7 +275130,6 @@ self: { ''; description = "The Haskell Tool Stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "stack"; maintainers = [ lib.maintainers.cdepillabout ]; }) {}; @@ -277462,6 +276170,8 @@ self: { libraryHaskellDepends = [ base fsnotify ]; description = "Develop applications without restarts"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stash" = callPackage @@ -277553,24 +276263,6 @@ self: { }) {}; "stateWriter" = callPackage - ({ mkDerivation, base, containers, criterion, deepseq, dlist, free - , hspec, lens, mtl, QuickCheck, transformers, vector - }: - mkDerivation { - pname = "stateWriter"; - version = "0.3.0"; - sha256 = "0l8x758ywgz3c6fhyw1ajaqnq98l2ra39cj4yl2873z89q2cxdlp"; - libraryHaskellDepends = [ base mtl transformers ]; - testHaskellDepends = [ base free hspec mtl QuickCheck ]; - benchmarkHaskellDepends = [ - base containers criterion deepseq dlist lens mtl transformers - vector - ]; - description = "A faster variant of the RWS monad transformers"; - license = lib.licenses.bsd3; - }) {}; - - "stateWriter_0_4_0" = callPackage ({ mkDerivation, base, containers, criterion, deepseq, dlist, free , hspec, lens, mtl, QuickCheck, transformers, vector }: @@ -277586,7 +276278,6 @@ self: { ]; description = "A faster variant of the RWS monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "statechart" = callPackage @@ -277690,6 +276381,25 @@ self: { broken = true; }) {}; + "static-bytes" = callPackage + ({ mkDerivation, base, bytestring, hspec, hspec-discover, memory + , primitive, QuickCheck, rio, text, vector + }: + mkDerivation { + pname = "static-bytes"; + version = "0.1.0"; + sha256 = "00lai18b7wzyy08l6na0lnzpzlwsld7iqfcz2r0l6qbxmdmm3hsx"; + libraryHaskellDepends = [ + base bytestring memory primitive rio vector + ]; + testHaskellDepends = [ + base bytestring hspec memory primitive QuickCheck rio text vector + ]; + testToolDepends = [ hspec-discover ]; + description = "A Haskell library providing types representing 8, 16, 32, 64 or 128 bytes of data"; + license = lib.licenses.bsd3; + }) {}; + "static-canvas" = callPackage ({ mkDerivation, base, double-conversion, free, mtl, text }: mkDerivation { @@ -278227,6 +276937,7 @@ self: { ]; description = "Binding to Standard Template Library C++"; license = lib.licenses.bsd2; + hydraPlatforms = lib.platforms.none; }) {}; "stdf" = callPackage @@ -278327,6 +277038,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "A file watcher and development tool"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "sos"; }) {}; @@ -279016,6 +277728,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Storable offsets for record fields"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "storable-record" = callPackage @@ -279050,20 +277764,6 @@ self: { }) {}; "storable-tuple" = callPackage - ({ mkDerivation, base, base-orphans, storable-record, utility-ht }: - mkDerivation { - pname = "storable-tuple"; - version = "0.0.3.3"; - sha256 = "0dfzhxgkn1l6ls7zh6iifhyvhm8l47n40z0ar23c6ibsa94w1ynw"; - libraryHaskellDepends = [ - base base-orphans storable-record utility-ht - ]; - description = "Storable instance for pairs and triples"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.thielema ]; - }) {}; - - "storable-tuple_0_1" = callPackage ({ mkDerivation, base, base-orphans, storable-record, utility-ht }: mkDerivation { pname = "storable-tuple"; @@ -279074,7 +277774,6 @@ self: { ]; description = "Storable instance for pairs and triples"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.thielema ]; }) {}; @@ -279087,8 +277786,8 @@ self: { pname = "storablevector"; version = "0.2.13.1"; sha256 = "06fgxbnc5vwmiv7dxywj7ncjhmxv0wjs0bys5hza6mrwn3sw5r2w"; - revision = "2"; - editedCabalFile = "05p97fmm8jkhhyhm2gqm7knnri64sihqywr9r49s01c8fkgzm1qx"; + revision = "3"; + editedCabalFile = "0iwdlamw4fm49qfawx7xp9alvv94l6q1xqrqav9k1q6486m27q99"; libraryHaskellDepends = [ base deepseq non-negative QuickCheck semigroups syb transformers unsafe utility-ht @@ -279481,8 +278180,8 @@ self: { }: mkDerivation { pname = "streaming"; - version = "0.2.3.1"; - sha256 = "127azyczj0ab2wv7d4mb86zsbffkvjg9fpjwrqlrf2vmjgizlppw"; + version = "0.2.4.0"; + sha256 = "1q6x6bqkd4r6404hrprnqjvnn7ykwayfdhmkji7ifmx08jkzppfa"; libraryHaskellDepends = [ base containers ghc-prim mmorph mtl transformers transformers-base ]; @@ -279529,6 +278228,7 @@ self: { ]; description = "Streaming conversion from/to base64"; license = lib.licenses.publicDomain; + hydraPlatforms = lib.platforms.none; }) {}; "streaming-benchmarks" = callPackage @@ -279617,8 +278317,8 @@ self: { }: mkDerivation { pname = "streaming-bytestring"; - version = "0.2.4"; - sha256 = "0iz4h5a1fd9bj2rkpwh5vk37j71frwqlbl2igfyxn4g7irpxipxh"; + version = "0.3.1"; + sha256 = "0ph6s8a1r0k9zhffmj23plzjlpipy4sr662dd0ya5igb9fbp5i32"; libraryHaskellDepends = [ base bytestring deepseq exceptions ghc-prim mmorph mtl resourcet streaming transformers transformers-base @@ -279631,28 +278331,6 @@ self: { license = lib.licenses.bsd3; }) {}; - "streaming-bytestring_0_3_0" = callPackage - ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim - , mmorph, mtl, resourcet, smallcheck, streaming, tasty, tasty-hunit - , tasty-smallcheck, transformers, transformers-base - }: - mkDerivation { - pname = "streaming-bytestring"; - version = "0.3.0"; - sha256 = "0n0xa2mdbpz0h21z8xjmvkyj58kx8ln4naw5l7011qdp8lblbr2i"; - libraryHaskellDepends = [ - base bytestring deepseq exceptions ghc-prim mmorph mtl resourcet - streaming transformers transformers-base - ]; - testHaskellDepends = [ - base bytestring resourcet smallcheck streaming tasty tasty-hunit - tasty-smallcheck transformers - ]; - description = "Fast, effectful byte streams"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - "streaming-cassava" = callPackage ({ mkDerivation, base, bytestring, cassava, hspec, mtl, QuickCheck , quickcheck-instances, streaming, streaming-bytestring, text @@ -279878,8 +278556,8 @@ self: { }: mkDerivation { pname = "streaming-pcap"; - version = "1.1.1.1"; - sha256 = "1qzll7n2h9jgwhnx0gvrxzi19dkhqxy0fymbc414hwsn27f8sh8b"; + version = "1.1.2"; + sha256 = "1c4xd5bfqm5v9ahp2nyyv48wr3afc69ljvqlwskbl8cra06jg5r4"; libraryHaskellDepends = [ attoparsec base bytestring pcap resourcet streaming streaming-attoparsec streaming-bytestring @@ -280034,32 +278712,11 @@ self: { ]; description = "with/bracket-style idioms for use with streaming"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streamly" = callPackage - ({ mkDerivation, atomic-primops, base, containers, deepseq - , directory, exceptions, filepath, fusion-plugin-types, ghc-prim - , heaps, lockfree-queue, monad-control, mtl, network, primitive - , transformers, transformers-base, unicode-data - }: - mkDerivation { - pname = "streamly"; - version = "0.8.1.1"; - sha256 = "13m415pcyyzipm5nsf9l8lcan3dn2ck666rq014y46zd66l5ahb9"; - revision = "1"; - editedCabalFile = "0y9pq53jd2wf7xb5i51pa6vm728sza405dx37j8rqnqxxbm5sq7y"; - libraryHaskellDepends = [ - atomic-primops base containers deepseq directory exceptions - filepath fusion-plugin-types ghc-prim heaps lockfree-queue - monad-control mtl network primitive transformers transformers-base - unicode-data - ]; - description = "Dataflow programming and declarative concurrency"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "streamly_0_9_0" = callPackage ({ mkDerivation, atomic-primops, base, containers, deepseq , directory, exceptions, hashable, heaps, lockfree-queue , monad-control, mtl, network, streamly-core, template-haskell @@ -280078,7 +278735,6 @@ self: { ]; description = "Streaming, dataflow programming and declarative concurrency"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -280228,6 +278884,8 @@ self: { ]; description = "Folder watching as a Streamly stream"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streamly-lmdb" = callPackage @@ -280291,6 +278949,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Posix related streaming APIs"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "streamly-process" = callPackage @@ -280443,24 +279103,6 @@ self: { }) {}; "strict" = callPackage - ({ mkDerivation, assoc, base, binary, bytestring, deepseq, ghc-prim - , hashable, text, these, transformers - }: - mkDerivation { - pname = "strict"; - version = "0.4.0.1"; - sha256 = "0hb24a09c3agsq7sdv8r2b2jc2f4g1blg2xvj4cfadynib0apxnz"; - revision = "4"; - editedCabalFile = "0pdzqhy7z70m8gxcr54jf04qhncl1jbvwybigb8lrnxqirs5l86n"; - libraryHaskellDepends = [ - assoc base binary bytestring deepseq ghc-prim hashable text these - transformers - ]; - description = "Strict data types and String IO"; - license = lib.licenses.bsd3; - }) {}; - - "strict_0_5" = callPackage ({ mkDerivation, assoc, base, binary, bytestring, deepseq, ghc-prim , hashable, text, these, transformers }: @@ -280474,7 +279116,6 @@ self: { ]; description = "Strict data types and String IO"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "strict-base" = callPackage @@ -280491,23 +279132,6 @@ self: { }) {}; "strict-base-types" = callPackage - ({ mkDerivation, aeson, base, quickcheck-instances, strict - , strict-lens - }: - mkDerivation { - pname = "strict-base-types"; - version = "0.7"; - sha256 = "079pa6w3f5i5kv1v6mwhp2k0siyywnk3igm93y2kaz37f352x5jn"; - revision = "2"; - editedCabalFile = "1x0rgmbwwjb75p5bwcxa1ns5vbfdniik3p7wmivqkfz5d369z39m"; - libraryHaskellDepends = [ - aeson base quickcheck-instances strict strict-lens - ]; - description = "Strict variants of the types provided in base"; - license = lib.licenses.bsd3; - }) {}; - - "strict-base-types_0_8" = callPackage ({ mkDerivation, aeson, base, quickcheck-instances, strict , strict-lens }: @@ -280520,7 +279144,6 @@ self: { ]; description = "Strict variants of the types provided in base"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "strict-concurrency" = callPackage @@ -280663,19 +279286,6 @@ self: { }) {}; "strict-lens" = callPackage - ({ mkDerivation, base, lens, strict }: - mkDerivation { - pname = "strict-lens"; - version = "0.4.0.2"; - sha256 = "1dsgr53q0sdivrxc7jmbqjd65hav9zwjqc8zfbyybkr1ww17bhf5"; - revision = "2"; - editedCabalFile = "1sdqml2fizmm1wrlmg1l8b9hnff8la03wl39hr47bldvlqn6dywx"; - libraryHaskellDepends = [ base lens strict ]; - description = "Lenses for types in strict package"; - license = lib.licenses.bsd3; - }) {}; - - "strict-lens_0_4_0_3" = callPackage ({ mkDerivation, base, lens, strict }: mkDerivation { pname = "strict-lens"; @@ -280684,7 +279294,6 @@ self: { libraryHaskellDepends = [ base lens strict ]; description = "Lenses for types in strict package"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "strict-list" = callPackage @@ -280854,6 +279463,8 @@ self: { libraryHaskellDepends = [ base bytestring tagged text ]; description = "String class library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "string-combinators" = callPackage @@ -281030,8 +279641,8 @@ self: { ({ mkDerivation, base, HUnit, template-haskell, text }: mkDerivation { pname = "string-qq"; - version = "0.0.4"; - sha256 = "0wfxkw4x6j6jq9nd82k83g2k3hskpsvk1dp4cpkshvjr4wg9qny8"; + version = "0.0.5"; + sha256 = "0iss84b1cfi3zqj5wgcdakpbv9965r7ib65n7j9nb108fazkra59"; libraryHaskellDepends = [ base template-haskell ]; testHaskellDepends = [ base HUnit text ]; description = "QuasiQuoter for non-interpolated strings, texts and bytestrings"; @@ -281299,8 +279910,8 @@ self: { ({ mkDerivation, base, bytestring, text }: mkDerivation { pname = "stripe-concepts"; - version = "1.0.3.2"; - sha256 = "1gvfqqfaxzgdyq03p7c6kys5bc6frpm5wsm8zsg8rk50wh18gzmg"; + version = "1.0.3.3"; + sha256 = "0yxgj1za39a4ihy76fqrnj00x22fifclhchyshmybz549h06g5ih"; libraryHaskellDepends = [ base bytestring text ]; description = "Types for the Stripe API"; license = lib.licenses.mit; @@ -281410,8 +280021,8 @@ self: { }: mkDerivation { pname = "stripe-scotty"; - version = "1.1.0.3"; - sha256 = "10nfpn0rsknnbir4ghad7rygp2l0rsfkd74ipgz76b60k23x4kj9"; + version = "1.1.0.4"; + sha256 = "04s4rgfm2jgg8909x9bbma2q13gzjx718kamj1fa5jgqfsyc40df"; libraryHaskellDepends = [ aeson base bytestring http-types scotty stripe-concepts stripe-signature text @@ -281442,8 +280053,8 @@ self: { }: mkDerivation { pname = "stripe-signature"; - version = "1.0.0.15"; - sha256 = "0p2m6lrl6sh44919wggzb3xpc29ib6khpac70zrx8s4f0iwrpyq4"; + version = "1.0.0.16"; + sha256 = "06dngchja4r7cirrm1zxsrgg9lh8ik40qp2vbjhpy9qwg7sqv956"; libraryHaskellDepends = [ base base16-bytestring bytestring cryptohash-sha256 stripe-concepts text @@ -281480,8 +280091,8 @@ self: { }: mkDerivation { pname = "stripe-wreq"; - version = "1.0.1.15"; - sha256 = "0w9wa08i53k2557hd5cb0a8m65b6993j2dn9bd9g8p6j6j77cjcp"; + version = "1.0.1.16"; + sha256 = "0m0wh4fpp5nim2f9i6gxyw34kb5m9yl5c6j551kscbgq8pvzmjkm"; libraryHaskellDepends = [ aeson base bytestring lens stripe-concepts text wreq ]; @@ -281528,8 +280139,8 @@ self: { }: mkDerivation { pname = "strive"; - version = "6.0.0.7"; - sha256 = "051hgcx3h90g3zbai2yy62z42ilklwpyg09sj090q9impz2pw10h"; + version = "6.0.0.9"; + sha256 = "0zd3c303vyl61alw2bl217znm72ajpsy33qjz2pf52azsdk96qfc"; libraryHaskellDepends = [ aeson base bytestring data-default gpolyline http-client http-client-tls http-types template-haskell text time transformers @@ -281595,28 +280206,6 @@ self: { }) {}; "strongweak" = callPackage - ({ mkDerivation, base, either, generic-random, hspec - , hspec-discover, prettyprinter, QuickCheck, quickcheck-instances - , refined, vector, vector-sized - }: - mkDerivation { - pname = "strongweak"; - version = "0.3.2"; - sha256 = "1xmqacfv4xqx1v7xdiflmc4am9366jhpdv1r7hldmh1ihw7jkfc3"; - libraryHaskellDepends = [ - base either prettyprinter refined vector vector-sized - ]; - testHaskellDepends = [ - base either generic-random hspec prettyprinter QuickCheck - quickcheck-instances refined vector vector-sized - ]; - testToolDepends = [ hspec-discover ]; - description = "Convert between strong and weak representations of types"; - license = lib.licenses.mit; - maintainers = [ lib.maintainers.raehik ]; - }) {}; - - "strongweak_0_6_0" = callPackage ({ mkDerivation, acc, base, either, generic-random, hspec , hspec-discover, prettyprinter, QuickCheck, quickcheck-instances , refined1, text, vector, vector-sized @@ -281635,7 +280224,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "Convert between strong and weak representations of types"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.raehik ]; }) {}; @@ -281736,8 +280324,8 @@ self: { pname = "structured"; version = "0.1.1"; sha256 = "1mz02ys85z79nj24ylsmgh8v2m7zv2rixf7w0iqnwc49lax52w4q"; - revision = "6"; - editedCabalFile = "0kbc1p5qv5n2fhammf0f879ndsgp083387bar1hmnc2xia6lzx8c"; + revision = "7"; + editedCabalFile = "1fqc041qxnsj95pd9mfzdz5jn1ibmlml8zx8biqdivmv25xn59am"; libraryHaskellDepends = [ aeson array base base16-bytestring binary bytestring containers hashable scientific tagged text time-compat transformers @@ -281964,39 +280552,7 @@ self: { broken = true; }) {}; - "stylish-haskell_0_13_0_0" = callPackage - ({ mkDerivation, aeson, base, bytestring, Cabal, containers - , directory, file-embed, filepath, ghc-lib-parser, HsYAML - , HsYAML-aeson, HUnit, mtl, optparse-applicative, random, strict - , syb, test-framework, test-framework-hunit, text - }: - mkDerivation { - pname = "stylish-haskell"; - version = "0.13.0.0"; - sha256 = "0x9w3zh1lzp6l5xj3mynnlr0fzb5mbv0wwpfxp8fr6bk0jcrzjwf"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base bytestring Cabal containers directory file-embed - filepath ghc-lib-parser HsYAML HsYAML-aeson mtl syb text - ]; - executableHaskellDepends = [ - aeson base bytestring Cabal containers directory file-embed - filepath ghc-lib-parser HsYAML HsYAML-aeson mtl - optparse-applicative strict syb - ]; - testHaskellDepends = [ - aeson base bytestring Cabal containers directory file-embed - filepath ghc-lib-parser HsYAML HsYAML-aeson HUnit mtl random syb - test-framework test-framework-hunit text - ]; - description = "Haskell code prettifier"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - mainProgram = "stylish-haskell"; - }) {}; - - "stylish-haskell" = callPackage + "stylish-haskell_0_14_3_0" = callPackage ({ mkDerivation, aeson, base, bytestring, Cabal, containers , directory, file-embed, filepath, ghc, ghc-boot, ghc-boot-th , ghc-lib-parser-ex, HsYAML, HsYAML-aeson, HUnit, mtl @@ -282027,12 +280583,13 @@ self: { ]; description = "Haskell code prettifier"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "stylish-haskell"; }) {}; - "stylish-haskell_0_14_4_0" = callPackage + "stylish-haskell" = callPackage ({ mkDerivation, aeson, base, bytestring, Cabal, containers - , directory, file-embed, filepath, ghc-lib-parser + , directory, file-embed, filepath, ghc, ghc-boot, ghc-boot-th , ghc-lib-parser-ex, HsYAML, HsYAML-aeson, HUnit, mtl , optparse-applicative, random, regex-tdfa, strict, syb , test-framework, test-framework-hunit, text @@ -282043,6 +280600,40 @@ self: { sha256 = "0y0vfz5vkvw0wzcsw2ym3nix0v3pwjw2vas0qv3lrhdvn3ba9gb7"; isLibrary = true; isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring Cabal containers directory file-embed + filepath ghc ghc-boot ghc-boot-th ghc-lib-parser-ex HsYAML + HsYAML-aeson mtl regex-tdfa syb text + ]; + executableHaskellDepends = [ + aeson base bytestring Cabal containers directory file-embed + filepath ghc ghc-boot ghc-boot-th ghc-lib-parser-ex HsYAML + HsYAML-aeson mtl optparse-applicative regex-tdfa strict syb text + ]; + testHaskellDepends = [ + aeson base bytestring Cabal containers directory file-embed + filepath ghc ghc-boot ghc-boot-th ghc-lib-parser-ex HsYAML + HsYAML-aeson HUnit mtl random regex-tdfa syb test-framework + test-framework-hunit text + ]; + description = "Haskell code prettifier"; + license = lib.licenses.bsd3; + mainProgram = "stylish-haskell"; + }) {}; + + "stylish-haskell_0_14_5_0" = callPackage + ({ mkDerivation, aeson, base, bytestring, Cabal, containers + , directory, file-embed, filepath, ghc-lib-parser + , ghc-lib-parser-ex, HsYAML, HsYAML-aeson, HUnit, mtl + , optparse-applicative, random, regex-tdfa, strict, syb + , test-framework, test-framework-hunit, text + }: + mkDerivation { + pname = "stylish-haskell"; + version = "0.14.5.0"; + sha256 = "07f0cn7xy8yg1rm0yvkjx27xqv9xc3n1c5s4fqq3yrqyi5szdhbw"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ aeson base bytestring Cabal containers directory file-embed filepath ghc-lib-parser ghc-lib-parser-ex HsYAML HsYAML-aeson mtl @@ -282071,8 +280662,10 @@ self: { }: mkDerivation { pname = "stylist"; - version = "2.7.0.0"; - sha256 = "0a8d6cqn8k4q836lywp7j63s1sprfi059n35f13b4ym9834y5rxi"; + version = "2.7.0.1"; + sha256 = "1sp75f3rhp7f635w8ascc64z8ka67y2y6l6wws7fv5pq2rxagy6h"; + revision = "1"; + editedCabalFile = "1kd3p7mfbs7qsrisn889iqci0hfhq0kd2xip4hy2ar2yq1cpxyj2"; libraryHaskellDepends = [ async base css-syntax file-embed hashable network-uri regex-tdfa stylist-traits text unordered-containers @@ -282085,6 +280678,7 @@ self: { description = "Apply CSS styles to a document tree"; license = lib.licenses.gpl3Only; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "stylist-traits" = callPackage @@ -282093,10 +280687,11 @@ self: { pname = "stylist-traits"; version = "0.1.3.1"; sha256 = "0dw26liwvp490njpj1p8mjkanin1mmx68pd0br034ppaq3aacmnl"; + revision = "1"; + editedCabalFile = "0yh6jsv0irgkb094qjhdx32mzs4sn9k03kymdzx80z0yivhlkgjw"; libraryHaskellDepends = [ base css-syntax network-uri text ]; description = "Traits, datatypes, & parsers for Haskell Stylist"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "stylized" = callPackage @@ -283256,8 +281851,8 @@ self: { }: mkDerivation { pname = "sv2v"; - version = "0.0.10"; - sha256 = "00h7f8dmi17r4bcyzm25d6avvxdi8fqfxmvh7ssg9kqcbbix9xkd"; + version = "0.0.11"; + sha256 = "1417kf2z17da9q7zajdplxvqlfcgd4g9g17pg9bi0hl214wd2fcr"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -283337,8 +281932,8 @@ self: { ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }: mkDerivation { pname = "svg-icons"; - version = "3.0.0"; - sha256 = "1p29mwyy8hln0npmg14q0vyll6wyk3fakcskb2prgmy44k54wbxn"; + version = "3.8.1"; + sha256 = "0dpqbl01bgwpvs02q8981q37gjcrmrz4jzwn4icjdly39vnqngjm"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -283967,6 +282562,8 @@ self: { testHaskellDepends = [ base HUnit ]; description = "Scrap Your Boilerplate With Class"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "syb-with-class-instances-text" = callPackage @@ -283983,32 +282580,6 @@ self: { }) {}; "sydtest" = callPackage - ({ mkDerivation, async, autodocodec, autodocodec-yaml, base - , bytestring, containers, dlist, envparse, filepath, MonadRandom - , mtl, optparse-applicative, path, path-io, pretty-show, QuickCheck - , quickcheck-io, random, random-shuffle, safe, safe-coloured-text - , safe-coloured-text-terminfo, stm, sydtest-discover, text, vector - }: - mkDerivation { - pname = "sydtest"; - version = "0.13.0.4"; - sha256 = "0v799zkqm6w0kvbi6hs6cdygcbsachq6m21hiv6kdyca2kyrkgvp"; - libraryHaskellDepends = [ - async autodocodec autodocodec-yaml base bytestring containers dlist - envparse filepath MonadRandom mtl optparse-applicative path path-io - pretty-show QuickCheck quickcheck-io random random-shuffle safe - safe-coloured-text safe-coloured-text-terminfo stm text vector - ]; - testHaskellDepends = [ - base bytestring path path-io QuickCheck random safe-coloured-text - stm text vector - ]; - testToolDepends = [ sydtest-discover ]; - description = "A modern testing framework for Haskell with good defaults and advanced testing features"; - license = "unknown"; - }) {}; - - "sydtest_0_15_0_0" = callPackage ({ mkDerivation, async, autodocodec, autodocodec-yaml, base , bytestring, containers, dlist, envparse, filepath, MonadRandom , mtl, optparse-applicative, path, path-io, pretty-show, QuickCheck @@ -284034,7 +282605,6 @@ self: { testToolDepends = [ sydtest-discover ]; description = "A modern testing framework for Haskell with good defaults and advanced testing features"; license = "unknown"; - hydraPlatforms = lib.platforms.none; }) {}; "sydtest-aeson" = callPackage @@ -284114,21 +282684,6 @@ self: { }) {}; "sydtest-hedgehog" = callPackage - ({ mkDerivation, base, containers, hedgehog, stm, sydtest - , sydtest-discover - }: - mkDerivation { - pname = "sydtest-hedgehog"; - version = "0.3.0.1"; - sha256 = "12yqhz927x2nzca3xg824a0rc3icz8hs088rci530s30wc7qpvlj"; - libraryHaskellDepends = [ base containers hedgehog stm sydtest ]; - testHaskellDepends = [ base hedgehog sydtest ]; - testToolDepends = [ sydtest-discover ]; - description = "A Hedgehog companion library for sydtest"; - license = "unknown"; - }) {}; - - "sydtest-hedgehog_0_4_0_0" = callPackage ({ mkDerivation, base, containers, hedgehog, stm, sydtest , sydtest-discover }: @@ -284141,7 +282696,6 @@ self: { testToolDepends = [ sydtest-discover ]; description = "A Hedgehog companion library for sydtest"; license = "unknown"; - hydraPlatforms = lib.platforms.none; }) {}; "sydtest-hedis" = callPackage @@ -284166,23 +282720,6 @@ self: { }) {}; "sydtest-hspec" = callPackage - ({ mkDerivation, base, hspec, hspec-core, mtl, QuickCheck, stm - , sydtest, sydtest-discover - }: - mkDerivation { - pname = "sydtest-hspec"; - version = "0.3.0.2"; - sha256 = "02vq4s5r87phkvzrzf13gg1796b7f9w7sn0kmdd7sqqx7ap20ysp"; - libraryHaskellDepends = [ - base hspec-core mtl QuickCheck stm sydtest - ]; - testHaskellDepends = [ base hspec stm sydtest ]; - testToolDepends = [ sydtest-discover ]; - description = "An Hspec companion library for sydtest"; - license = "unknown"; - }) {}; - - "sydtest-hspec_0_4_0_0" = callPackage ({ mkDerivation, base, hspec, hspec-core, mtl, QuickCheck, stm , sydtest, sydtest-discover }: @@ -284198,6 +282735,7 @@ self: { description = "An Hspec companion library for sydtest"; license = "unknown"; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "sydtest-mongo" = callPackage @@ -284531,8 +283069,6 @@ self: { testHaskellDepends = [ base hashable QuickCheck ]; description = "Permutations, patterns, and statistics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "sym-plot" = callPackage @@ -284544,7 +283080,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; }) {}; "symantic" = callPackage @@ -285158,6 +283693,8 @@ 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 @@ -285391,8 +283928,8 @@ self: { pname = "synthesizer-core"; version = "0.8.3"; sha256 = "0a12qmr7fdlz5mbrki9nd1fl07670hll3wrdpp1apvf6zd36h7mn"; - revision = "2"; - editedCabalFile = "064a3xlqwl8v6q29djjcm0wx13wy1qw3p44v546amjbprk93kh1r"; + revision = "3"; + editedCabalFile = "0fgrj8a1cgnhcbdyhj478plaj68mrakk945cbpc9brxzcs835x0y"; libraryHaskellDepends = [ array base binary bytestring containers deepseq event-list explicit-exception filepath non-empty non-negative numeric-prelude @@ -285423,8 +283960,8 @@ self: { pname = "synthesizer-dimensional"; version = "0.8.1.1"; sha256 = "0giaa6v2yvb0amvdzdv5bq7dsns9pgbzv7sgjdi4a4zy0x4gmhc4"; - revision = "1"; - editedCabalFile = "15wb7v43ijbjqnnjdjf7c547wjbk4047in84q26b0vzi5nvrb3ij"; + revision = "2"; + editedCabalFile = "0gbwqhcqlpnhhz9pn5hk6aab8gnbgs37hzzil8q7pnyfgi3sdh84"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -285916,6 +284453,24 @@ self: { maintainers = [ lib.maintainers.sternenseemann ]; }) {}; + "systemd-api" = callPackage + ({ mkDerivation, base, byte-order, byteslice, posix-api, primitive + , systemd, text-short + }: + mkDerivation { + pname = "systemd-api"; + version = "0.1.0.0"; + sha256 = "1isnzmz32nd55hgrn18gsjz7g5d6cvj1yxgf2z2i1fhjwnkw144y"; + libraryHaskellDepends = [ + base byte-order byteslice posix-api primitive text-short + ]; + librarySystemDepends = [ systemd ]; + description = "systemd bindings"; + license = lib.licenses.bsd3; + platforms = lib.platforms.linux; + hydraPlatforms = lib.platforms.none; + }) {inherit (pkgs) systemd;}; + "systemd-socket-activation" = callPackage ({ mkDerivation, base, containers, network, quaalude, text , transformers, unix @@ -286123,8 +284678,8 @@ self: { }: mkDerivation { pname = "tableaux"; - version = "0.2"; - sha256 = "0dc1qdjlwxqjfb286knmbam6y9w9wlr6ah7l2ndq33yia4n2jp8b"; + version = "0.3"; + sha256 = "16kr0jlp3jnnv4a8dlfjyljc9xqlv351b87qf77yqa84j8229vlp"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -286338,6 +284893,8 @@ self: { pname = "tagchup"; version = "0.4.1.2"; sha256 = "0zlrdlb0f6dhhx163i62ljh1spr0d5gcf0c96m5z7nzq529qq792"; + revision = "1"; + editedCabalFile = "12rbb1y40z1yln62pdd8698zmgxhmvs1sib9lzakqmbgj3ckpclq"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -286356,21 +284913,6 @@ self: { }) {}; "tagged" = callPackage - ({ mkDerivation, base, deepseq, template-haskell, transformers }: - mkDerivation { - pname = "tagged"; - version = "0.8.6.1"; - sha256 = "00kcc6lmj7v3xm2r3wzw5jja27m4alcw1wi8yiismd0bbzwzrq7m"; - revision = "3"; - editedCabalFile = "19klgkhkca9qgq2ylc41z85x7piagjh8wranriy48dcfkgraw94a"; - libraryHaskellDepends = [ - base deepseq template-haskell transformers - ]; - description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments"; - license = lib.licenses.bsd3; - }) {}; - - "tagged_0_8_7" = callPackage ({ mkDerivation, base, deepseq, template-haskell, transformers }: mkDerivation { pname = "tagged"; @@ -286381,7 +284923,6 @@ self: { ]; description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "tagged-binary" = callPackage @@ -286416,10 +284957,10 @@ self: { ({ mkDerivation, base, mtl, transformers }: mkDerivation { pname = "tagged-identity"; - version = "0.1.3"; - sha256 = "1n5jafvcck6mq14fb1wrgclkrkxz4vd1x09y028awz66makn5v1c"; + version = "0.1.4"; + sha256 = "0mq4q4i16lzm1d0ckarwjk2a47y28lfrv0hc31y0xblb9q50xxwl"; libraryHaskellDepends = [ base mtl transformers ]; - description = "Trivial monad transformer that allows identical monad stacks have different types"; + description = "Trivial monad transformer that allows identical monad stacks to have different types"; license = lib.licenses.bsd3; }) {}; @@ -286766,6 +285307,8 @@ self: { ]; description = "Hierarchical Tags & Tag Trees"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tai" = callPackage @@ -286856,7 +285399,9 @@ self: { ]; description = "Tailwind wrapped in Haskell"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "tailwind-run"; + broken = true; }) {}; "tak" = callPackage @@ -287216,8 +285761,8 @@ self: { }: mkDerivation { pname = "tar-conduit"; - version = "0.3.2"; - sha256 = "0bgn3hyf20g1gfnzy8f41s7nj54kfcyjk2izw99svrw8f3dphi80"; + version = "0.3.2.1"; + sha256 = "0lxyfil7fgg1gvb02qhs2na9cy7nqg8fvclwy6pnz4anqa4wc28r"; libraryHaskellDepends = [ base bytestring conduit conduit-combinators directory filepath safe-exceptions text unix @@ -287494,36 +286039,6 @@ self: { }) {}; "tasty-autocollect" = callPackage - ({ mkDerivation, base, bytestring, containers, directory - , explainable-predicates, filepath, ghc, tasty - , tasty-expected-failure, tasty-golden, tasty-hunit - , tasty-quickcheck, template-haskell, temporary, text, transformers - , typed-process - }: - mkDerivation { - pname = "tasty-autocollect"; - version = "0.3.2.0"; - sha256 = "1f2z08zclnz8kvxs67a1r1qfdb2j8nfjnvsj4434sl59inl6s9vx"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring containers directory filepath ghc tasty - tasty-expected-failure template-haskell text transformers - ]; - executableHaskellDepends = [ base text ]; - testHaskellDepends = [ - base bytestring containers directory explainable-predicates - filepath tasty tasty-golden tasty-hunit tasty-quickcheck temporary - text typed-process - ]; - description = "Autocollection of tasty tests"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - mainProgram = "tasty-autocollect"; - broken = true; - }) {}; - - "tasty-autocollect_0_4_1" = callPackage ({ mkDerivation, base, bytestring, containers, directory , explainable-predicates, filepath, ghc, tasty , tasty-expected-failure, tasty-golden, tasty-hunit @@ -287645,33 +286160,6 @@ self: { }) {}; "tasty-discover" = callPackage - ({ mkDerivation, base, containers, directory, filepath, Glob - , hedgehog, tasty, tasty-hedgehog, tasty-hspec, tasty-hunit - , tasty-quickcheck, tasty-smallcheck - }: - mkDerivation { - pname = "tasty-discover"; - version = "4.2.2"; - sha256 = "1j95njl3ml7cfxnwv0i17ijca84fgyrjs2cfw4g5yh1m4x2zvg34"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base containers directory filepath Glob - ]; - executableHaskellDepends = [ - base containers directory filepath Glob - ]; - testHaskellDepends = [ - base containers directory filepath Glob hedgehog tasty - tasty-hedgehog tasty-hspec tasty-hunit tasty-quickcheck - tasty-smallcheck - ]; - description = "Test discovery for the tasty framework"; - license = lib.licenses.mit; - mainProgram = "tasty-discover"; - }) {}; - - "tasty-discover_5_0_0" = callPackage ({ mkDerivation, base, bytestring, containers, directory, filepath , Glob, hedgehog, hspec, hspec-core, tasty, tasty-golden , tasty-hedgehog, tasty-hspec, tasty-hunit, tasty-quickcheck @@ -287698,7 +286186,6 @@ self: { ]; description = "Test discovery for the tasty framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "tasty-discover"; }) {}; @@ -287816,22 +286303,6 @@ self: { }) {}; "tasty-hedgehog" = callPackage - ({ mkDerivation, base, hedgehog, tagged, tasty - , tasty-expected-failure - }: - mkDerivation { - pname = "tasty-hedgehog"; - version = "1.3.1.0"; - sha256 = "1iq452mvd9wc9pfmjsmm848jwp3cvsk1faf2mlr21vcs0yaxvq3m"; - libraryHaskellDepends = [ base hedgehog tagged tasty ]; - testHaskellDepends = [ - base hedgehog tasty tasty-expected-failure - ]; - description = "Integration for tasty and hedgehog"; - license = lib.licenses.bsd3; - }) {}; - - "tasty-hedgehog_1_4_0_1" = callPackage ({ mkDerivation, base, hedgehog, tagged, tasty , tasty-expected-failure }: @@ -287839,13 +286310,14 @@ self: { pname = "tasty-hedgehog"; version = "1.4.0.1"; sha256 = "1vnx5vqmm0hk1xqhbp392fc1r91jrav0v5j92wx8q1pm2lhpibf8"; + revision = "1"; + editedCabalFile = "1hcn40fzwmc7q77c38lvrwwa3nshxls9ijzj7v42408a2rsgb4i3"; libraryHaskellDepends = [ base hedgehog tagged tasty ]; testHaskellDepends = [ base hedgehog tasty tasty-expected-failure ]; description = "Integration for tasty and hedgehog"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "tasty-hedgehog-coverage" = callPackage @@ -287873,20 +286345,6 @@ self: { }) {}; "tasty-hslua" = callPackage - ({ mkDerivation, base, bytestring, hslua-core, tasty, tasty-hunit - }: - mkDerivation { - pname = "tasty-hslua"; - version = "1.0.2"; - sha256 = "0ibdxwaclghcgcyf9zx4b1dnp4b708ydwli4clmb0a0mp1lwdp98"; - libraryHaskellDepends = [ - base bytestring hslua-core tasty tasty-hunit - ]; - description = "Tasty helpers to test HsLua"; - license = lib.licenses.mit; - }) {}; - - "tasty-hslua_1_1_0" = callPackage ({ mkDerivation, base, bytestring, hslua-core, tasty, tasty-hunit }: mkDerivation { @@ -287898,7 +286356,6 @@ self: { ]; description = "Tasty helpers to test HsLua"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "tasty-hspec_1_1_6" = callPackage @@ -287926,8 +286383,10 @@ self: { }: mkDerivation { pname = "tasty-hspec"; - version = "1.2.0.2"; - sha256 = "0cfcpi25jmnmzfzsx364qsj68q6gyph5z112kl8ja222hnhhr2n2"; + version = "1.2.0.3"; + sha256 = "150dvscaa0sv5pjsd74mmnp9f0jmz09qs24swz73wwjzrzmnypcx"; + revision = "1"; + editedCabalFile = "01sc5gmij3280b63jpjcz0a2lq045dj5ay46yq9i896cyka6gs6r"; libraryHaskellDepends = [ base hspec hspec-core QuickCheck tasty tasty-quickcheck tasty-smallcheck @@ -288011,21 +286470,6 @@ self: { }) {}; "tasty-inspection-testing" = callPackage - ({ mkDerivation, base, ghc, inspection-testing, tasty - , template-haskell - }: - mkDerivation { - pname = "tasty-inspection-testing"; - version = "0.1.0.1"; - sha256 = "0p46w44f19w7lvdzyg3vq6qzix0rjp8p23ilxz82dviq38lgmifp"; - libraryHaskellDepends = [ - base ghc inspection-testing tasty template-haskell - ]; - description = "Inspection testing support for tasty"; - license = lib.licenses.mit; - }) {}; - - "tasty-inspection-testing_0_2" = callPackage ({ mkDerivation, base, ghc, inspection-testing, tasty , template-haskell }: @@ -288040,7 +286484,6 @@ self: { ]; description = "Inspection testing support for tasty"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "tasty-integrate" = callPackage @@ -288177,27 +286620,6 @@ self: { }) {}; "tasty-lua" = callPackage - ({ mkDerivation, base, bytestring, directory, file-embed, filepath - , hslua-core, hslua-marshalling, lua-arbitrary, QuickCheck, tasty - , tasty-hunit, text - }: - mkDerivation { - pname = "tasty-lua"; - version = "1.0.2"; - sha256 = "1vnyvgcjsvqhwwyqkbgqksr9ppj5whiihpwcqkg33sl7jj3ysdwv"; - libraryHaskellDepends = [ - base bytestring file-embed hslua-core hslua-marshalling - lua-arbitrary QuickCheck tasty text - ]; - testHaskellDepends = [ - base bytestring directory filepath hslua-core hslua-marshalling - lua-arbitrary QuickCheck tasty tasty-hunit - ]; - description = "Write tests in Lua, integrate into tasty"; - license = lib.licenses.mit; - }) {}; - - "tasty-lua_1_1_0" = callPackage ({ mkDerivation, base, bytestring, directory, file-embed, filepath , hslua-core, hslua-marshalling, lua-arbitrary, QuickCheck, tasty , tasty-hunit, text @@ -288216,7 +286638,6 @@ self: { ]; description = "Write tests in Lua, integrate into tasty"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "tasty-mgolden" = callPackage @@ -288278,20 +286699,6 @@ self: { }) {}; "tasty-program" = callPackage - ({ mkDerivation, base, deepseq, directory, filepath, process, tasty - }: - mkDerivation { - pname = "tasty-program"; - version = "1.0.5"; - sha256 = "1i19b1pps1hwqs7djx859ddcdmqfzgyzyi72db62jw03bynmbcjc"; - libraryHaskellDepends = [ - base deepseq directory filepath process tasty - ]; - description = "Use tasty framework to test whether a program executes correctly"; - license = lib.licenses.bsd3; - }) {}; - - "tasty-program_1_1_0" = callPackage ({ mkDerivation, base, deepseq, directory, filepath, process, tasty }: mkDerivation { @@ -288303,7 +286710,6 @@ self: { ]; description = "Use tasty framework to test whether a program executes correctly"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "tasty-quickcheck" = callPackage @@ -288421,8 +286827,8 @@ self: { }: mkDerivation { pname = "tasty-sugar"; - version = "2.2.0.0"; - sha256 = "1s33a7pg7zaih2slq3gy0pdk6vl3ahy4w4sb3d3k1wvfk4nvxkc7"; + version = "2.2.1.0"; + sha256 = "032b9l1v8brnh1pk813srmjxp3bx00lmr5mhig16rv899dh1wgqv"; libraryHaskellDepends = [ base containers directory filemanip filepath kvitable logict microlens mtl optparse-applicative parallel prettyprinter tasty @@ -288435,6 +286841,7 @@ self: { doHaddock = false; description = "Tests defined by Search Using Golden Answer References"; license = lib.licenses.isc; + hydraPlatforms = lib.platforms.none; }) {}; "tasty-tap" = callPackage @@ -288469,6 +286876,8 @@ self: { testHaskellDepends = [ base tasty tasty-hunit ]; description = "Producing JUnit-style XML test reports"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tasty-test-vector" = callPackage @@ -288789,29 +287198,6 @@ self: { }) {}; "tdigest" = callPackage - ({ mkDerivation, base, base-compat, binary, deepseq, reducers - , semigroupoids, semigroups, tasty, tasty-quickcheck, transformers - , vector, vector-algorithms - }: - mkDerivation { - pname = "tdigest"; - version = "0.2.1.1"; - sha256 = "1dvkf7cs8dcr13wza5iyq2qgvz75r33mzgfmhdihw62xzxsqb6d3"; - revision = "3"; - editedCabalFile = "0a39vwf37hkh06rn79blr3bw7ij05pgpxrkc9cldgdd5p4gvn1qn"; - libraryHaskellDepends = [ - base base-compat binary deepseq reducers semigroupoids transformers - vector vector-algorithms - ]; - testHaskellDepends = [ - base base-compat binary deepseq semigroups tasty tasty-quickcheck - vector vector-algorithms - ]; - description = "On-line accumulation of rank-based statistics"; - license = lib.licenses.bsd3; - }) {}; - - "tdigest_0_3" = callPackage ({ mkDerivation, base, base-compat, binary, deepseq , foldable1-classes-compat, reducers, semigroups, tasty , tasty-quickcheck, transformers, vector, vector-algorithms @@ -288830,7 +287216,6 @@ self: { ]; description = "On-line accumulation of rank-based statistics"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "tdigest-Chart" = callPackage @@ -289193,8 +287578,8 @@ self: { }: mkDerivation { pname = "telegram-bot-api"; - version = "6.7"; - sha256 = "0ghbnni5shwmdsc31pr58xqa0f85ii4zp0g0mmgwrhvhkav4ma0b"; + version = "6.7.1"; + sha256 = "1a1k54q1ivhdj9vdgil1lv17vx0pz2n89vlz6bj7pf4g0w50cz4s"; libraryHaskellDepends = [ aeson aeson-pretty base bytestring cron filepath hashable http-api-data http-client http-client-tls monad-control mtl @@ -289205,35 +287590,10 @@ self: { ]; description = "Easy to use library for building Telegram bots. Exports Telegram Bot API."; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "telegram-bot-simple" = callPackage - ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron - , filepath, hashable, http-api-data, http-client, http-client-tls - , monad-control, mtl, pretty-show, profunctors, servant - , servant-client, servant-multipart-api, servant-multipart-client - , servant-server, split, stm, template-haskell, text, time - , transformers, unordered-containers, warp, warp-tls - }: - mkDerivation { - pname = "telegram-bot-simple"; - version = "0.6.2"; - sha256 = "10w9lq0ns1ycn0agmpp5114yfjrd20vwq050jxnfyk603aaw49k1"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson aeson-pretty base bytestring cron filepath hashable - http-api-data http-client http-client-tls monad-control mtl - pretty-show profunctors servant servant-client - servant-multipart-api servant-multipart-client servant-server split - stm template-haskell text time transformers unordered-containers - warp warp-tls - ]; - description = "Easy to use library for building Telegram bots"; - license = lib.licenses.bsd3; - }) {}; - - "telegram-bot-simple_0_12" = callPackage ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron , filepath, hashable, http-api-data, http-client, http-client-tls , monad-control, mtl, pretty-show, profunctors, servant @@ -289454,6 +287814,8 @@ self: { libraryHaskellDepends = [ base mtl text ]; description = "Simple string substitution"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "template-default" = callPackage @@ -289507,6 +287869,8 @@ self: { ]; description = "Optics for template-haskell types"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "template-haskell-util" = callPackage @@ -289961,6 +288325,7 @@ self: { ]; description = "TensorFlow bindings"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) libtensorflow;}; "tensorflow-core-ops" = callPackage @@ -289981,6 +288346,7 @@ self: { ]; description = "Haskell wrappers for Core Tensorflow Ops"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "tensorflow-logging" = callPackage @@ -290009,6 +288375,7 @@ self: { ]; description = "TensorBoard related functionality"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "tensorflow-mnist" = callPackage @@ -290062,6 +288429,7 @@ self: { ]; description = "Code generation for TensorFlow operations"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "tensorflow-ops" = callPackage @@ -290091,6 +288459,7 @@ self: { ]; description = "Friendly layer around TensorFlow bindings"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {}; "tensorflow-proto" = callPackage @@ -290108,6 +288477,7 @@ self: { libraryToolDepends = [ protobuf ]; description = "TensorFlow protocol buffers"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) protobuf;}; "tensorflow-records" = callPackage @@ -290415,47 +288785,6 @@ self: { }) {}; "termonad" = callPackage - ({ mkDerivation, adjunctions, aeson, base, Cabal, cabal-doctest - , classy-prelude, colour, constraints, containers, data-default - , directory, distributive, doctest, dyre, file-embed, filepath - , focuslist, genvalidity-containers, genvalidity-hspec, gi-gdk - , gi-gio, gi-glib, gi-gtk, gi-pango, gi-vte, gtk3, haskell-gi-base - , hedgehog, inline-c, lens, mono-traversable, pcre2, pretty-simple - , QuickCheck, tasty, tasty-hedgehog, tasty-hspec, template-haskell - , text, transformers, unordered-containers, vte_291, xml-conduit - , xml-html-qq, yaml - }: - mkDerivation { - pname = "termonad"; - version = "4.4.0.0"; - sha256 = "0xyb0z0k16mpsr5nc7a4k7w04k6skfwja25f5w329w1djrkvqfyx"; - isLibrary = true; - isExecutable = true; - enableSeparateDataOutput = true; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - adjunctions aeson base classy-prelude colour constraints containers - data-default directory distributive dyre file-embed filepath - focuslist gi-gdk gi-gio gi-glib gi-gtk gi-pango gi-vte - haskell-gi-base inline-c lens mono-traversable pretty-simple - QuickCheck text transformers unordered-containers xml-conduit - xml-html-qq yaml - ]; - libraryPkgconfigDepends = [ gtk3 pcre2 vte_291 ]; - executableHaskellDepends = [ base ]; - testHaskellDepends = [ - base doctest genvalidity-containers genvalidity-hspec hedgehog lens - QuickCheck tasty tasty-hedgehog tasty-hspec template-haskell - ]; - description = "Terminal emulator configurable in Haskell"; - license = lib.licenses.bsd3; - badPlatforms = lib.platforms.darwin; - mainProgram = "termonad"; - maintainers = [ lib.maintainers.cdepillabout ]; - }) {inherit (pkgs) gtk3; inherit (pkgs) pcre2; - vte_291 = pkgs.vte;}; - - "termonad_4_5_0_0" = callPackage ({ mkDerivation, adjunctions, aeson, base, Cabal, cabal-doctest , classy-prelude, colour, constraints, containers, data-default , directory, distributive, doctest, dyre, file-embed, filepath @@ -290491,7 +288820,6 @@ self: { description = "Terminal emulator configurable in Haskell"; license = lib.licenses.bsd3; badPlatforms = lib.platforms.darwin; - hydraPlatforms = lib.platforms.none; mainProgram = "termonad"; maintainers = [ lib.maintainers.cdepillabout ]; }) {inherit (pkgs) gtk3; inherit (pkgs) pcre2; @@ -290657,8 +288985,8 @@ self: { pname = "test-framework"; version = "0.8.2.0"; sha256 = "1hhacrzam6b8f10hyldmjw8pb7frdxh04rfg3farxcxwbnhwgbpm"; - revision = "9"; - editedCabalFile = "13qmj87p4nddbqlsdk03j5v7mj4bcxamzmdc5pzf585j9gara8yn"; + revision = "10"; + editedCabalFile = "087hnvbnzyw3by6ag0gk8bmk27w52iqplml9lm6wx08mrw0d2myx"; libraryHaskellDepends = [ ansi-terminal ansi-wl-pprint base containers hostname old-locale random regex-posix time xml @@ -291327,7 +289655,9 @@ self: { ]; description = "Compile separate tex files with the same bibliography"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "tex-join-bib"; + broken = true; }) {}; "tex2txt" = callPackage @@ -291371,28 +289701,6 @@ self: { }) {}; "texmath" = callPackage - ({ mkDerivation, base, bytestring, containers, directory, filepath - , mtl, pandoc-types, parsec, pretty-show, split, syb, tagged, tasty - , tasty-golden, text, xml - }: - mkDerivation { - pname = "texmath"; - version = "0.12.5.5"; - sha256 = "0hm88495sql6dz10hkrhfdnzfpgaa8zcy00v3irkzibq886nbcva"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base containers mtl pandoc-types parsec split syb text xml - ]; - testHaskellDepends = [ - base bytestring directory filepath pretty-show tagged tasty - tasty-golden text xml - ]; - description = "Conversion between math formats"; - license = lib.licenses.gpl2Only; - }) {}; - - "texmath_0_12_8" = callPackage ({ mkDerivation, base, bytestring, containers, directory, filepath , mtl, pandoc-types, parsec, pretty-show, split, syb, tagged, tasty , tasty-golden, text, typst-symbols, xml @@ -291413,7 +289721,6 @@ self: { ]; description = "Conversion between math formats"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; }) {}; "texrunner" = callPackage @@ -291423,10 +289730,8 @@ self: { }: mkDerivation { pname = "texrunner"; - version = "0.0.1.2"; - sha256 = "1fxyxwgvn0rxhkl1fs2msr88jqwx5wwfnjsjlcankrwcn7gyk7jy"; - revision = "5"; - editedCabalFile = "19qmc88i2nf9wsx6bhr0zvz0q5nqr6harx3smy58v0qcslb6chm4"; + version = "0.0.1.3"; + sha256 = "0lck7b6gw217jabgz2sa3r32i7yxm35hx32jn0s86dbckc2xqili"; libraryHaskellDepends = [ attoparsec base bytestring directory filepath io-streams mtl process semigroups temporary @@ -291440,16 +289745,20 @@ self: { "text_2_0_2" = callPackage ({ mkDerivation, array, base, binary, bytestring, containers - , deepseq, directory, filepath, ghc-prim, QuickCheck, tasty - , tasty-bench, tasty-hunit, tasty-inspection-testing - , tasty-quickcheck, template-haskell, transformers + , deepseq, directory, filepath, ghc-prim, QuickCheck + , system-cxx-std-lib, tasty, tasty-bench, tasty-hunit + , tasty-inspection-testing, tasty-quickcheck, template-haskell + , transformers }: mkDerivation { pname = "text"; version = "2.0.2"; sha256 = "1bggb4gq15r7z685w7c7hbm3w4n6day451ickz70d1l919jvwdf7"; + revision = "1"; + editedCabalFile = "1k25ba7hxgsj155yjmi218lhhyw640r4d4zr105gvhfkcj6gmdbi"; libraryHaskellDepends = [ - array base binary bytestring deepseq ghc-prim template-haskell + array base binary bytestring deepseq ghc-prim system-cxx-std-lib + template-haskell ]; testHaskellDepends = [ base bytestring deepseq directory ghc-prim QuickCheck tasty @@ -291613,6 +289922,8 @@ self: { ]; description = "A text compression library"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-containers" = callPackage @@ -291772,9 +290083,8 @@ self: { "text-icu" = callPackage ({ mkDerivation, array, base, bytestring, deepseq, directory - , ghc-prim, HUnit, icu, icu-i18n, QuickCheck, random - , test-framework, test-framework-hunit, test-framework-quickcheck2 - , text, time + , ghc-prim, HUnit, icu, QuickCheck, random, test-framework + , test-framework-hunit, test-framework-quickcheck2, text, time }: mkDerivation { pname = "text-icu"; @@ -291782,7 +290092,7 @@ self: { sha256 = "0frxrsj580ipgb3pdvw1msdz8d63j02vvrqhzjja3ixlq24am69d"; libraryHaskellDepends = [ base bytestring deepseq text time ]; librarySystemDepends = [ icu ]; - libraryPkgconfigDepends = [ icu-i18n ]; + libraryPkgconfigDepends = [ icu ]; testHaskellDepends = [ array base bytestring deepseq directory ghc-prim HUnit QuickCheck random test-framework test-framework-hunit @@ -291790,7 +290100,7 @@ self: { ]; description = "Bindings to the ICU library"; license = lib.licenses.bsd3; - }) {inherit (pkgs) icu; icu-i18n = null;}; + }) {inherit (pkgs) icu;}; "text-icu-normalized" = callPackage ({ mkDerivation, base, base-unicode-symbols, bytestring, containers @@ -291837,6 +290147,30 @@ self: { broken = true; }) {inherit (pkgs) icu;}; + "text-iso8601" = callPackage + ({ mkDerivation, attoparsec, attoparsec-iso8601, base + , integer-conversion, QuickCheck, quickcheck-instances, tasty + , tasty-bench, tasty-hunit, tasty-quickcheck, text, time + , time-compat + }: + mkDerivation { + pname = "text-iso8601"; + version = "0.1"; + sha256 = "1kszvadfl2ihmyd1chd6am6qkdvd9zwa5q1954yz3waiz537m3pm"; + libraryHaskellDepends = [ + base integer-conversion text time time-compat + ]; + testHaskellDepends = [ + base QuickCheck quickcheck-instances tasty tasty-hunit + tasty-quickcheck text time-compat + ]; + benchmarkHaskellDepends = [ + attoparsec attoparsec-iso8601 base tasty-bench text time-compat + ]; + description = "Converting time to and from ISO 8601 text"; + license = lib.licenses.bsd3; + }) {}; + "text-json-qq" = callPackage ({ mkDerivation, base, haskell-src-meta, json, json-qq, parsec , template-haskell @@ -292226,6 +290560,8 @@ self: { pname = "text-show"; version = "3.10.3"; sha256 = "0f59cr1bqy2kbhdxxz1a86lf6masyy67f1i8kj1815df6rpgnshy"; + revision = "1"; + editedCabalFile = "0ix7wgh7xcgxfdvfrphilb81zfpkb1swla2has2py24nxyn2dd46"; libraryHaskellDepends = [ array base base-compat-batteries bifunctors bytestring bytestring-builder containers generic-deriving ghc-boot-th ghc-prim @@ -292257,6 +290593,8 @@ self: { pname = "text-show-instances"; version = "3.9.5"; sha256 = "0i91yil7qlk0vv242prs178lvddzlzhh9d78lnmvyvalqrw7bib8"; + revision = "1"; + editedCabalFile = "06464d8ffxj5ag8ml6nriywwb05jk5z3kim13d0q3bz0m7s3hgz0"; libraryHaskellDepends = [ aeson base base-compat bifunctors binary containers directory ghc-boot-th haskeline hpc old-locale old-time pretty random @@ -292291,6 +290629,8 @@ self: { benchmarkHaskellDepends = [ base bytestring criterion text ]; description = "Streaming decoding functions for UTF encodings. (deprecated)"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "text-time" = callPackage @@ -292416,19 +290756,6 @@ self: { }) {}; "text-zipper" = callPackage - ({ mkDerivation, base, deepseq, hspec, QuickCheck, text, vector }: - mkDerivation { - pname = "text-zipper"; - version = "0.12"; - sha256 = "00k7d6qfznhp6l2ihw3pppkn580pwd7ac7wx9vidil4y9hjagaw6"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ base deepseq text vector ]; - testHaskellDepends = [ base hspec QuickCheck text ]; - description = "A text editor zipper library"; - license = lib.licenses.bsd3; - }) {}; - - "text-zipper_0_13" = callPackage ({ mkDerivation, base, deepseq, hspec, QuickCheck, text, vector }: mkDerivation { pname = "text-zipper"; @@ -292439,7 +290766,6 @@ self: { testHaskellDepends = [ base hspec QuickCheck text ]; description = "A text editor zipper library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "text-zipper-monad" = callPackage @@ -292729,8 +291055,8 @@ self: { }) {}; "th-compat" = callPackage - ({ mkDerivation, base, base-compat, directory, filepath, hspec - , hspec-discover, mtl, template-haskell + ({ mkDerivation, base, base-compat, hspec, hspec-discover, mtl + , template-haskell }: mkDerivation { pname = "th-compat"; @@ -292738,9 +291064,7 @@ self: { sha256 = "1f5ssi24mnhmmi91dl5ddg2jwci6akwlznqggf56nyxl9b0pmyfq"; revision = "2"; editedCabalFile = "0c0p2qy78cwhdfw0hn8g16l5xidikdk5314gam4258pk7q47rbp5"; - libraryHaskellDepends = [ - base directory filepath template-haskell - ]; + libraryHaskellDepends = [ base template-haskell ]; testHaskellDepends = [ base base-compat hspec mtl template-haskell ]; @@ -292814,8 +291138,10 @@ self: { }: mkDerivation { pname = "th-desugar"; - version = "1.13.1"; - sha256 = "03k2kfbzfc87kibzbpp3s1l5xb0ww2vvwj9ngh0qapxm28a01rz3"; + version = "1.14"; + sha256 = "1b57v15xx0z0xjlijv61dh07p6rvfkdpxnxiaaa1iv7zyg2x7cnz"; + revision = "2"; + editedCabalFile = "16i6x4w286mhhkxzjid5pfbnn51dzyxq6brawlppqb15qbnvs744"; libraryHaskellDepends = [ base containers ghc-prim mtl ordered-containers syb template-haskell th-abstraction th-lift th-orphans @@ -292904,6 +291230,8 @@ self: { pname = "th-extras"; version = "0.0.0.6"; sha256 = "0jkwy2kqdqmq3qmfy76px2pm8idxgs18x1k1dzpsccq21ja27gq2"; + revision = "1"; + editedCabalFile = "0v81vfgaky4bb3rh18mnb7ampwm43dba3vsngv9mb1f3z975f0ix"; libraryHaskellDepends = [ base containers syb template-haskell th-abstraction ]; @@ -293175,6 +291503,27 @@ self: { license = lib.licenses.mit; }) {}; + "th-printf_0_8" = callPackage + ({ mkDerivation, base, charset, containers, dlist, hspec, HUnit + , integer-logarithms, microlens-platform, mtl, parsec, QuickCheck + , semigroups, template-haskell, text, th-lift, transformers + }: + mkDerivation { + pname = "th-printf"; + version = "0.8"; + sha256 = "0lirq0aq7sq43g29xpzhrpkmh1wlkdyxh9pv6ryqbbpcgnx98m7l"; + libraryHaskellDepends = [ + base charset containers dlist integer-logarithms microlens-platform + mtl parsec semigroups template-haskell text th-lift transformers + ]; + testHaskellDepends = [ + base hspec HUnit QuickCheck template-haskell text + ]; + description = "Quasiquoters for printf"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "th-reify-compat" = callPackage ({ mkDerivation, base, template-haskell }: mkDerivation { @@ -293426,7 +291775,9 @@ self: { ]; description = "Haskell API bindings for http://themoviedb.org"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "tmdb"; + broken = true; }) {}; "themplate" = callPackage @@ -293507,19 +291858,6 @@ self: { }) {}; "these" = callPackage - ({ mkDerivation, assoc, base, binary, deepseq, hashable }: - mkDerivation { - pname = "these"; - version = "1.1.1.1"; - sha256 = "027m1gd7i6jf2ppfkld9qrv3xnxg276587pmx10z9phpdvswk66p"; - revision = "6"; - editedCabalFile = "12ll5l8m482qkb8zn79vx51bqlwc89fgixf8jv33a32b4qzc3499"; - libraryHaskellDepends = [ assoc base binary deepseq hashable ]; - description = "An either-or-both data type"; - license = lib.licenses.bsd3; - }) {}; - - "these_1_2" = callPackage ({ mkDerivation, assoc, base, binary, deepseq , foldable1-classes-compat, hashable }: @@ -293532,23 +291870,9 @@ self: { ]; description = "An either-or-both data type"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "these-lens" = callPackage - ({ mkDerivation, base, lens, these }: - mkDerivation { - pname = "these-lens"; - version = "1.0.1.2"; - sha256 = "1v3kj7j4bkywbmdbblwqs5gsj5s23d59sb3s27jf3bwdzf9d21p6"; - revision = "2"; - editedCabalFile = "1mncy6mcwqxy4fwibrsfc3jcx183wfjfvfvbj030y86pfihvbwg3"; - libraryHaskellDepends = [ base lens these ]; - description = "Lenses for These"; - license = lib.licenses.bsd3; - }) {}; - - "these-lens_1_0_1_3" = callPackage ({ mkDerivation, base, lens, these }: mkDerivation { pname = "these-lens"; @@ -293557,7 +291881,6 @@ self: { libraryHaskellDepends = [ base lens these ]; description = "Lenses for These"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "these-optics" = callPackage @@ -293957,8 +292280,8 @@ self: { pname = "threepenny-gui"; version = "0.9.4.0"; sha256 = "08jqa01pp6b300ic0xcn687i0a0kvz76bgym3dchk9n75m6hvc4f"; - revision = "1"; - editedCabalFile = "1lhy4g10ylqb5pkh1rmpbjvynypbj1y82h0mhrr3igngpfi8k69x"; + revision = "2"; + editedCabalFile = "1jbi3njiyrcykcx8nnz43a7yzh1ad5aigd7ww04vhi8vp3gasbv6"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -294107,6 +292430,8 @@ self: { libraryHaskellDepends = [ base bytestring case-insensitive text ]; description = "Convert textual types through Text without needing O(n^2) instances"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "throwable-exceptions" = callPackage @@ -294360,28 +292685,6 @@ self: { }) {}; "tidal" = callPackage - ({ mkDerivation, base, bytestring, clock, colour, containers - , criterion, deepseq, exceptions, hosc, microspec, mtl, network - , parsec, primitive, random, text, tidal-link, transformers, weigh - }: - mkDerivation { - pname = "tidal"; - version = "1.9.2"; - sha256 = "0ncc5rc2g0brmgd28cbigp1rhvch9az30vg987q8fn7xfzbxw92h"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - base bytestring clock colour containers deepseq exceptions hosc mtl - network parsec primitive random text tidal-link transformers - ]; - testHaskellDepends = [ - base containers deepseq hosc microspec parsec - ]; - benchmarkHaskellDepends = [ base criterion weigh ]; - description = "Pattern language for improvised music"; - license = lib.licenses.gpl3Only; - }) {}; - - "tidal_1_9_4" = callPackage ({ mkDerivation, base, bytestring, clock, colour, containers , criterion, deepseq, exceptions, hosc, microspec, mtl, network , parsec, primitive, random, text, tidal-link, transformers, weigh @@ -294401,18 +292704,17 @@ self: { benchmarkHaskellDepends = [ base criterion weigh ]; description = "Pattern language for improvised music"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "tidal-link" = callPackage - ({ mkDerivation, base }: + ({ mkDerivation, base, system-cxx-std-lib }: mkDerivation { pname = "tidal-link"; version = "1.0.1"; sha256 = "0s3x73zx4rxjawcf2744z9dr05j4pabbxddrz9814h1d61q2cbb1"; isLibrary = true; isExecutable = true; - libraryHaskellDepends = [ base ]; + libraryHaskellDepends = [ base system-cxx-std-lib ]; executableHaskellDepends = [ base ]; description = "Ableton Link integration for Tidal"; license = lib.licenses.gpl3Only; @@ -294863,25 +293165,6 @@ self: { }) {}; "time-parsers" = callPackage - ({ mkDerivation, attoparsec, base, bifunctors, parsec, parsers - , tasty, tasty-hunit, template-haskell, text, time - }: - mkDerivation { - pname = "time-parsers"; - version = "0.1.2.1"; - sha256 = "102k6l9888kbgng045jk170qjbmdnwv2lbzlc12ncybfk2yk7wdv"; - revision = "5"; - editedCabalFile = "0dbqqlh98m06qj8jh1fs55lcxj4x4555x4p48xi3bjh5fdg4dkw0"; - libraryHaskellDepends = [ base parsers template-haskell time ]; - testHaskellDepends = [ - attoparsec base bifunctors parsec parsers tasty tasty-hunit - template-haskell text time - ]; - description = "Parsers for types in `time`"; - license = lib.licenses.bsd3; - }) {}; - - "time-parsers_0_2" = callPackage ({ mkDerivation, attoparsec, base, bifunctors, parsec, parsers , tasty, tasty-hunit, template-haskell, text, time }: @@ -294896,7 +293179,6 @@ self: { ]; description = "Parsers for types in `time`"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "time-patterns" = callPackage @@ -295196,8 +293478,8 @@ self: { pname = "timeline"; version = "0.1.0.0"; sha256 = "0ya56j51vgg380yylpakfgr5srv20ybiyy7yhfyxz21sdgz7f168"; - revision = "1"; - editedCabalFile = "0n6vbq1240czyq6bzlbsy9mk1swss78vbk5v099b8h5kf21z5pb1"; + revision = "3"; + editedCabalFile = "1mr593bg9wahgwf1xx3qms9x7zyyjd6lgkclq5s7jz2r9z1z7l9g"; libraryHaskellDepends = [ base containers hedgehog indexed-traversable semigroupoids template-haskell text th-compat time @@ -295835,6 +294117,8 @@ self: { pname = "tinytools-vty"; version = "0.1.0.3"; sha256 = "17q484rfrwixp2y72x1pxcav2y6sz99la961yn8iwa1ipwljy1s6"; + revision = "1"; + editedCabalFile = "1mfyc4ilc68p8q4cpjq528387zg4bzzs6kzp12s4i3hmm7lxxch8"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -296224,8 +294508,8 @@ self: { }: mkDerivation { pname = "tls"; - version = "1.5.8"; - sha256 = "0rxdv8ab98kd4nqql7djmmi51k4vayq21s38s43sx3rzn0iyla3b"; + version = "1.6.0"; + sha256 = "1674i73dwha42ia1wlngi346lnfbag46w1wvqfim5f61q6pj17fj"; libraryHaskellDepends = [ asn1-encoding asn1-types async base bytestring cereal cryptonite data-default-class hourglass memory mtl network transformers x509 @@ -296291,6 +294575,8 @@ self: { ]; description = "Set of programs for TLS testing and debugging"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tls-extra" = callPackage @@ -296336,8 +294622,8 @@ self: { }: mkDerivation { pname = "tlynx"; - version = "0.7.2.1"; - sha256 = "0v3lcmvd036mjsjyxlcixrxbf33f3bp4ijjcx2c1jhir109yvzxp"; + version = "0.7.2.2"; + sha256 = "0hc4z139v9ig0fcm4dqim388idik63d1qy00ir1bglf4rwhs41b7"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -296430,8 +294716,8 @@ self: { }: mkDerivation { pname = "tmp-proc"; - version = "0.5.1.3"; - sha256 = "050inff8y97bzf4ajnqrxgcblj0cq0khcp1y35vwbwgm3al2l21p"; + version = "0.5.1.4"; + sha256 = "0ps2fh7c9s30yc2jvwz5qzlhr6qck23as7f1ddkvxfh07wll2bkz"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -296447,6 +294733,31 @@ self: { license = lib.licenses.bsd3; }) {}; + "tmp-proc_0_5_2_1" = callPackage + ({ mkDerivation, async, base, bytestring, data-default, hspec + , http-client, http-types, mtl, network, process, text, unliftio + , wai, warp, warp-tls + }: + mkDerivation { + pname = "tmp-proc"; + version = "0.5.2.1"; + sha256 = "0zhwvpy9dxxy550wr7wha6iqmrvcqpdgdlzx08sjljzvi1wiliji"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + async base bytestring mtl network process text unliftio wai warp + warp-tls + ]; + testHaskellDepends = [ + base bytestring data-default hspec http-client http-types text wai + warp + ]; + description = "Run 'tmp' processes in integration tests"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "tmp-proc-example" = callPackage ({ mkDerivation, aeson, base, bytestring, exceptions, hedis, hspec , hspec-tmp-proc, http-client, http-client-tls, monad-logger, mtl @@ -296479,8 +294790,8 @@ self: { }: mkDerivation { pname = "tmp-proc-postgres"; - version = "0.5.2.2"; - sha256 = "1h8c5rv4i85z173mx2d2bw2ipzwjs04lrlc45249l26f6p4nlr9p"; + version = "0.5.2.3"; + sha256 = "1db2nj009daglrdgwn89xab072ax1lcl3rvjzlp6fcqfmppdjj1g"; libraryHaskellDepends = [ base bytestring postgresql-simple text tmp-proc ]; @@ -296498,8 +294809,8 @@ self: { }: mkDerivation { pname = "tmp-proc-rabbitmq"; - version = "0.5.1.2"; - sha256 = "1kysd1li7qaczdiqxbcmhxjq97h6xkjcyz0qhkwfy424x1dd6m3d"; + version = "0.5.1.4"; + sha256 = "0iv12gbahmxxb0ap616ziwj34dx25qbmj9j9ach29hfabsr45bx9"; libraryHaskellDepends = [ amqp base bytestring text tmp-proc ]; testHaskellDepends = [ amqp base bytestring hspec hspec-tmp-proc text tmp-proc @@ -296514,8 +294825,8 @@ self: { }: mkDerivation { pname = "tmp-proc-redis"; - version = "0.5.1.2"; - sha256 = "1602z1sx9gl0ca3wfq48k1rnxl93fb99zp6m49mbyd8l2gfijf5c"; + version = "0.5.1.4"; + sha256 = "0rmximk8asf59s89girbvg244dsd7h72x2bwswkrm2zmv42j2qhr"; libraryHaskellDepends = [ base bytestring hedis text tmp-proc ]; testHaskellDepends = [ base bytestring hedis hspec hspec-tmp-proc text tmp-proc @@ -296530,8 +294841,8 @@ self: { }: mkDerivation { pname = "tmp-proc-zipkin"; - version = "0.5.1.2"; - sha256 = "1sjdrd53vh8mfc7gk04lzzqjcgaif4pb20vsd52cfh5210iagb92"; + version = "0.5.1.4"; + sha256 = "19vwpgchhzc29ssvdidjim97957dnf8p21myq5fc3js7dq7lzgz3"; libraryHaskellDepends = [ base bytestring http-client text tmp-proc tracing ]; @@ -296555,6 +294866,7 @@ self: { ]; description = "simple executable for templating"; license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; mainProgram = "tmpl"; }) {}; @@ -296748,7 +295060,9 @@ self: { ]; description = "Manage the toilet queue at the IMO"; license = "GPL"; + hydraPlatforms = lib.platforms.none; mainProgram = "toilet"; + broken = true; }) {}; "token-bucket" = callPackage @@ -297023,19 +295337,24 @@ self: { }) {}; "toml-parser" = callPackage - ({ mkDerivation, alex, array, base, happy, text, time }: + ({ mkDerivation, alex, array, base, containers, happy, hspec + , hspec-discover, markdown-unlit, prettyprinter, template-haskell + , text, time, transformers + }: mkDerivation { pname = "toml-parser"; - version = "0.1.0.0"; - sha256 = "0p1nl3009qlcqn4jjggbm1v719a6bswklkyjb3plm0cz3bsyr0fs"; - revision = "3"; - editedCabalFile = "1hls6xw2c7379m1x92da91v7mv1ysdsj6shi1nslfq5xgm53bw14"; - libraryHaskellDepends = [ array base text time ]; + version = "1.3.0.0"; + sha256 = "162vhazlilpqxvdp8xv4qsnpijr2wz6a1zyknas6f8yy9rxa5mpw"; + libraryHaskellDepends = [ + array base containers prettyprinter text time transformers + ]; libraryToolDepends = [ alex happy ]; - description = "Parser for the TOML configuration language"; + testHaskellDepends = [ + base containers hspec template-haskell time + ]; + testToolDepends = [ hspec-discover markdown-unlit ]; + description = "TOML 1.0.0 parser"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "toml-reader" = callPackage @@ -298792,6 +297111,8 @@ self: { ]; description = "General data structure lifting for Template Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "traverse-with-class" = callPackage @@ -298940,8 +297261,10 @@ self: { }: mkDerivation { pname = "tree-diff"; - version = "0.2.2"; - sha256 = "0g3lsp067dq1ydvj2im4nlfxa65g9zjmjjkv91dhjhnrklir10q0"; + version = "0.3.0.1"; + sha256 = "1bkjsklsqxq8i8p3zx73pck4ca1kv21zjvn9xhbhz191gygprrj0"; + revision = "3"; + editedCabalFile = "1skq2bqfsj1f4hqy5cwm8k0a8bgqbdqspcxccismbgxxqqg60d22"; libraryHaskellDepends = [ aeson ansi-terminal ansi-wl-pprint base base-compat bytestring bytestring-builder containers deepseq hashable parsec parsers @@ -298951,44 +297274,13 @@ self: { testHaskellDepends = [ ansi-terminal ansi-wl-pprint base base-compat parsec primitive QuickCheck tagged tasty tasty-golden tasty-quickcheck trifecta + unordered-containers ]; benchmarkHaskellDepends = [ base criterion deepseq Diff ]; description = "Diffing of (expression) trees"; license = lib.licenses.gpl2Plus; }) {}; - "tree-diff_0_3_0_1" = callPackage - ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, base - , base-compat, bytestring, bytestring-builder, containers - , criterion, data-array-byte, deepseq, Diff, hashable, parsec - , parsers, pretty, primitive, QuickCheck, scientific, semialign - , strict, tagged, tasty, tasty-golden, tasty-quickcheck, text - , these, time, trifecta, unordered-containers, uuid-types, vector - }: - mkDerivation { - pname = "tree-diff"; - version = "0.3.0.1"; - sha256 = "1bkjsklsqxq8i8p3zx73pck4ca1kv21zjvn9xhbhz191gygprrj0"; - revision = "2"; - editedCabalFile = "070r8xv71bl57ln6kg51g66pplvvprknm6kai0a75vhjmnz5aicc"; - libraryHaskellDepends = [ - aeson ansi-terminal ansi-wl-pprint base base-compat bytestring - bytestring-builder containers data-array-byte deepseq hashable - parsec parsers pretty primitive QuickCheck scientific semialign - strict tagged text these time unordered-containers uuid-types - vector - ]; - testHaskellDepends = [ - ansi-terminal ansi-wl-pprint base base-compat data-array-byte - parsec primitive QuickCheck tagged tasty tasty-golden - tasty-quickcheck trifecta unordered-containers - ]; - benchmarkHaskellDepends = [ base criterion deepseq Diff ]; - description = "Diffing of (expression) trees"; - license = lib.licenses.gpl2Plus; - hydraPlatforms = lib.platforms.none; - }) {}; - "tree-fun" = callPackage ({ mkDerivation, base, containers, mtl }: mkDerivation { @@ -299570,8 +297862,8 @@ self: { pname = "trifecta"; version = "2.1.2"; sha256 = "1akx8m6mgskwsbhsf90cxlqjq23jk4pwaxagvm923dpncwrlwfla"; - revision = "2"; - editedCabalFile = "0a1dvyzvdxk6sqb5y3y2k5qvyr7vq5jx7a409z3f7wa2mkf5xj02"; + revision = "3"; + editedCabalFile = "005c02rzsj83zm5ys6572af2d57lalsnkla5f312x0b7ykhnmz90"; libraryHaskellDepends = [ ansi-terminal array base blaze-builder blaze-html blaze-markup bytestring charset comonad containers deepseq fingertree ghc-prim @@ -299825,6 +298117,8 @@ self: { testHaskellDepends = [ base binary containers cropty merge text ]; description = "An implementation of a trust chain"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "truthful" = callPackage @@ -300124,6 +298418,8 @@ self: { pname = "ttc"; version = "1.2.1.0"; sha256 = "001r357h1szs86xsivikvm4h57g6f6p63c2r83y2kpiflnaap4as"; + revision = "1"; + editedCabalFile = "16z92hzk88w6gbhykjhhjy1zcvlnclmr94jz7rdqanbmbybqs4pg"; libraryHaskellDepends = [ base bytestring template-haskell text ]; testHaskellDepends = [ base bytestring tasty tasty-hunit template-haskell text @@ -300614,30 +298910,6 @@ self: { }) {}; "turtle" = callPackage - ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock - , containers, directory, doctest, exceptions, foldl, hostname - , managed, optional-args, optparse-applicative, process, stm - , streaming-commons, system-fileio, system-filepath, tasty-bench - , temporary, text, time, transformers, unix, unix-compat - }: - mkDerivation { - pname = "turtle"; - version = "1.5.25"; - sha256 = "1hh2rbwk3m4iklk67f1l1a8shsng9qzs9132j6lpag7cgqkrmqdk"; - libraryHaskellDepends = [ - ansi-wl-pprint async base bytestring clock containers directory - exceptions foldl hostname managed optional-args - optparse-applicative process stm streaming-commons system-fileio - system-filepath temporary text time transformers unix unix-compat - ]; - testHaskellDepends = [ base doctest system-filepath temporary ]; - benchmarkHaskellDepends = [ base tasty-bench text ]; - description = "Shell programming, Haskell-style"; - license = lib.licenses.bsd3; - maintainers = [ lib.maintainers.Gabriella439 ]; - }) {}; - - "turtle_1_6_1" = callPackage ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock , containers, directory, doctest, exceptions, filepath, foldl , hostname, managed, optional-args, optparse-applicative, process @@ -300648,8 +298920,8 @@ self: { pname = "turtle"; version = "1.6.1"; sha256 = "171viripwn8hg3afkkswr243bv7q0r0bz3mn0bflddm4jdf49597"; - revision = "3"; - editedCabalFile = "00jxvvpffllwcaw2sg0rymj66963ihifpjn4m94mgscqwl25cfqs"; + revision = "5"; + editedCabalFile = "1ll4pz1f2inhrfv1l6akzqlbycfwjxr6n1zzfspscjvwwni4vkm7"; libraryHaskellDepends = [ ansi-wl-pprint async base bytestring clock containers directory exceptions filepath foldl hostname managed optional-args @@ -300662,7 +298934,6 @@ self: { benchmarkHaskellDepends = [ base tasty-bench text ]; description = "Shell programming, Haskell-style"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.Gabriella439 ]; }) {}; @@ -300716,6 +298987,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Tiny web application framework for WAI"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "tweak" = callPackage @@ -300746,6 +299019,7 @@ self: { ]; description = "An equational theorem prover"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "twee"; }) {}; @@ -301201,6 +299475,8 @@ self: { ]; description = "A high level file watcher DSL"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "twitchapi" = callPackage @@ -301600,6 +299876,8 @@ self: { libraryHaskellDepends = [ base ]; description = "Type-level Ord compatibility layer"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-digits" = callPackage @@ -301969,32 +300247,6 @@ self: { }) {}; "type-natural" = callPackage - ({ mkDerivation, base, constraints, equational-reasoning, ghc - , ghc-typelits-knownnat, ghc-typelits-natnormalise - , ghc-typelits-presburger, integer-logarithms, QuickCheck - , quickcheck-instances, tasty, tasty-discover, tasty-hunit - , tasty-quickcheck, template-haskell - }: - mkDerivation { - pname = "type-natural"; - version = "1.1.0.1"; - sha256 = "1dzmaia5w59cmq6aivsamklq6ydd72l9y44az1plycmscm0kchiz"; - libraryHaskellDepends = [ - base constraints equational-reasoning ghc ghc-typelits-knownnat - ghc-typelits-natnormalise ghc-typelits-presburger - integer-logarithms template-haskell - ]; - testHaskellDepends = [ - base equational-reasoning integer-logarithms QuickCheck - quickcheck-instances tasty tasty-discover tasty-hunit - tasty-quickcheck template-haskell - ]; - testToolDepends = [ tasty-discover ]; - description = "Type-level natural and proofs of their properties"; - license = lib.licenses.bsd3; - }) {}; - - "type-natural_1_3_0_0" = callPackage ({ mkDerivation, base, constraints, equational-reasoning, ghc , ghc-typelits-knownnat, ghc-typelits-natnormalise , ghc-typelits-presburger, integer-logarithms, QuickCheck @@ -302018,7 +300270,6 @@ self: { testToolDepends = [ tasty-discover ]; description = "Type-level natural and proofs of their properties"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "type-of-html" = callPackage @@ -302067,6 +300318,8 @@ self: { libraryHaskellDepends = [ base ghc-prim ]; description = "Various type-level operators"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "type-ord" = callPackage @@ -302331,21 +300584,6 @@ self: { }) {}; "typecheck-plugin-nat-simple" = callPackage - ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra }: - mkDerivation { - pname = "typecheck-plugin-nat-simple"; - version = "0.1.0.7"; - sha256 = "1zvl113x5hi4xx29nl8kf3wxi9a51b4z17x380akl5isw8qhpj1x"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - base containers ghc ghc-tcplugins-extra - ]; - testHaskellDepends = [ base containers ghc ghc-tcplugins-extra ]; - description = "Simple type check plugin which calculate addition, subtraction and less-or-equal-than"; - license = lib.licenses.bsd3; - }) {}; - - "typecheck-plugin-nat-simple_0_1_0_9" = callPackage ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra }: mkDerivation { pname = "typecheck-plugin-nat-simple"; @@ -302358,7 +300596,6 @@ self: { testHaskellDepends = [ base containers ghc ghc-tcplugins-extra ]; description = "Simple type check plugin which calculate addition, subtraction and less-or-equal-than"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "typed-admin" = callPackage @@ -302503,7 +300740,9 @@ self: { executableHaskellDepends = [ base diagrams-lib text ]; description = "Typed and composable spreadsheets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.Gabriella439 ]; + broken = true; }) {}; "typed-streams" = callPackage @@ -302810,6 +301049,8 @@ self: { doHaddock = false; description = "Efficient implementation of a dependent map with types as keys"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "types-compat" = callPackage @@ -302845,8 +301086,8 @@ self: { }: mkDerivation { pname = "typesafe-precure"; - version = "0.9.1.1"; - sha256 = "0g04zr6nd7fsbj6xjvr151kbq2j1hmm9fdnj4mlh26s0gacbpv7w"; + version = "0.10.0.1"; + sha256 = "0ynmmxry5wqpjak0dj3pv6j0cpv8865v10s7bcr1sbbzr00nsci9"; libraryHaskellDepends = [ aeson aeson-pretty autoexporter base bytestring dlist monad-skeleton template-haskell text th-data-compat @@ -302857,6 +301098,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "Type-safe transformations and purifications of PreCures (Japanese Battle Heroine)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "typescript-docs" = callPackage @@ -303018,23 +301260,27 @@ self: { "typst" = callPackage ({ mkDerivation, aeson, array, base, bytestring, cassava - , containers, filepath, mtl, ordered-containers, parsec, pretty - , pretty-show, regex-tdfa, scientific, tasty, tasty-golden, text - , typst-symbols, vector, xml-conduit, yaml + , containers, digits, directory, filepath, mtl, ordered-containers + , parsec, pretty, pretty-show, regex-tdfa, scientific, tasty + , tasty-golden, text, time, toml-parser, typst-symbols, vector + , xml-conduit, yaml }: mkDerivation { pname = "typst"; - version = "0.1.0.0"; - sha256 = "1vsfl9lijx01raz6fdi9mn5rvlpxbgb2q6ky37ahqn2pcd3r82m4"; + version = "0.3.1.0"; + sha256 = "05jal4csacirg67f0lqmcs5z9sgv9wica24mgnj1rsk2j0jc7z3a"; + revision = "1"; + editedCabalFile = "16fyvpfcgdp3sqbsfc5p4014c14v0j4hiw5r8idhpcrfnviv1dlb"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - aeson array base bytestring cassava containers filepath mtl - ordered-containers parsec pretty regex-tdfa scientific text - typst-symbols vector xml-conduit yaml + aeson array base bytestring cassava containers digits directory + filepath mtl ordered-containers parsec pretty regex-tdfa scientific + text time toml-parser typst-symbols vector xml-conduit yaml ]; testHaskellDepends = [ - base bytestring filepath pretty-show tasty tasty-golden text + base bytestring directory filepath pretty-show tasty tasty-golden + text time ]; description = "Parsing and evaluating typst syntax"; license = lib.licenses.bsd3; @@ -303044,10 +301290,8 @@ self: { ({ mkDerivation, base, text }: mkDerivation { pname = "typst-symbols"; - version = "0.1.0.1"; - sha256 = "0kwdsp3j5qpfwaf2z91k7x9844bnb2wdm3v5ii9zkpnjmpxvbqph"; - revision = "1"; - editedCabalFile = "1z4f2ypk6askn5m9zcpla5cib7xliff2akp0bcs34lwqnr0ycjvr"; + version = "0.1.2"; + sha256 = "1ax0rd5qqrig1ck5fprdfwk6cqbdi1v05ibd9m33vwygf4gcgrn2"; libraryHaskellDepends = [ base text ]; description = "Symbol and emoji lookup for typst language"; license = lib.licenses.mit; @@ -303085,8 +301329,8 @@ self: { pname = "tz"; version = "0.1.3.6"; sha256 = "1vqnfk656i6j3j1bf9lc36adziv52x1b2ccq6afp8cka1nay2mcd"; - revision = "1"; - editedCabalFile = "0mwal38qsf32fppza1ivx0vdvpma9z5gn4ni08mc080ns0s7kvgy"; + revision = "3"; + editedCabalFile = "03viai54yr4m59vavvgf070q50nsnpwxnzjnj3sbbxxs1sg3ncpv"; libraryHaskellDepends = [ base binary bytestring containers data-default deepseq template-haskell time tzdata vector @@ -303112,6 +301356,8 @@ self: { pname = "tzdata"; version = "0.2.20230322.0"; sha256 = "1qir5cy2cyk4p923l3ibimvc0rn4h5pwx0wmjarx69bmxzm7jib7"; + revision = "1"; + editedCabalFile = "0xzpdsgzfqbhr5xk6k26rdkd18js08dc0vwbh2v3fbshf97nfr02"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base bytestring containers deepseq vector @@ -303347,6 +301593,8 @@ self: { testHaskellDepends = [ base containers ]; description = "Datatype and parser for the Universal Configuration Language (UCL) using libucl"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) libucl;}; "uconv" = callPackage @@ -304317,24 +302565,6 @@ self: { }) {}; "unicode-data" = callPackage - ({ mkDerivation, base, deepseq, hspec, hspec-discover, tasty - , tasty-bench - }: - mkDerivation { - pname = "unicode-data"; - version = "0.3.1"; - sha256 = "0q2wygqg0z9b22gzi083cxm73a8iz14zqvdsjmix9i57jxa827xy"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ base hspec ]; - testToolDepends = [ hspec-discover ]; - benchmarkHaskellDepends = [ base deepseq tasty tasty-bench ]; - description = "Access Unicode Character Database (UCD)"; - license = lib.licenses.asl20; - }) {}; - - "unicode-data_0_4_0_1" = callPackage ({ mkDerivation, base, deepseq, hspec, tasty, tasty-bench }: mkDerivation { pname = "unicode-data"; @@ -304349,7 +302579,6 @@ self: { benchmarkHaskellDepends = [ base deepseq tasty tasty-bench ]; description = "Access Unicode Character Database (UCD)"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "unicode-data-names" = callPackage @@ -304537,17 +302766,18 @@ self: { }) {}; "unicode-tricks" = callPackage - ({ mkDerivation, base, containers, data-default, deepseq, hashable - , hspec, hspec-discover, QuickCheck, text + ({ mkDerivation, base, containers, data-default-class, deepseq + , hashable, hspec, hspec-discover, QuickCheck, text, time }: mkDerivation { pname = "unicode-tricks"; - version = "0.12.1.0"; - sha256 = "139hrmxqw1f4gchv8wlyy3x1xfwcv5zzpdz0f3b6xm6v4zbwy101"; + version = "0.14.0.0"; + sha256 = "1p612nkaq2v020n22zgw6cv3glwjsj1jcy6ad4lw30dg800wcrb2"; libraryHaskellDepends = [ - base containers data-default deepseq hashable QuickCheck text + base containers data-default-class deepseq hashable QuickCheck text + time ]; - testHaskellDepends = [ base hashable hspec QuickCheck text ]; + testHaskellDepends = [ base hashable hspec QuickCheck text time ]; testToolDepends = [ hspec-discover ]; description = "Functions to work with unicode blocks more convenient"; license = lib.licenses.bsd3; @@ -304575,6 +302805,7 @@ self: { testHaskellDepends = [ base text ]; description = "Make writing in unicode easy"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "unicoder"; }) {}; @@ -304841,6 +303072,7 @@ self: { libraryHaskellDepends = [ base fsnotify twitch uniformBase ]; description = "uniform wrapper for watch"; license = "GPL"; + hydraPlatforms = lib.platforms.none; }) {}; "uniform-webserver" = callPackage @@ -304927,6 +303159,8 @@ self: { libraryHaskellDepends = [ base containers transformers ]; description = "Efficient union and equivalence testing of sets"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "union-find-array" = callPackage @@ -304969,6 +303203,8 @@ self: { ]; description = "Union mount filesystem paths into Haskell datastructures"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unipatterns" = callPackage @@ -305365,6 +303601,24 @@ self: { license = lib.licenses.bsd3; }) {}; + "units-parser_0_1_1_5" = callPackage + ({ mkDerivation, base, containers, mtl, multimap, parsec, syb + , tasty, tasty-hunit, template-haskell + }: + mkDerivation { + pname = "units-parser"; + version = "0.1.1.5"; + sha256 = "16q7q9c27wy8hx7rp34d2nhywpdkn8rb43hljx1j20kydyp0m2sb"; + libraryHaskellDepends = [ base containers mtl multimap parsec ]; + testHaskellDepends = [ + base containers mtl multimap parsec syb tasty tasty-hunit + template-haskell + ]; + description = "A parser for units of measure"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "unittyped" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -305411,6 +303665,8 @@ self: { libraryHaskellDepends = [ base text transformers ]; description = "A monad type class shared between web services"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "unitym-servant" = callPackage @@ -305426,6 +303682,7 @@ self: { ]; description = "Implementaation of unitym for Servant servers"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "unitym-yesod" = callPackage @@ -305631,8 +303888,8 @@ self: { }: mkDerivation { pname = "universum"; - version = "1.8.1.1"; - sha256 = "1cfz4h66jw0jh19vms4smga33hj9sc5s3xdaigi01wnaza7wl2di"; + version = "1.8.2"; + sha256 = "1dhynivkbg59b5m2m90dwxz6wk00im3gihyvigrcqazpfhq4j845"; libraryHaskellDepends = [ base bytestring containers deepseq ghc-prim hashable microlens microlens-mtl mtl safe-exceptions stm text transformers @@ -305665,17 +303922,6 @@ self: { }) {}; "unix-bytestring" = callPackage - ({ mkDerivation, base, bytestring }: - mkDerivation { - pname = "unix-bytestring"; - version = "0.3.7.8"; - sha256 = "0x20dzcpmy5qq35fsxiigk4lzad101qkrkckphry2ak0b1ijk4zl"; - libraryHaskellDepends = [ base bytestring ]; - description = "Unix/Posix-specific functions for ByteStrings"; - license = lib.licenses.bsd3; - }) {}; - - "unix-bytestring_0_4_0" = callPackage ({ mkDerivation, base, bytestring }: mkDerivation { pname = "unix-bytestring"; @@ -305684,23 +303930,28 @@ self: { libraryHaskellDepends = [ base bytestring ]; description = "Unix/Posix-specific functions for ByteStrings"; license = lib.licenses.bsd3; + }) {}; + + "unix-compat_0_6" = callPackage + ({ mkDerivation, base, directory, extra, hspec, HUnit + , monad-parallel, temporary, unix + }: + mkDerivation { + pname = "unix-compat"; + version = "0.6"; + sha256 = "1y6m8ix8np6vambabdaj2h7ydgda8igwy3kliv53mba3clx85kdl"; + revision = "1"; + editedCabalFile = "0g5mi6rh977idajgxnnlsd7dp28vf4xwiiwpsc4pj1rqv0lhjp8g"; + libraryHaskellDepends = [ base unix ]; + testHaskellDepends = [ + base directory extra hspec HUnit monad-parallel temporary + ]; + description = "Portable POSIX-compatibility layer"; + license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; }) {}; "unix-compat" = callPackage - ({ mkDerivation, base, unix }: - mkDerivation { - pname = "unix-compat"; - version = "0.5.4"; - sha256 = "1cd4lh2c16h7y5hzrcn5l9vir8aq2wcizwksppnagklsdsfmf942"; - revision = "2"; - editedCabalFile = "0mik6xb1jdmb2jlxlmzf0517mxfj0c1j2i4r6h5212m4q6znqqcm"; - libraryHaskellDepends = [ base unix ]; - description = "Portable POSIX-compatibility layer"; - license = lib.licenses.bsd3; - }) {}; - - "unix-compat_0_7" = callPackage ({ mkDerivation, base, directory, extra, hspec, HUnit , monad-parallel, temporary, unix }: @@ -305714,7 +303965,6 @@ self: { ]; description = "Portable POSIX-compatibility layer"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "unix-fcntl" = callPackage @@ -305839,15 +304089,16 @@ self: { "unix-time" = callPackage ({ mkDerivation, base, binary, bytestring, hspec, hspec-discover - , old-locale, old-time, QuickCheck, time + , old-locale, old-time, QuickCheck, template-haskell, time }: mkDerivation { pname = "unix-time"; - version = "0.4.9"; - sha256 = "024bmjy16mwdyf4rkyy6l2s63ym5gg04vxdk5ylml1hfhva381s9"; + version = "0.4.10"; + sha256 = "1g196sh2jj0mhk6jh9pmsrh06y6p8j5cd9x1wfqwfyx8rgw4njky"; libraryHaskellDepends = [ base binary bytestring old-time ]; testHaskellDepends = [ - base bytestring hspec old-locale old-time QuickCheck time + base bytestring hspec old-locale old-time QuickCheck + template-haskell time ]; testToolDepends = [ hspec-discover ]; description = "Unix time parser/formatter and utilities"; @@ -306033,21 +304284,6 @@ self: { }) {}; "unliftio-pool" = callPackage - ({ mkDerivation, base, resource-pool, time, transformers - , unliftio-core - }: - mkDerivation { - pname = "unliftio-pool"; - version = "0.2.2.0"; - sha256 = "08246kbmgxv5afm6kngag2mh8mswifsh6017z8rirca37cwp01vr"; - libraryHaskellDepends = [ - base resource-pool time transformers unliftio-core - ]; - description = "Data.Pool generalized to MonadUnliftIO."; - license = lib.licenses.bsd3; - }) {}; - - "unliftio-pool_0_4_2_0" = callPackage ({ mkDerivation, base, resource-pool, transformers, unliftio-core }: mkDerivation { @@ -306059,7 +304295,6 @@ self: { ]; description = "Data.Pool generalized to MonadUnliftIO."; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "unliftio-streams" = callPackage @@ -306067,8 +304302,8 @@ self: { }: mkDerivation { pname = "unliftio-streams"; - version = "0.1.1.1"; - sha256 = "1r9yn710nwx4h2ky2pmlhmap5ydx4fhcaq119dq7cysnygzi5q2n"; + version = "0.2.0.0"; + sha256 = "06xgkv78p7c3hikng0v84gg1ifhh4sbbza93njs8farwcn980d9n"; libraryHaskellDepends = [ base bytestring io-streams text unliftio-core ]; @@ -306277,6 +304512,8 @@ 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 @@ -306521,9 +304758,8 @@ self: { }) {}; "uom-plugin" = callPackage - ({ mkDerivation, base, containers, deepseq, doctest, ghc - , ghc-tcplugin-api, QuickCheck, tasty, tasty-hunit - , template-haskell, units-parser + ({ mkDerivation, base, containers, deepseq, ghc, ghc-tcplugin-api + , tasty, tasty-hunit, template-haskell, units-parser }: mkDerivation { pname = "uom-plugin"; @@ -306533,10 +304769,7 @@ self: { base containers deepseq ghc ghc-tcplugin-api template-haskell units-parser ]; - testHaskellDepends = [ - base containers deepseq doctest ghc ghc-tcplugin-api QuickCheck - tasty tasty-hunit template-haskell units-parser - ]; + testHaskellDepends = [ base tasty tasty-hunit ]; description = "Units of measure as a GHC type-checker plugin"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -306643,6 +304876,23 @@ self: { mainProgram = "update-repos"; }) {}; + "updo" = callPackage + ({ mkDerivation, aeson, base, dhall, filepath, text, turtle + , utf8-string + }: + mkDerivation { + pname = "updo"; + version = "1.0.0"; + sha256 = "1dhbp9jsf3wchdc4vyzf03lp9jwxlrbqy3kpr4mysvlc0k1gfyr0"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + aeson base dhall filepath text turtle utf8-string + ]; + description = "A style of maintaining and upgrading Haskell projects"; + license = lib.licenses.mpl20; + }) {}; + "uploadcare" = callPackage ({ mkDerivation, aeson, attoparsec, base, bytestring, cryptohash , hex, http-conduit, http-types, old-locale, time @@ -306732,6 +304982,8 @@ 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 @@ -307139,6 +305391,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 @@ -307355,6 +305609,8 @@ self: { ]; description = "The UserId type and useful instances for web development"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "users" = callPackage @@ -308285,6 +306541,8 @@ self: { ]; description = "Runs commands on remote machines using ssh"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "valid" = callPackage @@ -308381,8 +306639,8 @@ self: { pname = "validated-literals"; version = "0.3.1"; sha256 = "0s6ag8wm19qzfhxpz686nsmvrf3lhbq1g5fcck6d97lij559xlvg"; - revision = "2"; - editedCabalFile = "0qax4hp3wj779xzvwriq0js9x1i2daafjygmg4b4zscvshkb6ci6"; + revision = "3"; + editedCabalFile = "15hfvrd24lqmnklyh2w7lv8l8a0xyqqn4b2sfnlifch4ml0kr1qf"; libraryHaskellDepends = [ base template-haskell th-compat ]; testHaskellDepends = [ base bytestring deepseq tasty tasty-hunit tasty-travis @@ -308412,8 +306670,8 @@ self: { }: mkDerivation { pname = "validation"; - version = "1.1.2"; - sha256 = "15hhz2kj6h9zv568bvq79ymck3s3b89fpkasdavbwvyhfyjm5k8x"; + version = "1.1.3"; + sha256 = "159pvlzs5caabay4irs6dgrxpyhrcakyxqv7fvhs8cnarlafjhbv"; libraryHaskellDepends = [ assoc base bifunctors deepseq lens semigroupoids semigroups ]; @@ -308502,6 +306760,8 @@ self: { testHaskellDepends = [ base containers doctest Glob hspec text ]; description = "Composable validations for your Haskell data types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "validity" = callPackage @@ -308802,6 +307062,8 @@ self: { libraryHaskellDepends = [ base text ]; description = "Simple type for representing one of several media types"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "variable-media-field-dhall" = callPackage @@ -308813,6 +307075,7 @@ self: { libraryHaskellDepends = [ base dhall variable-media-field ]; description = "Dhall instances for VF"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "variable-media-field-optics" = callPackage @@ -308824,6 +307087,7 @@ self: { libraryHaskellDepends = [ base optics-th variable-media-field ]; description = "Optics for variable-media-field"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; }) {}; "variable-precision" = callPackage @@ -309217,30 +307481,6 @@ self: { }) {}; "vec" = callPackage - ({ mkDerivation, adjunctions, base, base-compat, boring, criterion - , deepseq, distributive, fin, hashable, indexed-traversable - , inspection-testing, QuickCheck, semigroupoids, tagged - , transformers, vector - }: - mkDerivation { - pname = "vec"; - version = "0.4.1"; - sha256 = "01v5zd4lak76ymlhi3zjpsy3g01vcchwx1b7cavc4rdzpdjqw58b"; - revision = "1"; - editedCabalFile = "156w28mz6d1gdp907j14v5xvj5y786h5pi4bfgvri592zwd2p46b"; - libraryHaskellDepends = [ - adjunctions base boring deepseq distributive fin hashable - indexed-traversable QuickCheck semigroupoids transformers - ]; - testHaskellDepends = [ - base base-compat fin inspection-testing tagged - ]; - benchmarkHaskellDepends = [ base criterion fin vector ]; - description = "Vec: length-indexed (sized) list"; - license = lib.licenses.bsd3; - }) {}; - - "vec_0_5" = callPackage ({ mkDerivation, adjunctions, base, base-compat, boring, criterion , deepseq, distributive, fin, hashable, indexed-traversable , inspection-testing, QuickCheck, semigroupoids, tagged @@ -309260,7 +307500,6 @@ self: { benchmarkHaskellDepends = [ base criterion fin vector ]; description = "Vec: length-indexed (sized) list"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vec-lens" = callPackage @@ -309341,26 +307580,6 @@ self: { }) {}; "vector" = callPackage - ({ mkDerivation, base, base-orphans, deepseq, doctest, ghc-prim - , HUnit, primitive, QuickCheck, random, tasty, tasty-hunit - , tasty-quickcheck, template-haskell, transformers - }: - mkDerivation { - pname = "vector"; - version = "0.12.3.1"; - sha256 = "0dczbcisxhhix859dng5zhxkn3xvlnllsq60apqzvmyl5g056jpv"; - revision = "4"; - editedCabalFile = "19r3pz08wqrhkz2sx41jm91d914yk4sndrrvls9wgdvi50qiy51r"; - libraryHaskellDepends = [ base deepseq ghc-prim primitive ]; - testHaskellDepends = [ - base base-orphans doctest HUnit primitive QuickCheck random tasty - tasty-hunit tasty-quickcheck template-haskell transformers - ]; - description = "Efficient Arrays"; - license = lib.licenses.bsd3; - }) {}; - - "vector_0_13_0_0" = callPackage ({ mkDerivation, base, base-orphans, deepseq, doctest, HUnit , primitive, QuickCheck, random, tasty, tasty-bench, tasty-hunit , tasty-inspection-testing, tasty-quickcheck, template-haskell @@ -309381,29 +307600,9 @@ self: { benchmarkHaskellDepends = [ base random tasty tasty-bench ]; description = "Efficient Arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vector-algorithms" = callPackage - ({ mkDerivation, base, bytestring, containers, mwc-random - , primitive, QuickCheck, vector - }: - mkDerivation { - pname = "vector-algorithms"; - version = "0.8.0.4"; - sha256 = "0fxg6w0vh5g2vzw4alajj9ywdijfn9nyx28hbckhmwwbfxb6l5vn"; - revision = "2"; - editedCabalFile = "0i55aqh2kfswmzvkyls1vlzlg3gvh1ydhksx9w7circ8ffj6lrg0"; - libraryHaskellDepends = [ base bytestring primitive vector ]; - testHaskellDepends = [ - base bytestring containers QuickCheck vector - ]; - benchmarkHaskellDepends = [ base mwc-random vector ]; - description = "Efficient algorithms for vector arrays"; - license = lib.licenses.bsd3; - }) {}; - - "vector-algorithms_0_9_0_1" = callPackage ({ mkDerivation, base, bitvec, bytestring, containers, mwc-random , primitive, QuickCheck, vector }: @@ -309422,7 +307621,6 @@ self: { benchmarkHaskellDepends = [ base mwc-random vector ]; description = "Efficient algorithms for vector arrays"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vector-binary" = callPackage @@ -309444,8 +307642,8 @@ self: { pname = "vector-binary-instances"; version = "0.2.5.2"; sha256 = "0kgmlb4rf89b18d348cf2k06xfhdpamhmvq7iz5pab5014hknbmp"; - revision = "3"; - editedCabalFile = "0av0k2gn90mf5ai74575bd368x73ljnr7xlkwsqmrs6zdzkw0i83"; + revision = "5"; + editedCabalFile = "1svw25aid1vby7288b36d2mbqcvmggfr3ndv8ymj2y2jm72z5a4v"; libraryHaskellDepends = [ base binary vector ]; testHaskellDepends = [ base binary tasty tasty-quickcheck vector ]; benchmarkHaskellDepends = [ @@ -309531,6 +307729,8 @@ self: { testHaskellDepends = [ base hedgehog hedgehog-classes ]; description = "circular vectors"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-clock" = callPackage @@ -309746,9 +307946,9 @@ self: { "vector-quicksort" = callPackage ({ mkDerivation, atomic-counter, base, bytestring, containers - , deepseq, parallel, primitive, QuickCheck, random, stm, tasty - , tasty-bench, tasty-quickcheck, text, text-builder-linear, vector - , vector-algorithms + , deepseq, parallel, primitive, QuickCheck, random, stm + , system-cxx-std-lib, tasty, tasty-bench, tasty-quickcheck, text + , text-builder-linear, vector, vector-algorithms }: mkDerivation { pname = "vector-quicksort"; @@ -309756,7 +307956,9 @@ self: { sha256 = "1s8azyaa73zys31whi2m6l0mnyy8hdw8hzsdpd5h0j3d78ywykkf"; revision = "1"; editedCabalFile = "18h7lflrp2d80cjzdqwjykpl95b3ng9bcrb9gq5qnab652fgyr8j"; - libraryHaskellDepends = [ base parallel primitive stm vector ]; + libraryHaskellDepends = [ + base parallel primitive stm system-cxx-std-lib vector + ]; testHaskellDepends = [ base containers QuickCheck tasty tasty-quickcheck vector ]; @@ -309820,6 +308022,8 @@ self: { libraryHaskellDepends = [ base random vector ]; description = "Algorithms for vector shuffling"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "vector-sized" = callPackage @@ -309831,8 +308035,8 @@ self: { pname = "vector-sized"; version = "1.5.0"; sha256 = "13h4qck1697iswd9f8w17fpjc6yhl2pgrvay7pb22j2h3mgaxpjl"; - revision = "1"; - editedCabalFile = "0y088b8fdhjrghi203n11ip4x2j4632c8rz6a5hx8azmdz2giiph"; + revision = "2"; + editedCabalFile = "1xck60sdci3vw39jp6qpbljhv06v43ih8bvxh6p40bwb6mxzn2wh"; libraryHaskellDepends = [ adjunctions base binary comonad deepseq distributive finite-typelits hashable indexed-list-literals primitive vector @@ -310051,7 +308255,9 @@ self: { testHaskellDepends = [ base Cabal filepath hspec text ]; description = "Automatically add files to exposed-modules and other-modules"; license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; mainProgram = "velma"; + broken = true; }) {}; "venzone" = callPackage @@ -310326,26 +308532,6 @@ self: { }) {}; "versions" = callPackage - ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens - , parser-combinators, QuickCheck, tasty, tasty-hunit - , tasty-quickcheck, text - }: - mkDerivation { - pname = "versions"; - version = "5.0.5"; - sha256 = "01kn3ilizzm5n05nz0qry1vjb6bj8dzinyqn3mbshds298acn70c"; - libraryHaskellDepends = [ - base deepseq hashable megaparsec parser-combinators text - ]; - testHaskellDepends = [ - base megaparsec microlens QuickCheck tasty tasty-hunit - tasty-quickcheck text - ]; - description = "Types and parsers for software version numbers"; - license = lib.licenses.bsd3; - }) {}; - - "versions_6_0_1" = callPackage ({ mkDerivation, base, deepseq, hashable, megaparsec, microlens , parser-combinators, tasty, tasty-hunit, text }: @@ -310361,7 +308547,6 @@ self: { ]; description = "Types and parsers for software version numbers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vessel" = callPackage @@ -310377,6 +308562,8 @@ self: { pname = "vessel"; version = "0.3.0.0"; sha256 = "1vqbrz8g9r43q6rqall6xhw6f4c56fj6lwp6cz0758fr7n4n3mqa"; + revision = "1"; + editedCabalFile = "1gngb4zc5169ybq9v8sm37fwn4f5mnyjql3n7l2iyhcp3d827xnx"; libraryHaskellDepends = [ aeson aeson-gadt-th base base-orphans bifunctors commutative-semigroups constraints constraints-extras containers @@ -311477,41 +309664,6 @@ self: { }) {}; "vty" = callPackage - ({ mkDerivation, ansi-terminal, base, binary, blaze-builder - , bytestring, Cabal, containers, deepseq, directory, filepath - , hashable, HUnit, microlens, microlens-mtl, microlens-th, mtl - , parallel, parsec, QuickCheck, quickcheck-assertions, random - , smallcheck, stm, string-qq, terminfo, test-framework - , test-framework-hunit, test-framework-smallcheck, text - , transformers, unix, utf8-string, vector - }: - mkDerivation { - pname = "vty"; - version = "5.37"; - sha256 = "1w6dc25npvlaflxcyzdssnymgi7x03zkwg7swyjw6cjjfdmkgqb7"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - ansi-terminal base binary blaze-builder bytestring containers - deepseq directory filepath hashable microlens microlens-mtl - microlens-th mtl parallel parsec stm terminfo text transformers - unix utf8-string vector - ]; - executableHaskellDepends = [ - base containers directory filepath microlens microlens-mtl mtl - ]; - testHaskellDepends = [ - base blaze-builder bytestring Cabal containers deepseq HUnit - microlens microlens-mtl mtl QuickCheck quickcheck-assertions random - smallcheck stm string-qq terminfo test-framework - test-framework-hunit test-framework-smallcheck text unix - utf8-string vector - ]; - description = "A simple terminal UI library"; - license = lib.licenses.bsd3; - }) {}; - - "vty_5_38" = callPackage ({ mkDerivation, ansi-terminal, base, binary, blaze-builder , bytestring, containers, deepseq, directory, filepath, microlens , microlens-mtl, microlens-th, mtl, parsec, stm, terminfo, text @@ -311533,7 +309685,6 @@ self: { ]; description = "A simple terminal UI library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "vty-examples" = callPackage @@ -312089,8 +310240,8 @@ self: { }: mkDerivation { pname = "wai-feature-flags"; - version = "0.1.0.4"; - sha256 = "02fwha57wwjbjapkp519da2jml3921rdlna1zr7vdmrqdz6j327j"; + version = "0.1.0.6"; + sha256 = "1djmzcl6bdjdvljzjjgj3avr8cd0cbrfshj1zrhzf0829v4viq9s"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -312216,6 +310367,7 @@ self: { testToolDepends = [ tasty-discover ]; description = "Wrap WAI applications to run on AWS Lambda"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wai-handler-launch" = callPackage @@ -312835,6 +310987,37 @@ self: { broken = true; }) {}; + "wai-middleware-delegate_0_1_4_0" = callPackage + ({ mkDerivation, async, base, blaze-builder, bytestring + , bytestring-lexing, case-insensitive, conduit, conduit-extra + , crypton-connection, data-default, hspec, hspec-tmp-proc + , http-client, http-client-tls, http-types, network, random + , resourcet, streaming-commons, text, tmp-proc, vault, wai + , wai-conduit, warp, warp-tls + }: + mkDerivation { + pname = "wai-middleware-delegate"; + version = "0.1.4.0"; + sha256 = "0fx6mskb48gmnhhc35ldxl9sgd3hkcy3yb7nmqlfdgmhin9759pv"; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + async base blaze-builder bytestring case-insensitive conduit + conduit-extra data-default http-client http-types streaming-commons + text wai wai-conduit + ]; + testHaskellDepends = [ + async base blaze-builder bytestring bytestring-lexing + case-insensitive conduit conduit-extra crypton-connection + data-default hspec hspec-tmp-proc http-client http-client-tls + http-types network random resourcet text tmp-proc vault wai + wai-conduit warp warp-tls + ]; + description = "WAI middleware that delegates handling of requests"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "wai-middleware-etag" = callPackage ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash , filepath, http-date, http-types, unix-compat @@ -313073,8 +311256,8 @@ self: { pname = "wai-middleware-static"; version = "0.9.2"; sha256 = "1ynm0xcr3pj5bbph78p1kpyxvd0n3a0gfdbm6yb7i004ixaqf33c"; - revision = "1"; - editedCabalFile = "1zran8wpwizrwdw23a5qckmiplyk6xf2z8x4his0ipfy2zzl5ql6"; + revision = "2"; + editedCabalFile = "1dvvnfxb5p7d2rsapn826xcyy3pjd8s95sjzna55xg08dwlykr83"; libraryHaskellDepends = [ base base16-bytestring bytestring containers cryptohash-sha1 directory expiring-cache-map filepath http-types mime-types @@ -313436,31 +311619,6 @@ self: { }) {}; "wai-saml2" = callPackage - ({ mkDerivation, base, base64-bytestring, bytestring, c14n - , cryptonite, data-default-class, filepath, http-types, mtl - , pretty-show, tasty, tasty-golden, text, time, vault, wai - , wai-extra, x509, x509-store, xml-conduit - }: - mkDerivation { - pname = "wai-saml2"; - version = "0.3.0.1"; - sha256 = "1j8qldy111q36dwr53pc6jiljfwzwi77n21mglvkpq4cfkcsch92"; - libraryHaskellDepends = [ - base base64-bytestring bytestring c14n cryptonite - data-default-class http-types mtl text time vault wai wai-extra - x509 x509-store xml-conduit - ]; - testHaskellDepends = [ - base base64-bytestring bytestring c14n cryptonite - data-default-class filepath http-types mtl pretty-show tasty - tasty-golden text time vault wai wai-extra x509 x509-store - xml-conduit - ]; - description = "SAML2 assertion validation as WAI middleware"; - license = lib.licenses.mit; - }) {}; - - "wai-saml2_0_4" = callPackage ({ mkDerivation, base, base16-bytestring, base64-bytestring , bytestring, c14n, containers, cryptonite, data-default-class , filepath, http-types, mtl, network-uri, pretty-show, tasty @@ -313485,6 +311643,7 @@ self: { description = "SAML2 assertion validation as WAI middleware"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wai-secure-cookies" = callPackage @@ -313892,6 +312051,8 @@ self: { testToolDepends = [ tasty-discover ]; description = "Functions to manipulate records"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "waldo" = callPackage @@ -313989,10 +312150,8 @@ self: { }: mkDerivation { pname = "warp"; - version = "3.3.23"; - sha256 = "0y1r7czq5zrgklqrx1b9pmxn5lhmf7zpqdjz7hfmnzsmr3vndmms"; - revision = "1"; - editedCabalFile = "04akn70kmgmw7scapks11srfy44nqj9cy03qsp6rawlzwbxwk9id"; + version = "3.3.25"; + sha256 = "1wa62inv7ai32jb88gr2vjiv1mh8gb96wc521y6mv2w967q1hzga"; libraryHaskellDepends = [ array auto-update base bsb-http-chunked bytestring case-insensitive containers ghc-prim hashable http-date http-types http2 iproute @@ -314015,7 +312174,7 @@ self: { license = lib.licenses.mit; }) {}; - "warp_3_3_27" = callPackage + "warp_3_3_28" = callPackage ({ mkDerivation, array, auto-update, base, bsb-http-chunked , bytestring, case-insensitive, containers, crypton-x509, directory , gauge, ghc-prim, hashable, hspec, hspec-discover, http-client @@ -314025,8 +312184,8 @@ self: { }: mkDerivation { pname = "warp"; - version = "3.3.27"; - sha256 = "067qxjsr9wkizv1dzpdsn48lgbrjrn35c1v4dwxv51wy48hbqzdv"; + version = "3.3.28"; + sha256 = "1apijxvh4yi4qqcw102vgkm5gyavlv1m5lgdk3a58f00qjy7qy2h"; libraryHaskellDepends = [ array auto-update base bsb-http-chunked bytestring case-insensitive containers crypton-x509 ghc-prim hashable http-date http-types @@ -314125,29 +312284,37 @@ self: { }) {}; "warp-systemd" = callPackage - ({ mkDerivation, base, network, systemd, unix, wai, warp }: + ({ mkDerivation, base, http-types, network, systemd, unix, wai + , warp + }: mkDerivation { pname = "warp-systemd"; - version = "0.2.0.0"; - sha256 = "114ipqsfvg4bx15n7mnpym8pnj668854s4vdz188awzd0n60hf8z"; + version = "0.3.0.0"; + sha256 = "1yvkg49wla7axk8vdh5c7d0pxlhyb66ka0xiqi6a3ra3zmw5xi3c"; + isLibrary = true; + isExecutable = true; libraryHaskellDepends = [ base network systemd unix wai warp ]; + executableHaskellDepends = [ base http-types wai warp ]; description = "Socket activation and other systemd integration for the Warp web server (WAI)"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; + mainProgram = "warp-systemd-example"; broken = true; }) {}; "warp-tls" = callPackage ({ mkDerivation, base, bytestring, cryptonite, data-default-class - , network, streaming-commons, tls, tls-session-manager, unliftio - , wai, warp + , network, recv, streaming-commons, tls, tls-session-manager + , unliftio, wai, warp }: mkDerivation { pname = "warp-tls"; - version = "3.3.4"; - sha256 = "00vgs9v7k0fapl05knqii9g47svf4lapb7ixkll7xr4zvmkk0r0m"; + version = "3.3.6"; + sha256 = "1davjsbfvybcd78scaqzxfwnaqmja4j7j3qbcdbb50gv1d87105f"; + revision = "1"; + editedCabalFile = "07wgs8q350caxl9ncbslhqlkm0zxpkx50qj6ljamwf9vd8ld0i5d"; libraryHaskellDepends = [ - base bytestring cryptonite data-default-class network + base bytestring cryptonite data-default-class network recv streaming-commons tls tls-session-manager unliftio wai warp ]; description = "HTTP over TLS support for Warp via the TLS package"; @@ -314237,8 +312404,8 @@ self: { ({ mkDerivation, base, mtl, time }: mkDerivation { pname = "watchdog"; - version = "0.3.1"; - sha256 = "01zhj464c1lwjgb6zijqjlrzfcrknfmf2v2b2m1pmxy94jly2ww9"; + version = "0.3.2"; + sha256 = "0wfmh9qi9zy8zzm1lh3gx7ls9g6av8skrzvgr4kb964v0mpgkv8i"; libraryHaskellDepends = [ base mtl time ]; description = "Simple control structure to re-try an action with exponential backoff"; license = lib.licenses.bsd3; @@ -314315,8 +312482,8 @@ self: { pname = "wave"; version = "0.2.0"; sha256 = "149kgwngq3qxc7gxpkqb16j669j0wpv2f3gnvfwp58yg6m4259ki"; - revision = "1"; - editedCabalFile = "19rxhnqhhv1qs35y723c15c8nifj8pakcrd09jlvg5271zg4qb0b"; + revision = "2"; + editedCabalFile = "015zqms9ypqwb2x0yf51pdy63bikqypn3g3s4ng0nnqsl4bcdya9"; enableSeparateDataOutput = true; libraryHaskellDepends = [ base bytestring cereal containers transformers @@ -314649,6 +312816,8 @@ self: { ]; description = "dynamic plugin system for web applications"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "web-push" = callPackage @@ -315121,8 +313290,8 @@ self: { }: mkDerivation { pname = "webauthn"; - version = "0.6.0.1"; - sha256 = "190pjd3mw9lkx32ybwdks1d9ppqca27h8milfxlgidbiwydzg76y"; + version = "0.7.0.0"; + sha256 = "18zhmdq53pkcg5c86fgjb7z6kql9f1bs33grgf714299vrl4dfak"; libraryHaskellDepends = [ aeson asn1-encoding asn1-parse asn1-types base base16-bytestring base64-bytestring binary bytestring cborg containers cryptonite @@ -315138,6 +313307,8 @@ self: { ]; description = "Relying party (server) implementation of the WebAuthn 2 specification"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webby" = callPackage @@ -315164,6 +313335,8 @@ self: { ]; description = "A super-simple web server framework"; license = lib.licenses.asl20; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "webcloud" = callPackage @@ -315249,29 +313422,6 @@ self: { }) {}; "webdriver" = callPackage - ({ mkDerivation, aeson, attoparsec, base, base64-bytestring - , bytestring, call-stack, data-default-class, directory - , directory-tree, exceptions, filepath, http-client, http-types - , lifted-base, monad-control, network, network-uri, scientific - , temporary, text, time, transformers, transformers-base - , unordered-containers, vector, zip-archive - }: - mkDerivation { - pname = "webdriver"; - version = "0.10.0.1"; - sha256 = "1mwdn96f5mn8zpbh0rh8f88dh4r8mrizd44hn5n0z2gnj0dipfkp"; - libraryHaskellDepends = [ - aeson attoparsec base base64-bytestring bytestring call-stack - data-default-class directory directory-tree exceptions filepath - http-client http-types lifted-base monad-control network - network-uri scientific temporary text time transformers - transformers-base unordered-containers vector zip-archive - ]; - description = "a Haskell client for the Selenium WebDriver protocol"; - license = lib.licenses.bsd3; - }) {}; - - "webdriver_0_11_0_0" = callPackage ({ mkDerivation, aeson, attoparsec, base, base64-bytestring , bytestring, call-stack, data-default-class, directory , directory-tree, exceptions, filepath, http-client, http-types @@ -315283,6 +313433,8 @@ self: { pname = "webdriver"; version = "0.11.0.0"; sha256 = "0d9j0bw6znjsgxz2rqjrpcyybrn50nyz9pj5ajmpgs0pmgx0zbc2"; + revision = "1"; + editedCabalFile = "076jg2n99fqnk5bs7q20w7wafqykz4zp97kc34jnwrl9rx6bv2nl"; libraryHaskellDepends = [ aeson attoparsec base base64-bytestring bytestring call-stack data-default-class directory directory-tree exceptions filepath @@ -315292,7 +313444,6 @@ self: { ]; description = "a Haskell client for the Selenium WebDriver protocol"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "webdriver-angular" = callPackage @@ -315545,6 +313696,7 @@ self: { ]; description = "Composable, type-safe library to build HTTP API servers"; license = lib.licenses.mpl20; + hydraPlatforms = lib.platforms.none; }) {}; "webidl" = callPackage @@ -316060,25 +314212,30 @@ self: { }) {}; "weeder" = callPackage - ({ mkDerivation, algebraic-graphs, base, bytestring, containers - , dhall, directory, filepath, generic-lens, ghc, lens, mtl - , optparse-applicative, regex-tdfa, text, transformers + ({ mkDerivation, aeson, algebraic-graphs, base, bytestring + , containers, directory, filepath, generic-lens, ghc, hspec, lens + , mtl, optparse-applicative, process, regex-tdfa, silently, text + , toml-reader, transformers }: mkDerivation { pname = "weeder"; - version = "2.5.0"; - sha256 = "17i8mmkmqf0fc1gad3r5zw3ypc31q2vwqryl5n1wbh402sycn7il"; + version = "2.6.0"; + sha256 = "1ajn23fvdv93qx0kz3dnby1s06qpkypg5ln2cb15abfic0f5aabd"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - algebraic-graphs base bytestring containers dhall directory - filepath generic-lens ghc lens mtl optparse-applicative regex-tdfa - text transformers + algebraic-graphs base bytestring containers directory filepath + generic-lens ghc lens mtl optparse-applicative regex-tdfa text + toml-reader transformers ]; executableHaskellDepends = [ base bytestring containers directory filepath ghc optparse-applicative transformers ]; + testHaskellDepends = [ + aeson algebraic-graphs base directory filepath ghc hspec process + silently text toml-reader + ]; description = "Detect dead code"; license = lib.licenses.bsd3; mainProgram = "weeder"; @@ -316151,6 +314308,23 @@ self: { license = lib.licenses.bsd3; }) {}; + "weigh_0_0_17" = callPackage + ({ mkDerivation, base, criterion-measurement, deepseq, ghc, mtl + , process, split, temporary + }: + mkDerivation { + pname = "weigh"; + version = "0.0.17"; + sha256 = "1wp8r6mpj4cqy2mx7vxpav05qks2xj8y93rhzf9qhmvdr6r8acb2"; + libraryHaskellDepends = [ + base criterion-measurement deepseq ghc mtl process split temporary + ]; + testHaskellDepends = [ base deepseq ]; + description = "Measure allocations of a Haskell functions/values"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "weighted" = callPackage ({ mkDerivation, base, mtl, semiring-num, transformers }: mkDerivation { @@ -316624,6 +314798,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Scrape WikiCFP web site"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wikipedia4epub" = callPackage @@ -316664,6 +314840,8 @@ self: { testToolDepends = [ hspec-discover ]; description = "Dynamic key binding framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "wild-bind-indicator" = callPackage @@ -316681,6 +314859,7 @@ self: { ]; description = "Graphical indicator for WildBind"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "wild-bind-task-x11" = callPackage @@ -316697,6 +314876,7 @@ 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; }) {}; "wild-bind-x11" = callPackage @@ -316718,6 +314898,7 @@ self: { testToolDepends = [ hspec-discover ]; description = "X11-specific implementation for WildBind"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "willow" = callPackage @@ -316800,6 +314981,8 @@ self: { ]; description = "OS window icon/name utilities"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "windowslive" = callPackage @@ -316869,6 +315052,7 @@ self: { ]; description = "A compact, well-typed seralisation format for Haskell values"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "winery"; }) {}; @@ -316988,25 +315172,6 @@ self: { }) {}; "witch" = callPackage - ({ mkDerivation, base, bytestring, containers, HUnit, tagged - , template-haskell, text, time, transformers - }: - mkDerivation { - pname = "witch"; - version = "1.1.6.1"; - sha256 = "1n4kckgk5v63bpjgky3dfgyayl82hlnxzwaa99pzyxrcjkpql5ay"; - libraryHaskellDepends = [ - base bytestring containers tagged template-haskell text time - ]; - testHaskellDepends = [ - base bytestring containers HUnit tagged text time transformers - ]; - description = "Convert values from one type into another"; - license = lib.licenses.mit; - maintainers = [ lib.maintainers.maralorn ]; - }) {}; - - "witch_1_2_0_2" = callPackage ({ mkDerivation, base, bytestring, containers, HUnit, tagged , template-haskell, text, time, transformers }: @@ -317022,7 +315187,6 @@ self: { ]; description = "Convert values from one type into another"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; maintainers = [ lib.maintainers.maralorn ]; }) {}; @@ -319254,8 +317418,8 @@ self: { }: mkDerivation { pname = "x86-64bit"; - version = "0.4.6.2"; - sha256 = "117r80i4xgjn9naxffgz871i7cclxjr7m0llfjkgwgqd01sqjdqi"; + version = "0.4.6.3"; + sha256 = "1x4lrjxc5n7bknzxh0s4kmbnnjxga7rc7ksanqld45ypk1nn8ss8"; libraryHaskellDepends = [ base deepseq monads-tf tardis vector ]; testHaskellDepends = [ base deepseq monads-tf QuickCheck tardis vector @@ -319431,6 +317595,7 @@ self: { ]; description = "XDG Basedir"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "xdg-desktop-entry" = callPackage @@ -319644,13 +317809,13 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; - "xhtml_3000_2_2_1" = callPackage - ({ mkDerivation, base }: + "xhtml_3000_3_0_0" = callPackage + ({ mkDerivation, base, bytestring, containers, text }: mkDerivation { pname = "xhtml"; - version = "3000.2.2.1"; - sha256 = "0939kwpinq6l4n3nyvd1gzyl7f83gymw0wzqndlgy1yc7q0nkj2w"; - libraryHaskellDepends = [ base ]; + version = "3000.3.0.0"; + sha256 = "1rf8ksk65srdmlpqzpil8r527jzjxv0agx53apl85zik4nkdm0ly"; + libraryHaskellDepends = [ base bytestring containers text ]; description = "An XHTML combinator library"; license = lib.licenses.bsd3; hydraPlatforms = lib.platforms.none; @@ -319870,8 +318035,8 @@ self: { }: mkDerivation { pname = "xlsx"; - version = "1.0.0.1"; - sha256 = "1fs2xks7wcbr0idgd50kxlb35l5xy1icvkiyxm8q8772bq2zvadl"; + version = "1.1.1"; + sha256 = "1sk2hnb71lk03q9rnldqd412j97ajji75jzx5v5hlcq4znw2cd6x"; libraryHaskellDepends = [ attoparsec base base64-bytestring binary-search bytestring conduit containers data-default deepseq dlist errors exceptions extra @@ -319891,40 +318056,6 @@ self: { license = lib.licenses.mit; }) {}; - "xlsx_1_1_0_1" = callPackage - ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search - , bytestring, conduit, containers, criterion, data-default, deepseq - , Diff, directory, dlist, errors, exceptions, extra, filepath - , groom, hexpat, lens, monad-control, mtl, network-uri, old-locale - , raw-strings-qq, safe, smallcheck, tasty, tasty-hunit - , tasty-smallcheck, text, time, transformers, transformers-base - , vector, xeno, xml-conduit, xml-types, zip, zip-archive - , zip-stream, zlib - }: - mkDerivation { - pname = "xlsx"; - version = "1.1.0.1"; - sha256 = "0av80xy6qqmsmc40h13zsdyyh9gmjj5rk07vjq5s7h1zbqxaqfwp"; - libraryHaskellDepends = [ - attoparsec base base64-bytestring binary-search bytestring conduit - containers data-default deepseq dlist errors exceptions extra - filepath hexpat lens monad-control mtl network-uri old-locale safe - text time transformers transformers-base vector xeno xml-conduit - xml-types zip zip-archive zip-stream zlib - ]; - testHaskellDepends = [ - base bytestring conduit containers deepseq Diff directory filepath - groom lens mtl raw-strings-qq smallcheck tasty tasty-hunit - tasty-smallcheck text time vector xml-conduit - ]; - benchmarkHaskellDepends = [ - base bytestring conduit criterion deepseq lens - ]; - description = "Simple and incomplete Excel file parser/writer"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - }) {}; - "xlsx-tabular" = callPackage ({ mkDerivation, aeson, base, bytestring, containers, data-default , lens, text, xlsx @@ -320019,8 +318150,8 @@ self: { }: mkDerivation { pname = "xml-conduit"; - version = "1.9.1.2"; - sha256 = "1pa8arh2s7ql61pap9599j9ll94rb4j70c11vpgqymm01gx4d6wm"; + version = "1.9.1.3"; + sha256 = "1x0vbxshka284xl07z5458v8r9i1ylr5iw8nqrmrw767caaidsfq"; setupHaskellDepends = [ base Cabal cabal-doctest ]; libraryHaskellDepends = [ attoparsec base blaze-html blaze-markup bytestring conduit @@ -320133,6 +318264,7 @@ self: { description = "Bridge between xml-conduit/html-conduit and stylist"; license = lib.licenses.mit; hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "xml-conduit-writer" = callPackage @@ -320141,8 +318273,8 @@ self: { }: mkDerivation { pname = "xml-conduit-writer"; - version = "0.1.1.2"; - sha256 = "0n5fk6sj5grcfz51psbf8h4z40hd4dk8zpk870c6ipm2s9dc1488"; + version = "0.1.1.4"; + sha256 = "1fn5g9gya9402cyabzgfjbm2dbhli86hcwwk6a2g5mm6f0sbz792"; libraryHaskellDepends = [ base containers data-default dlist mtl text xml-conduit xml-types ]; @@ -320503,6 +318635,8 @@ self: { libraryHaskellDepends = [ base 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 @@ -320736,27 +318870,6 @@ self: { }) {}; "xmlbf" = callPackage - ({ mkDerivation, base, bytestring, containers, deepseq, QuickCheck - , quickcheck-instances, selective, tasty, tasty-hunit - , tasty-quickcheck, text, transformers, unordered-containers - }: - mkDerivation { - pname = "xmlbf"; - version = "0.6.2"; - sha256 = "0kmny9nxn1sj1sk7480lqin0fmq0lgwq6yxdxpnhsig01rgfisp6"; - libraryHaskellDepends = [ - base bytestring containers deepseq selective text transformers - unordered-containers - ]; - testHaskellDepends = [ - base bytestring QuickCheck quickcheck-instances tasty tasty-hunit - tasty-quickcheck text transformers - ]; - description = "XML back and forth! Parser, renderer, ToXml, FromXml, fixpoints"; - license = lib.licenses.asl20; - }) {}; - - "xmlbf_0_7" = callPackage ({ mkDerivation, base, bytestring, containers, deepseq, exceptions , mmorph, mtl, QuickCheck, quickcheck-instances, selective, tasty , tasty-hunit, tasty-quickcheck, text, transformers @@ -320776,30 +318889,9 @@ self: { ]; description = "XML back and forth! Parser, renderer, ToXml, FromXml, fixpoints"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "xmlbf-xeno" = callPackage - ({ mkDerivation, base, bytestring, criterion, deepseq, ghc-prim - , html-entities, tasty, tasty-hunit, text, unordered-containers - , xeno, xml, xmlbf - }: - mkDerivation { - pname = "xmlbf-xeno"; - version = "0.2.1"; - sha256 = "1vdvmny9f5nxwgdpzn0qa5wghr21i69pnkhw2d1zncsgvq3kkw28"; - libraryHaskellDepends = [ - base bytestring html-entities text unordered-containers xeno xmlbf - ]; - testHaskellDepends = [ base tasty tasty-hunit xmlbf ]; - benchmarkHaskellDepends = [ - base bytestring criterion deepseq ghc-prim xml - ]; - description = "xeno backend support for the xmlbf library"; - license = lib.licenses.asl20; - }) {}; - - "xmlbf-xeno_0_2_2" = callPackage ({ mkDerivation, base, bytestring, criterion, deepseq, ghc-prim , html-entities, tasty, tasty-hunit, text, unordered-containers , xeno, xml, xmlbf @@ -320817,31 +318909,9 @@ self: { ]; description = "xeno backend support for the xmlbf library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "xmlbf-xmlhtml" = callPackage - ({ mkDerivation, base, bytestring, html-entities, QuickCheck - , quickcheck-instances, tasty, tasty-hunit, tasty-quickcheck, text - , unordered-containers, xmlbf, xmlhtml - }: - mkDerivation { - pname = "xmlbf-xmlhtml"; - version = "0.2"; - sha256 = "1h2w98jdr3r9isbl5g39gd3fxlm4vqib15grqgarhx2gj1k9vlxd"; - libraryHaskellDepends = [ - base bytestring html-entities text unordered-containers xmlbf - xmlhtml - ]; - testHaskellDepends = [ - base bytestring QuickCheck quickcheck-instances tasty tasty-hunit - tasty-quickcheck text unordered-containers xmlbf - ]; - description = "xmlhtml backend support for the xmlbf library"; - license = lib.licenses.asl20; - }) {}; - - "xmlbf-xmlhtml_0_2_2" = callPackage ({ mkDerivation, base, bytestring, html-entities, tasty , tasty-hunit, text, unordered-containers, xmlbf, xmlhtml }: @@ -320856,7 +318926,6 @@ self: { testHaskellDepends = [ base tasty tasty-hunit xmlbf ]; description = "xmlhtml backend support for the xmlbf library"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "xmlgen" = callPackage @@ -320891,6 +318960,8 @@ self: { pname = "xmlhtml"; version = "0.2.5.4"; sha256 = "11aldkcd3lcxax42f4080127hqs1k95k84h5griwq27ig8gmbxdc"; + revision = "2"; + editedCabalFile = "1mmlm2hipqgcn2x3dw6bc83z5ffnsvi9aaxkw7rjj8c8mvm760qv"; libraryHaskellDepends = [ base blaze-builder blaze-html blaze-markup bytestring bytestring-builder containers parsec text unordered-containers @@ -321124,8 +319195,8 @@ self: { ({ mkDerivation, base, dbus }: mkDerivation { pname = "xmonad-dbus"; - version = "0.1.0.1"; - sha256 = "15sqfk4y4arrv0bjzkrw49z1p7k3fqkn4w8pak2j7rki3915iyd4"; + version = "0.1.0.2"; + sha256 = "0xjg0kmny6snyf9c1f86qg1fqjifdg9cvrbqywlfp6yl8cj0z1gn"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base dbus ]; @@ -321329,8 +319400,8 @@ self: { pname = "xor"; version = "0.0.1.1"; sha256 = "05jwfrg4cm27ldj3dbl0y144njhiha9yiypirbhsg6lc1b36s3kh"; - revision = "2"; - editedCabalFile = "02y2587racvd9ppmllivzzn6zvdm051i6sc795lshvdq24ivvh9q"; + revision = "3"; + editedCabalFile = "17al5ilxr2bqkv565jsv38frqvkxzn642m3j1j80zjmmw762a7sa"; libraryHaskellDepends = [ base bytestring ghc-byteorder ]; testHaskellDepends = [ base bytestring ghc-byteorder QuickCheck tasty tasty-hunit @@ -321343,6 +319414,27 @@ self: { license = lib.licenses.gpl2Plus; }) {}; + "xor_0_0_1_2" = callPackage + ({ mkDerivation, base, bytestring, criterion, ghc-byteorder + , QuickCheck, tasty, tasty-hunit, tasty-quickcheck + }: + mkDerivation { + pname = "xor"; + version = "0.0.1.2"; + sha256 = "0c0a1zg0kwp3jdlgw6y1l6qp00680khxa3sizx5wafdv09rwmrxc"; + libraryHaskellDepends = [ base bytestring ghc-byteorder ]; + testHaskellDepends = [ + base bytestring ghc-byteorder QuickCheck tasty tasty-hunit + tasty-quickcheck + ]; + benchmarkHaskellDepends = [ + base bytestring criterion ghc-byteorder + ]; + description = "Efficient XOR masking"; + license = lib.licenses.gpl2Plus; + hydraPlatforms = lib.platforms.none; + }) {}; + "xorshift" = callPackage ({ mkDerivation, base, random, time }: mkDerivation { @@ -322207,8 +320299,10 @@ self: { }: mkDerivation { pname = "yaml"; - version = "0.11.11.1"; - sha256 = "0j7xa3bgznaj35x3x184c0dy6hjflxkdwp3iprfnhmz2ds2dr790"; + version = "0.11.11.2"; + sha256 = "0bywv5q9a9yc8zxn4si5kp9gbfjrx8ham2n52d2ggzmhwlz94x7f"; + revision = "2"; + editedCabalFile = "13gq30d720vaw4slwd14pi0pg116kazyjzxw1pjnhc7vw1cih2kg"; configureFlags = [ "-fsystem-libyaml" ]; isLibrary = true; isExecutable = true; @@ -322379,10 +320473,8 @@ self: { }: mkDerivation { pname = "yaml-streamly"; - version = "0.12.2"; - sha256 = "0bjagj6bg884xchx8dkrhqikjmwqzpb8hkjlxvbxnsmsmwnc22cx"; - revision = "1"; - editedCabalFile = "1b600ki3w67xi9jfbmrfzf9q3d3wz1dc0hgl9lyq6vjfm6ngdrg2"; + version = "0.12.4"; + sha256 = "06cr9qqxxck6qgdc0lizjlkzm9j0mhyj4p64wymhkwd70dyhlfmz"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -322402,6 +320494,7 @@ self: { ]; description = "Support for parsing and rendering YAML documents"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yaml-union" = callPackage @@ -322434,34 +320527,6 @@ self: { }) {}; "yaml-unscrambler" = callPackage - ({ mkDerivation, acc, attoparsec, attoparsec-data, attoparsec-time - , base, base64-bytestring, bytestring, conduit, containers, foldl - , hashable, libyaml, mtl, neat-interpolation, QuickCheck - , quickcheck-instances, rerebase, scientific, selective, tasty - , tasty-hunit, tasty-quickcheck, text, text-builder-dev, time - , transformers, unordered-containers, uuid, vector, yaml - }: - mkDerivation { - pname = "yaml-unscrambler"; - version = "0.1.0.13"; - sha256 = "0c7cnxlx01xjr992z0150dl1lnlyj2gwrqza7yhgmn4m7wg6r5z1"; - libraryHaskellDepends = [ - acc attoparsec attoparsec-data attoparsec-time base - base64-bytestring bytestring conduit containers foldl hashable - libyaml mtl scientific selective text text-builder-dev time - transformers unordered-containers uuid vector yaml - ]; - testHaskellDepends = [ - foldl neat-interpolation QuickCheck quickcheck-instances rerebase - tasty tasty-hunit tasty-quickcheck - ]; - description = "Flexible declarative YAML parsing toolkit"; - license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "yaml-unscrambler_0_1_0_16" = callPackage ({ mkDerivation, acc, attoparsec, attoparsec-data, attoparsec-time , base, base64-bytestring, bytestring, conduit, containers, foldl , hashable, libyaml, mtl, neat-interpolation, quickcheck-instances @@ -322471,8 +320536,8 @@ self: { }: mkDerivation { pname = "yaml-unscrambler"; - version = "0.1.0.16"; - sha256 = "06swbd8zi2ykjkxyd6vqza028wqdl1w0rv5wh87pm6p95rklwbgw"; + version = "0.1.0.17"; + sha256 = "0bk0h65fwlg96q5vzmf07gr68wrsd06xrdxi9s7irvzyzlk0zh7q"; libraryHaskellDepends = [ acc attoparsec attoparsec-data attoparsec-time base base64-bytestring bytestring conduit containers foldl hashable @@ -322860,8 +320925,8 @@ self: { pname = "yasi"; version = "0.2.0.1"; sha256 = "0j5g5h40qvz2rinka7mrb8nc7dzhnprdfpjmzc4pdlx1w8fzw8xy"; - revision = "2"; - editedCabalFile = "00jc6fgv0r2l91949d9ry094fn45v19kn301hfap5i4n4wks1kmz"; + revision = "3"; + editedCabalFile = "10zrj93hwsy7q0w239m3j65fi96cjiabgcl18w922p2abl65a9kb"; libraryHaskellDepends = [ base ghc-hs-meta template-haskell text text-display ]; @@ -323225,6 +321290,7 @@ self: { ]; description = "Alert messages for the Yesod framework"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; }) {}; "yesod-angular" = callPackage @@ -323949,8 +322015,8 @@ self: { }: mkDerivation { pname = "yesod-core"; - version = "1.6.24.2"; - sha256 = "0cql4gk83ya0lyv0nyrp387nljpab4dwwy288rzp8klq9z5r2a7j"; + version = "1.6.24.3"; + sha256 = "035162bdcrjf2fs2whrhagh9jbclqnlzgp8ixxzi3712gm6dfkn5"; libraryHaskellDepends = [ aeson auto-update base blaze-html blaze-markup bytestring case-insensitive cereal clientsession conduit conduit-extra @@ -325198,6 +323264,33 @@ self: { broken = true; }) {}; + "yesod-static-streamly" = callPackage + ({ mkDerivation, base, base64-bytestring, bytestring, containers + , cryptonite, cryptonite-conduit, data-default, directory, filepath + , hspec, memory, monad-control, mtl, QuickCheck, streamly + , streamly-bytestring, streamly-core, template-haskell, text + , unix-compat, wai-app-static, yesod-core, yesod-static + }: + mkDerivation { + pname = "yesod-static-streamly"; + version = "0.1.5.3"; + sha256 = "1sa9h06wz23gpswn323mwpp93px945pig4wmh7xrbgznn2grdsvf"; + libraryHaskellDepends = [ + base base64-bytestring bytestring containers cryptonite + data-default directory filepath memory monad-control mtl streamly + streamly-bytestring streamly-core template-haskell text unix-compat + wai-app-static yesod-core yesod-static + ]; + testHaskellDepends = [ + base bytestring cryptonite cryptonite-conduit hspec memory + QuickCheck yesod-static + ]; + description = "A streamly-based library providing performance-focused alternatives for functionality found in yesod-static"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "yesod-table" = callPackage ({ mkDerivation, base, bytestring, containers, contravariant , semigroups, text, yesod-core @@ -325413,8 +323506,8 @@ self: { }: mkDerivation { pname = "yet-another-logger"; - version = "0.4.1"; - sha256 = "1p465nvysvchq97b5iak3m5avxslq8igjb7qkib5bwb08zc7cf8i"; + version = "0.4.2"; + sha256 = "0z5f21pa8jlgiilf51198cchm1nhv64z88vd9i3qicccl09d16ka"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -326135,8 +324228,8 @@ self: { pname = "youtube"; version = "0.2.1.1"; sha256 = "098fhkyw70sxb58bj9hbshg12j57s23qrv9r1r7m13rxbxw6lf9f"; - revision = "1"; - editedCabalFile = "0kxdxz4802fbbmj2p8wkf2wpqf2yazqz20yqnqn26pm248nvnavb"; + revision = "2"; + editedCabalFile = "1q7vl5jxzs4m1dnw2ba9pbsssdjzssb2faj7987p4hvdwqp56gwp"; isLibrary = false; isExecutable = true; enableSeparateDataOutput = true; @@ -326518,6 +324611,8 @@ self: { libraryToolDepends = [ c2hs ]; description = "zbar bindings in Haskell"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {inherit (pkgs) zbar;}; "zcache" = callPackage @@ -326534,40 +324629,6 @@ self: { }) {}; "zenacy-html" = callPackage - ({ mkDerivation, base, bytestring, containers, criterion - , data-default, dlist, extra, HUnit, mtl, pretty-show - , raw-strings-qq, safe, safe-exceptions, test-framework - , test-framework-hunit, text, transformers, vector, word8 - }: - mkDerivation { - pname = "zenacy-html"; - version = "2.0.7"; - sha256 = "1468haqjgmnh6drf5cfk42v0x80pr3a9asap8l6m1l4pwy531wkh"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring containers data-default dlist extra mtl pretty-show - safe safe-exceptions text transformers vector word8 - ]; - executableHaskellDepends = [ - base bytestring containers data-default dlist extra pretty-show - text vector - ]; - testHaskellDepends = [ - base bytestring containers data-default dlist extra HUnit mtl - pretty-show raw-strings-qq test-framework test-framework-hunit text - transformers - ]; - benchmarkHaskellDepends = [ - base bytestring containers criterion data-default dlist pretty-show - raw-strings-qq text - ]; - description = "A standard compliant HTML parsing library"; - license = lib.licenses.mit; - mainProgram = "zenacy-html-exe"; - }) {}; - - "zenacy-html_2_1_0" = callPackage ({ mkDerivation, base, bytestring, containers, criterion , data-default, dlist, extra, HUnit, mtl, pretty-show , raw-strings-qq, safe, safe-exceptions, test-framework @@ -326598,7 +324659,6 @@ self: { ]; description = "A standard compliant HTML parsing library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; mainProgram = "zenacy-html-exe"; }) {}; @@ -327031,17 +325091,17 @@ self: { }) {}; "zeugma" = callPackage - ({ mkDerivation, chronos, hedgehog, incipit, polysemy + ({ mkDerivation, base, chronos, hedgehog, incipit, polysemy , polysemy-chronos, polysemy-test, tasty, tasty-expected-failure - , tasty-hedgehog, unix + , tasty-hedgehog }: mkDerivation { pname = "zeugma"; - version = "0.7.0.0"; - sha256 = "1przsd9f0bhjygyczdlclpvw62a4hz1vq721fh2gq0ic8r3vs602"; + version = "0.8.1.0"; + sha256 = "0cgfz01cjdnj04i33rh62gzmdhl9x2f2hbr3nry8avvkl657spd3"; libraryHaskellDepends = [ - chronos hedgehog incipit polysemy polysemy-chronos polysemy-test - tasty tasty-expected-failure tasty-hedgehog unix + base chronos hedgehog incipit polysemy polysemy-chronos + polysemy-test tasty tasty-expected-failure tasty-hedgehog ]; description = "Polysemy effects for testing"; license = "BSD-2-Clause-Patent"; @@ -327261,37 +325321,6 @@ self: { }) {}; "zip" = callPackage - ({ mkDerivation, base, bytestring, bzlib-conduit, case-insensitive - , cereal, conduit, conduit-extra, conduit-zstd, containers, digest - , directory, dlist, exceptions, filepath, hspec, monad-control, mtl - , QuickCheck, resourcet, temporary, text, time, transformers - , transformers-base, unix - }: - mkDerivation { - pname = "zip"; - version = "1.7.2"; - sha256 = "1c5pr3hv11dpn4ybd4742qkpqmvb9l3l7xmzlsf65wm2p8071dvj"; - revision = "3"; - editedCabalFile = "0q72y8qsz1y01rlmi3chdb0p06qng7ffzv0ylmiqqn36f9qjl405"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base bytestring bzlib-conduit case-insensitive cereal conduit - conduit-extra conduit-zstd containers digest directory dlist - exceptions filepath monad-control mtl resourcet text time - transformers transformers-base unix - ]; - executableHaskellDepends = [ base filepath ]; - testHaskellDepends = [ - base bytestring conduit containers directory dlist exceptions - filepath hspec QuickCheck temporary text time transformers - ]; - description = "Operations on zip archives"; - license = lib.licenses.bsd3; - mainProgram = "haskell-zip-app"; - }) {}; - - "zip_2_0_0" = callPackage ({ mkDerivation, base, bytestring, bzlib-conduit, case-insensitive , cereal, conduit, conduit-extra, conduit-zstd, containers, digest , directory, dlist, exceptions, filepath, hspec, monad-control, mtl @@ -327302,6 +325331,8 @@ self: { pname = "zip"; version = "2.0.0"; sha256 = "1j3gwhgcn2j2jsdg4dw7a5y1pw0n273zkfk782pvzjqmccaywbdp"; + revision = "1"; + editedCabalFile = "0cfnwqd2fjlhn2y8srav9s24038amkg3svj1ngs5g1gcljv3rsk8"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -327317,7 +325348,6 @@ self: { ]; description = "Operations on zip archives"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; mainProgram = "haskell-zip-app"; }) {}; @@ -327555,8 +325585,8 @@ self: { pname = "zlib"; version = "0.6.3.0"; sha256 = "1nh4xsm3kgsg76jmkcphvy7hhslg9hx1s75mpsskhi2ksjd9ialy"; - revision = "1"; - editedCabalFile = "1z2dyphqmjb9akzqrqh8k82mfv416hqj82nz8mysidx09jgf7p4s"; + revision = "2"; + editedCabalFile = "0c8pr02ypwv42288akn3njajvda20kp4vjkbbjnzcarmq0xxjv9q"; libraryHaskellDepends = [ base bytestring ]; librarySystemDepends = [ zlib ]; testHaskellDepends = [ @@ -327594,6 +325624,8 @@ self: { ]; description = "zlib compression bindings"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "zlib-conduit" = callPackage @@ -327847,14 +325879,14 @@ self: { }) {}; "zoovisitor" = callPackage - ({ mkDerivation, async, base, exceptions, hspec, uuid, Z-Data - , zookeeper_mt + ({ mkDerivation, async, base, bytestring, exceptions, hspec, uuid + , Z-Data, zookeeper_mt }: mkDerivation { pname = "zoovisitor"; - version = "0.2.4.0"; - sha256 = "1dvd7gwqqz1qdy0zxcad7485s6nx9s93wgpfz7r0q6g7s0wmff6r"; - libraryHaskellDepends = [ base exceptions Z-Data ]; + version = "0.2.5.1"; + sha256 = "0iwc1z52q91dbpd6x2wdz8q9xi5hf7w8b1xpd68km80gnirwbca5"; + libraryHaskellDepends = [ base bytestring exceptions Z-Data ]; librarySystemDepends = [ zookeeper_mt ]; testHaskellDepends = [ async base hspec uuid Z-Data ]; description = "A haskell binding to Apache Zookeeper C library(mt) using Haskell Z project"; @@ -327998,7 +326030,9 @@ self: { ]; description = "Multi-file, colored, filtered log tailer"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; mainProgram = "ztail"; + broken = true; }) {}; "ztar" = callPackage @@ -328010,6 +326044,8 @@ self: { pname = "ztar"; version = "1.0.2"; sha256 = "081ip4fmkavrwhlqa8jwv4pdf40dvhfd7d4w3iqk3p9qpdnbjm3j"; + revision = "1"; + editedCabalFile = "03j3c6ngyjnf1v82m7cgink1kh0gllgp287fkh22cqsk5c26w84v"; libraryHaskellDepends = [ base bytestring deepseq directory filepath path process text unix-compat zip zlib @@ -328129,8 +326165,8 @@ self: { }: mkDerivation { pname = "zxcvbn-hs"; - version = "0.3.1"; - sha256 = "1x32gzgv56l6l14b5k3wa1nzs5b4wgm8a0vn6y49ks6pgi7bdzim"; + version = "0.3.2"; + sha256 = "12jr76vxajhqc3rksgz5b26vdcdjyc4gbz02lxv66h0i94zansq8"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ diff --git a/pkgs/development/haskell-modules/patches/hercules-ci-agent-cachix-1.6.patch b/pkgs/development/haskell-modules/patches/hercules-ci-agent-cachix-1.6.patch deleted file mode 100644 index 71145a3a3e4a..000000000000 --- a/pkgs/development/haskell-modules/patches/hercules-ci-agent-cachix-1.6.patch +++ /dev/null @@ -1,32 +0,0 @@ -diff --git a/hercules-ci-agent/hercules-ci-agent/Hercules/Agent/Cachix.hs b/hercules-ci-agent/hercules-ci-agent/Hercules/Agent/Cachix.hs -index 849d9bc..972bc90 100644 ---- hercules-ci-agent/hercules-ci-agent/Hercules/Agent/Cachix.hs -+++ hercules-ci-agent/hercules-ci-agent/Hercules/Agent/Cachix.hs -@@ -17,6 +17,7 @@ import Hercules.Agent.Log - import Hercules.CNix.Store (StorePath) - import Hercules.Error - import qualified Hercules.Formats.CachixCache as CachixCache -+import qualified Data.Conduit as Conduit - import Protolude - - push :: Text -> [StorePath] -> Int -> App () -@@ -36,6 +37,9 @@ push cache paths workers = withNamedContext "cache" cache $ do - Cachix.Push.PushParams - { pushParamsName = Agent.Cachix.pushCacheName pushCache, - pushParamsSecret = Agent.Cachix.pushCacheSecret pushCache, -+#if MIN_VERSION_cachix(1,6,0) -+ pushOnClosureAttempt = \_ missing -> return missing, -+#endif - pushParamsStore = nixStore, - pushParamsClientEnv = clientEnv, - pushParamsStrategy = \storePath -> -@@ -59,6 +63,9 @@ push cache paths workers = withNamedContext "cache" cache $ do - compressionLevel = 2, - #else - withXzipCompressor = Cachix.Push.defaultWithXzipCompressor, -+#endif -+#if MIN_VERSION_cachix(1,6,0) -+ onUncompressedNARStream = \_ _ -> Conduit.awaitForever Conduit.yield, - #endif - omitDeriver = False - } diff --git a/pkgs/development/haskell-modules/patches/hnix-compat-for-ghc-9.4.patch b/pkgs/development/haskell-modules/patches/hnix-compat-for-ghc-9.4.patch new file mode 100644 index 000000000000..c7322dfa3139 --- /dev/null +++ b/pkgs/development/haskell-modules/patches/hnix-compat-for-ghc-9.4.patch @@ -0,0 +1,79 @@ +From daae423d339e820e3fe8c720bd568cc49eae3fde Mon Sep 17 00:00:00 2001 +From: Rodney Lorrimar +Date: Tue, 25 Jul 2023 16:46:36 +0800 +Subject: [PATCH] GHC 9.4 compatibility + +This is commit b89eed9 from haskell-nix/hnix master branch, +backported to 0.16. + +The patch should be removed once hnix-0.17 is released. + +--- + src/Nix/Fresh.hs | 2 +- + src/Nix/Lint.hs | 2 +- + src/Nix/Utils.hs | 2 +- + src/Nix/Value.hs | 2 +- + 4 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/src/Nix/Fresh.hs b/src/Nix/Fresh.hs +index fdd20c4a..4b55de4e 100644 +--- a/src/Nix/Fresh.hs ++++ b/src/Nix/Fresh.hs +@@ -14,7 +14,7 @@ import Control.Monad.Catch ( MonadCatch + , MonadMask + , MonadThrow + ) +-import Control.Monad.Except ( MonadFix ) ++import Control.Monad.Fix ( MonadFix ) + import Control.Monad.Ref ( MonadAtomicRef(..) + , MonadRef(Ref) + ) +diff --git a/src/Nix/Lint.hs b/src/Nix/Lint.hs +index 2c207c91..3da8c298 100644 +--- a/src/Nix/Lint.hs ++++ b/src/Nix/Lint.hs +@@ -498,7 +498,7 @@ instance MonadThrow (Lint s) where + throwM e = Lint $ ReaderT $ const (throw e) + + instance MonadCatch (Lint s) where +- catch _m _h = Lint $ ReaderT $ const (fail "Cannot catch in 'Lint s'") ++ catch _m _h = Lint $ ReaderT $ const (error "Cannot catch in 'Lint s'") + + runLintM :: Options -> Lint s a -> ST s a + runLintM opts action = +diff --git a/src/Nix/Utils.hs b/src/Nix/Utils.hs +index 8f53b3a7..af370c21 100644 +--- a/src/Nix/Utils.hs ++++ b/src/Nix/Utils.hs +@@ -67,6 +67,7 @@ import Relude hiding ( pass + import Data.Binary ( Binary ) + import Data.Data ( Data ) + import Codec.Serialise ( Serialise ) ++import Control.Monad ( foldM ) + import Control.Monad.Fix ( MonadFix(..) ) + import Control.Monad.Free ( Free(..) ) + import Control.Monad.Trans.Control ( MonadTransControl(..) ) +@@ -84,7 +85,6 @@ import Lens.Family2.Stock ( _1 + , _2 + ) + import qualified System.FilePath as FilePath +-import Control.Monad.List (foldM) + + #if ENABLE_TRACING + import qualified Relude.Debug as X +diff --git a/src/Nix/Value.hs b/src/Nix/Value.hs +index aafdc25a..28b9508c 100644 +--- a/src/Nix/Value.hs ++++ b/src/Nix/Value.hs +@@ -554,7 +554,7 @@ liftNValue + => (forall x . u m x -> m x) + -> NValue t f m + -> NValue t f (u m) +-liftNValue = (`hoistNValue` lift) ++liftNValue f = hoistNValue f lift + + + -- *** MonadTransUnlift +-- +2.40.1 + diff --git a/pkgs/development/libraries/pcre2/default.nix b/pkgs/development/libraries/pcre2/default.nix index 82fc33670bc5..a3ddff888e79 100644 --- a/pkgs/development/libraries/pcre2/default.nix +++ b/pkgs/development/libraries/pcre2/default.nix @@ -34,5 +34,11 @@ stdenv.mkDerivation rec { license = licenses.bsd3; maintainers = with maintainers; [ ttuegel ]; platforms = platforms.all; + pkgConfigModules = [ + "libpcre2-posix" + "libpcre2-8" + "libpcre2-16" + "libpcre2-32" + ]; }; } diff --git a/pkgs/development/tools/haskell/hadrian/default.nix b/pkgs/development/tools/haskell/hadrian/default.nix index 5911c34982b0..1801d63cf8b9 100644 --- a/pkgs/development/tools/haskell/hadrian/default.nix +++ b/pkgs/development/tools/haskell/hadrian/default.nix @@ -4,6 +4,10 @@ , extra, filepath, lib, mtl, parsec, shake, text, transformers , unordered-containers, cryptohash-sha256, base16-bytestring , userSettings ? null +# Whether to pass --hyperlinked-source to haddock or not. This is a custom +# workaround as we wait for this to be configurable via userSettings or similar. +# https://gitlab.haskell.org/ghc/ghc/-/issues/23625 +, enableHyperlinkedSource ? true , writeText }: @@ -18,6 +22,9 @@ mkDerivation { postUnpack = '' sourceRoot="$sourceRoot/hadrian" ''; + patches = lib.optionals (!enableHyperlinkedSource) [ + ./disable-hyperlinked-source.patch + ]; # Overwrite UserSettings.hs with a provided custom one postPatch = lib.optionalString (userSettings != null) '' install -m644 "${writeText "UserSettings.hs" userSettings}" src/UserSettings.hs diff --git a/pkgs/development/tools/haskell/hadrian/disable-hyperlinked-source.patch b/pkgs/development/tools/haskell/hadrian/disable-hyperlinked-source.patch new file mode 100644 index 000000000000..72010f85cddc --- /dev/null +++ b/pkgs/development/tools/haskell/hadrian/disable-hyperlinked-source.patch @@ -0,0 +1,12 @@ +diff --git a/hadrian/src/Settings/Builders/Haddock.hs b/hadrian/src/Settings/Builders/Haddock.hs +index 902b2f85e2..429a441c3b 100644 +--- a/src/Settings/Builders/Haddock.hs ++++ b/src/Settings/Builders/Haddock.hs +@@ -57,7 +57,6 @@ haddockBuilderArgs = mconcat + , arg $ "--odir=" ++ takeDirectory output + , arg $ "--dump-interface=" ++ output + , arg "--html" +- , arg "--hyperlinked-source" + , arg "--hoogle" + , arg "--quickjump" + , arg $ "--title=" ++ pkgName pkg ++ "-" ++ version diff --git a/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix b/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix index 48a473be169b..a6f287c37b3f 100644 --- a/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix +++ b/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix @@ -1,6 +1,6 @@ { lib , stdenv -, supportedGhcVersions ? [ "92" ] +, supportedGhcVersions ? [ "94" ] , dynamic ? true , haskellPackages , haskell diff --git a/pkgs/development/tools/pandoc/default.nix b/pkgs/development/tools/pandoc/default.nix index 31396f800a1e..1e9eec3f804c 100644 --- a/pkgs/development/tools/pandoc/default.nix +++ b/pkgs/development/tools/pandoc/default.nix @@ -1,7 +1,8 @@ -{ stdenv, lib, haskellPackages, fetchpatch, haskell, removeReferencesTo }: +{ stdenv, lib, haskellPackages, haskell, removeReferencesTo }: let - static = haskell.lib.compose.justStaticExecutables haskellPackages.pandoc; + # Since pandoc 3.0 the pandoc binary resides in the pandoc-cli package. + static = haskell.lib.compose.justStaticExecutables haskellPackages.pandoc-cli; in (haskell.lib.compose.overrideCabal (drv: { diff --git a/pkgs/development/tools/purescript/spago/default.nix b/pkgs/development/tools/purescript/spago/default.nix index 8006147e2dd1..bc4587816ff1 100644 --- a/pkgs/development/tools/purescript/spago/default.nix +++ b/pkgs/development/tools/purescript/spago/default.nix @@ -15,7 +15,6 @@ let haskell.packages.ghc90.spago [ haskell.lib.compose.justStaticExecutables (haskell.lib.compose.overrideCabal (oldAttrs: { - maintainers = (oldAttrs.maintainers or []) ++ [ lib.maintainers.cdepillabout ]; changelog = "https://github.com/purescript/spago/releases/tag/${oldAttrs.version}"; })) haskell.lib.compose.unmarkBroken diff --git a/pkgs/test/haskell/default.nix b/pkgs/test/haskell/default.nix index 2ecbd4caf81b..8f1f21d65b51 100644 --- a/pkgs/test/haskell/default.nix +++ b/pkgs/test/haskell/default.nix @@ -6,4 +6,5 @@ lib.recurseIntoAttrs { documentationTarball = callPackage ./documentationTarball { }; setBuildTarget = callPackage ./setBuildTarget { }; incremental = callPackage ./incremental { }; + upstreamStackHpackVersion = callPackage ./upstreamStackHpackVersion { }; } diff --git a/pkgs/test/haskell/shellFor/default.nix b/pkgs/test/haskell/shellFor/default.nix index aa06ff6e52f8..83daf079cc0f 100644 --- a/pkgs/test/haskell/shellFor/default.nix +++ b/pkgs/test/haskell/shellFor/default.nix @@ -2,7 +2,11 @@ (haskellPackages.shellFor { packages = p: [ p.constraints p.linear ]; - extraDependencies = p: { libraryHaskellDepends = [ p.releaser ]; }; + # WARNING: When updating this, make sure that the libraries passed to + # `extraDependencies` are not actually transitive dependencies of libraries in + # `packages` above. We explicitly want to test that it is possible to specify + # `extraDependencies` that are not in the closure of `packages`. + extraDependencies = p: { libraryHaskellDepends = [ p.conduit ]; }; nativeBuildInputs = [ cabal-install ]; phases = [ "unpackPhase" "buildPhase" "installPhase" ]; unpackPhase = '' @@ -18,13 +22,19 @@ mkdir -p $HOME/.cabal touch $HOME/.cabal/config - # Check extraDependencies.libraryHaskellDepends arg + # Check that the extraDependencies.libraryHaskellDepends arg is correctly + # picked up. This uses ghci to interpret a small Haskell program that uses + # a package from extraDependencies. ghci < ./stack.tar.gz + tar xf ./stack.tar.gz + + upstream_stack_version_output="$(./stack-${stack.version}-linux-x86_64-static/stack --version)" + echo "upstream \`stack --version\` output: $upstream_stack_version_output" + + nixpkgs_stack_version_output="$(stack --version)" + echo "nixpkgs \`stack --version\` output: $nixpkgs_stack_version_output" + + # Confirm that the upstream stack version is the same as the stack version + # in Nixpkgs. This check isn't strictly necessary, but it is a good sanity + # check. + + if [[ "$upstream_stack_version_output" =~ "Version "([0-9]+((\.[0-9]+)+)) ]]; then + upstream_stack_version="''${BASH_REMATCH[1]}" + + echo "parsed upstream stack version: $upstream_stack_version" + echo "stack version from nixpkgs: ${stack.version}" + + if [[ "${stack.version}" != "$upstream_stack_version" ]]; then + echo "ERROR: stack version in Nixpkgs (${stack.version}) does not match the upstream version for some reason: $upstream_stack_version" + exit 1 + fi + else + echo "ERROR: Upstream stack version cannot be found in --version output: $upstream_stack_version" + exit 1 + fi + + # Confirm that the hpack version used in the upstream stack release is the + # same as the hpack version used by the Nixpkgs stack binary. + + if [[ "$upstream_stack_version_output" =~ hpack-([0-9]+((\.[0-9]+)+)) ]]; then + upstream_hpack_version="''${BASH_REMATCH[1]}" + + echo "parsed upstream stack's hpack version: $upstream_hpack_version" + echo "Nixpkgs stack's hpack version: ${hpack.version}" + + if [[ "${hpack.version}" != "$upstream_hpack_version" ]]; then + echo "ERROR: stack's hpack version in Nixpkgs (${hpack.version}) does not match the upstream stack's hpack version: $upstream_hpack_version" + echo "The stack derivation in Nixpkgs needs to be fixed up so that it depends on hpack-$upstream_hpack_version, instead of ${hpack.name}" + exit 1 + fi + else + echo "ERROR: Upstream stack's hpack version cannot be found in --version output: $upstream_hpack_version" + exit 1 + fi + + # Output a string with a known hash. + echo "success" > $out + ''; + + testScriptHash = builtins.hashString "sha256" testScript; +in + +stdenv.mkDerivation { + + # This name is very important. + # + # The idea here is that want this derivation to be re-run everytime the + # version of stack (or the version of its hpack dependency) changes in + # Nixpkgs. We also want to re-run this derivation whenever the test script + # is changed. + # + # Nix/Hydra will re-run derivations if their name changes (even if they are a + # FOD and they have the same hash). + # + # The name of this derivation contains the stack version string, the hpack + # version string, and a hash of the test script. So Nix will know to + # re-run this version when (and only when) one of those values change. + name = "upstream-stack-hpack-version-test-${stack.name}-${hpack.name}-${testScriptHash}"; + + # This is the sha256 hash for the string "success", which is output upon this + # test succeeding. + outputHash = "sha256-gbK9TqmMjbZlVPvI12N6GmmhMPMx/rcyt1yqtMSGj9U="; + outputHashMode = "flat"; + outputHashAlgo = "sha256"; + + nativeBuildInputs = [ curl stack ]; + + impureEnvVars = lib.fetchers.proxyImpureEnvVars; + + buildCommand = '' + # Make sure curl can access HTTPS sites, like GitHub. + # + # Note that we absolutely don't want the Nix store path of the cacert + # derivation in the testScript, because we don't want to rebuild this + # derivation when only the cacert derivation changes. + export SSL_CERT_FILE="${cacert}/etc/ssl/certs/ca-bundle.crt" + '' + testScript; + + meta = with lib; { + description = "Test that the stack in Nixpkgs uses the same version of Hpack as the upstream stack release"; + maintainers = with maintainers; [ cdepillabout ]; + + # This derivation internally runs a statically-linked version of stack from + # upstream. This statically-linked version of stack is only available for + # x86_64-linux, so this test can only be run on x86_64-linux. + platforms = [ "x86_64-linux" ]; + }; +} diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index 650f370012e7..5961726e6d60 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -16048,8 +16048,8 @@ with pkgs; then haskell.packages.native-bignum.ghc96 # Prefer native-bignum to avoid linking issues with gmp else if stdenv.hostPlatform.isStatic - then haskell.packages.native-bignum.ghc92 - else haskell.packages.ghc92); + then haskell.packages.native-bignum.ghc94 + else haskell.packages.ghc94); # haskellPackages.ghc is build->host (it exposes the compiler used to build the # set, similarly to stdenv.cc), but pkgs.ghc should be host->target to be more @@ -16062,8 +16062,8 @@ with pkgs; ghc = targetPackages.haskellPackages.ghc or # Prefer native-bignum to avoid linking issues with gmp (if stdenv.targetPlatform.isStatic - then haskell.compiler.native-bignum.ghc92 - else haskell.compiler.ghc92); + then haskell.compiler.native-bignum.ghc94 + else haskell.compiler.ghc94); alex = haskell.lib.compose.justStaticExecutables haskellPackages.alex; @@ -17649,7 +17649,7 @@ with pkgs; stdenv = clangStdenv; }; - jacinda = haskell.lib.compose.justStaticExecutables haskell.packages.ghc92.jacinda; + jacinda = haskell.lib.compose.justStaticExecutables haskellPackages.jacinda; janet = callPackage ../development/interpreters/janet { }; diff --git a/pkgs/top-level/haskell-packages.nix b/pkgs/top-level/haskell-packages.nix index 42867afef83d..c57302ccaa8b 100644 --- a/pkgs/top-level/haskell-packages.nix +++ b/pkgs/top-level/haskell-packages.nix @@ -5,11 +5,8 @@ let integerSimpleExcludes = [ "ghc865Binary" "ghc8102Binary" - "ghc8102BinaryMinimal" "ghc8107Binary" - "ghc8107BinaryMinimal" "ghc924Binary" - "ghc924BinaryMinimal" "ghcjs" "ghcjs810" "integer-simple" @@ -26,6 +23,7 @@ let "ghc943" "ghc944" "ghc945" + "ghc946" "ghc94" "ghc96" "ghc962" @@ -46,6 +44,7 @@ let "ghc943" "ghc944" "ghc945" + "ghc946" "ghc96" "ghc962" "ghcHEAD" @@ -89,36 +88,20 @@ in { llvmPackages = pkgs.llvmPackages_9; }; - ghc8102BinaryMinimal = callPackage ../development/compilers/ghc/8.10.2-binary.nix { - llvmPackages = pkgs.llvmPackages_9; - minimal = true; - }; - ghc8107Binary = callPackage ../development/compilers/ghc/8.10.7-binary.nix { llvmPackages = pkgs.llvmPackages_12; }; - ghc8107BinaryMinimal = callPackage ../development/compilers/ghc/8.10.7-binary.nix { - llvmPackages = pkgs.llvmPackages_12; - minimal = true; - }; - ghc924Binary = callPackage ../development/compilers/ghc/9.2.4-binary.nix { llvmPackages = pkgs.llvmPackages_12; }; - ghc924BinaryMinimal = callPackage ../development/compilers/ghc/9.2.4-binary.nix { - llvmPackages = pkgs.llvmPackages_12; - minimal = true; - }; ghc884 = callPackage ../development/compilers/ghc/8.8.4.nix { bootPkgs = # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar # 8.10.2 is needed as using 8.10.7 is broken due to RTS-incompatibilities - if stdenv.isAarch64 then - packages.ghc8102BinaryMinimal # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them - else if stdenv.hostPlatform.isMusl then + if stdenv.hostPlatform.isAarch64 || stdenv.hostPlatform.isMusl then packages.ghc8102Binary else packages.ghc865Binary; @@ -129,12 +112,8 @@ in { ghc88 = compiler.ghc884; ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix { bootPkgs = - # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar # the oldest ghc with aarch64-darwin support is 8.10.5 - # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them - if stdenv.hostPlatform.isAarch then - packages.ghc8107BinaryMinimal - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then # to my (@a-m-joseph) knowledge there are no newer official binaries for this platform packages.ghc865Binary else @@ -150,11 +129,8 @@ in { ghc810 = compiler.ghc8107; ghc902 = callPackage ../development/compilers/ghc/9.0.2.nix { bootPkgs = - # aarch64 ghc8107Binary exceeds max output size on hydra # the oldest ghc with aarch64-darwin support is 8.10.5 - if stdenv.hostPlatform.isAarch then - packages.ghc8107BinaryMinimal - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc810 else packages.ghc8107Binary; @@ -166,10 +142,7 @@ in { ghc90 = compiler.ghc902; ghc924 = callPackage ../development/compilers/ghc/9.2.4.nix { bootPkgs = - # aarch64 ghc8107Binary exceeds max output size on hydra - if stdenv.hostPlatform.isAarch then - packages.ghc8107BinaryMinimal - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc810 else packages.ghc8107Binary; @@ -183,10 +156,7 @@ in { }; ghc925 = callPackage ../development/compilers/ghc/9.2.5.nix { bootPkgs = - # aarch64 ghc8107Binary exceeds max output size on hydra - if stdenv.hostPlatform.isAarch then - packages.ghc8107BinaryMinimal - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc810 else packages.ghc8107Binary; @@ -200,10 +170,7 @@ in { }; ghc926 = callPackage ../development/compilers/ghc/9.2.6.nix { bootPkgs = - # aarch64 ghc8107Binary exceeds max output size on hydra - if stdenv.hostPlatform.isAarch then - packages.ghc8107BinaryMinimal - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc810 else packages.ghc8107Binary; @@ -217,10 +184,7 @@ in { }; ghc927 = callPackage ../development/compilers/ghc/9.2.7.nix { bootPkgs = - # aarch64 ghc8107Binary exceeds max output size on hydra - if stdenv.hostPlatform.isAarch then - packages.ghc8107BinaryMinimal - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc810 else packages.ghc8107Binary; @@ -234,10 +198,7 @@ in { }; ghc928 = callPackage ../development/compilers/ghc/9.2.8.nix { bootPkgs = - # aarch64 ghc8107Binary exceeds max output size on hydra - if stdenv.hostPlatform.isAarch then - packages.ghc8107BinaryMinimal - else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc810 else packages.ghc8107Binary; @@ -346,7 +307,31 @@ in { buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12; llvmPackages = pkgs.llvmPackages_12; }; - ghc94 = compiler.ghc945; + ghc946 = callPackage ../development/compilers/ghc/9.4.6.nix { + bootPkgs = + # Building with 9.2 is broken due to + # https://gitlab.haskell.org/ghc/ghc/-/issues/21914 + # Use 8.10 as a workaround where possible to keep bootstrap path short. + + # On ARM text won't build with GHC 8.10.* + if stdenv.hostPlatform.isAarch then + # TODO(@sternenseemann): package bindist + packages.ghc902 + # No suitable bindists for powerpc64le + else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then + packages.ghc902 + else + packages.ghc8107Binary; + inherit (buildPackages.python3Packages) sphinx; + # Need to use apple's patched xattr until + # https://github.com/xattr/xattr/issues/44 and + # https://github.com/xattr/xattr/issues/55 are solved. + inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook; + # Support range >= 10 && < 14 + buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12; + llvmPackages = pkgs.llvmPackages_12; + }; + ghc94 = compiler.ghc946; ghc962 = callPackage ../development/compilers/ghc/9.6.2.nix { bootPkgs = # For GHC 9.2 no armv7l bindists are available. @@ -354,8 +339,6 @@ in { packages.ghc924 else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc924 - else if stdenv.isAarch64 then - packages.ghc924BinaryMinimal else packages.ghc924Binary; inherit (buildPackages.python3Packages) sphinx; @@ -375,8 +358,6 @@ in { packages.ghc924 else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then packages.ghc924 - else if stdenv.isAarch64 then - packages.ghc924BinaryMinimal else packages.ghc924Binary; inherit (buildPackages.python3Packages) sphinx; @@ -435,36 +416,18 @@ in { compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { }; packageSetConfig = bootstrapPackageSet; }; - ghc8102BinaryMinimal = callPackage ../development/haskell-modules { - buildHaskellPackages = bh.packages.ghc8102BinaryMinimal; - ghc = bh.compiler.ghc8102BinaryMinimal; - compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { }; - packageSetConfig = bootstrapPackageSet; - }; ghc8107Binary = callPackage ../development/haskell-modules { buildHaskellPackages = bh.packages.ghc8107Binary; ghc = bh.compiler.ghc8107Binary; compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { }; packageSetConfig = bootstrapPackageSet; }; - ghc8107BinaryMinimal = callPackage ../development/haskell-modules { - buildHaskellPackages = bh.packages.ghc8107BinaryMinimal; - ghc = bh.compiler.ghc8107BinaryMinimal; - compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { }; - packageSetConfig = bootstrapPackageSet; - }; ghc924Binary = callPackage ../development/haskell-modules { buildHaskellPackages = bh.packages.ghc924Binary; ghc = bh.compiler.ghc924Binary; compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { }; packageSetConfig = bootstrapPackageSet; }; - ghc924BinaryMinimal = callPackage ../development/haskell-modules { - buildHaskellPackages = bh.packages.ghc924BinaryMinimal; - ghc = bh.compiler.ghc924BinaryMinimal; - compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { }; - packageSetConfig = bootstrapPackageSet; - }; ghc884 = callPackage ../development/haskell-modules { buildHaskellPackages = bh.packages.ghc884; ghc = bh.compiler.ghc884; @@ -529,7 +492,12 @@ in { ghc = bh.compiler.ghc945; compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.4.x.nix { }; }; - ghc94 = packages.ghc945; + ghc946 = callPackage ../development/haskell-modules { + buildHaskellPackages = bh.packages.ghc946; + ghc = bh.compiler.ghc946; + compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.4.x.nix { }; + }; + ghc94 = packages.ghc946; ghc962 = callPackage ../development/haskell-modules { buildHaskellPackages = bh.packages.ghc962; ghc = bh.compiler.ghc962; diff --git a/pkgs/top-level/release-haskell.nix b/pkgs/top-level/release-haskell.nix index 6113dcdb121d..1c5615d5dbb1 100644 --- a/pkgs/top-level/release-haskell.nix +++ b/pkgs/top-level/release-haskell.nix @@ -69,6 +69,7 @@ let ghc927 ghc928 ghc945 + ghc946 ghc962 ]; @@ -480,20 +481,11 @@ let # package sets (like Cabal, jailbreak-cabal) are # working as expected. cabal-install = released; - Cabal_3_6_3_0 = released; - Cabal_3_8_1_0 = released; - Cabal-syntax_3_8_1_0 = released; Cabal_3_10_1_0 = released; Cabal-syntax_3_10_1_0 = released; - cabal2nix = lib.subtractLists [ - compilerNames.ghc962 - ] released; - cabal2nix-unstable = lib.subtractLists [ - compilerNames.ghc962 - ] released; - funcmp = lib.subtractLists [ - compilerNames.ghc962 - ] released; + cabal2nix = released; + cabal2nix-unstable = released; + funcmp = released; haskell-language-server = lib.subtractLists [ # Support ceased as of 1.9.0.0 compilerNames.ghc884 @@ -504,14 +496,13 @@ let hlint = lib.subtractLists [ compilerNames.ghc962 ] released; - hpack = lib.subtractLists [ - compilerNames.ghc962 - ] released; + hpack = released; hsdns = released; jailbreak-cabal = released; - language-nix = lib.subtractLists [ - compilerNames.ghc962 - ] released; + language-nix = released; + large-hashable = [ + compilerNames.ghc928 + ]; nix-paths = released; titlecase = released; ghc-api-compat = [ @@ -526,6 +517,14 @@ let ghc-lib = released; ghc-lib-parser = released; ghc-lib-parser-ex = released; + ghc-source-gen = [ + # Feel free to remove these as they break, + # ghc-source-gen currently doesn't support GHC 9.4 + compilerNames.ghc884 + compilerNames.ghc8107 + compilerNames.ghc902 + compilerNames.ghc928 + ]; ghc-tags = [ compilerNames.ghc8107 compilerNames.ghc902 @@ -535,7 +534,11 @@ let compilerNames.ghc927 compilerNames.ghc928 compilerNames.ghc945 + compilerNames.ghc946 + compilerNames.ghc962 ]; + hashable = released; + primitive = released; weeder = [ compilerNames.ghc8107 compilerNames.ghc902 @@ -545,6 +548,8 @@ let compilerNames.ghc927 compilerNames.ghc928 compilerNames.ghc945 + compilerNames.ghc946 + compilerNames.ghc962 ]; }) {