diff --git a/pkgs/applications/terminal-emulators/termonad/default.nix b/pkgs/applications/terminal-emulators/termonad/default.nix index 4388cbcfb441..6a1dd0bec398 100644 --- a/pkgs/applications/terminal-emulators/termonad/default.nix +++ b/pkgs/applications/terminal-emulators/termonad/default.nix @@ -1,7 +1,7 @@ -{ stdenv, ghcWithPackages, makeWrapper, packages ? (pkgSet: []) }: +{ stdenv, haskellPackages, makeWrapper, packages ? (pkgSet: []) }: let - termonadEnv = ghcWithPackages (self: [ self.termonad ] ++ packages self); + termonadEnv = haskellPackages.ghcWithPackages (self: [ self.termonad ] ++ packages self); in stdenv.mkDerivation { name = "termonad-with-packages-${termonadEnv.version}"; @@ -16,4 +16,8 @@ in stdenv.mkDerivation { # trivial derivation preferLocalBuild = true; allowSubstitutes = false; + + meta = haskellPackages.termonad.meta // { + mainProgram = "termonad"; + }; } diff --git a/pkgs/data/misc/hackage/pin.json b/pkgs/data/misc/hackage/pin.json index b00021504b4d..26b38582e992 100644 --- a/pkgs/data/misc/hackage/pin.json +++ b/pkgs/data/misc/hackage/pin.json @@ -1,6 +1,6 @@ { - "commit": "23315eb3220b0748c3aa71a9027dc39e5416ce9e", - "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/23315eb3220b0748c3aa71a9027dc39e5416ce9e.tar.gz", - "sha256": "0pgcyfb3lnl7kxpj87sbj50ljlg2l05v4kgcdwy568pcf24bh764", - "msg": "Update from Hackage at 2021-08-17T22:21:14Z" + "commit": "193a13be44c51ebfc8e991b7bb53a4065129ff4d", + "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/193a13be44c51ebfc8e991b7bb53a4065129ff4d.tar.gz", + "sha256": "08j6qx3jqcw7ydwnpjr132l2mlpq6dqvwqgm3gq0ym4kjzrbdwsd", + "msg": "Update from Hackage at 2021-08-23T13:50:03Z" } diff --git a/pkgs/development/compilers/ghc/8.10.2-binary.nix b/pkgs/development/compilers/ghc/8.10.2-binary.nix index 3ef4ebb9b98f..824794774cec 100644 --- a/pkgs/development/compilers/ghc/8.10.2-binary.nix +++ b/pkgs/development/compilers/ghc/8.10.2-binary.nix @@ -374,6 +374,6 @@ stdenv.mkDerivation rec { # `pkgsMusl`. platforms = builtins.attrNames ghcBinDists.${distSetName}; hydraPlatforms = builtins.filter (p: minimal || p != "aarch64-linux") platforms; - maintainers = with lib.maintainers; [ lostnet ]; + maintainers = with lib.maintainers; [ lostnet guibou ]; }; } diff --git a/pkgs/development/compilers/ghc/8.10.5-binary.nix b/pkgs/development/compilers/ghc/8.10.7-binary.nix similarity index 95% rename from pkgs/development/compilers/ghc/8.10.5-binary.nix rename to pkgs/development/compilers/ghc/8.10.7-binary.nix index ce65929763de..34643dd2f87c 100644 --- a/pkgs/development/compilers/ghc/8.10.5-binary.nix +++ b/pkgs/development/compilers/ghc/8.10.7-binary.nix @@ -17,7 +17,8 @@ assert stdenv.targetPlatform == stdenv.hostPlatform; let downloadsUrl = "https://downloads.haskell.org/ghc"; - version = "8.10.5"; + # Copy sha256 from https://downloads.haskell.org/~ghc/8.10.7/SHA256SUMS + version = "8.10.7"; # Information about available bindists that we use in the build. # @@ -42,7 +43,7 @@ let i686-linux = { src = { url = "${downloadsUrl}/${version}/ghc-${version}-i386-deb9-linux.tar.xz"; - sha256 = "17cwmhhyz952psmp4j3pkdj0yrfxah3l2dawg5s4hdr228n5pjqc"; + sha256 = "fbfc1ef194f4e7a4c0da8c11cc69b17458a4b928b609b3622c97acc4acd5c5ab"; }; exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2"; archSpecificLibraries = [ @@ -55,7 +56,7 @@ let x86_64-linux = { src = { url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-deb10-linux.tar.xz"; - sha256 = "11v76wgljyszc6mgz6r16i6wkifgl15a26q7ablihp2cr8h3qqmw"; + sha256 = "a13719bca87a0d3ac0c7d4157a4e60887009a7f1a8dbe95c4759ec413e086d30"; }; exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2"; archSpecificLibraries = [ @@ -65,7 +66,7 @@ let armv7l-linux = { src = { url = "${downloadsUrl}/${version}/ghc-${version}-armv7-deb10-linux.tar.xz"; - sha256 = "0v5bvhb2z9j26yr0n9gc4xdq2lm37mr98g62p5z8pqahhhd0s5sn"; + sha256 = "3949c31bdf7d3b4afb765ea8246bca4ca9707c5d988d9961a244f0da100956a2"; }; exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2"; archSpecificLibraries = [ @@ -75,7 +76,7 @@ let aarch64-linux = { src = { url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-deb10-linux.tar.xz"; - sha256 = "1p0dgyn1m2nd8ax1g25lchaz9z2nk9jvyzf63biarq7qlzc5q24s"; + sha256 = "fad2417f9b295233bf8ade79c0e6140896359e87be46cb61cd1d35863d9d0e55"; }; exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2"; archSpecificLibraries = [ @@ -86,7 +87,7 @@ let x86_64-darwin = { src = { url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz"; - sha256 = "08javwfqd21kglbr1bnhnbjw2cggz1n668vi8kx5hbcnz3plf3zg"; + sha256 = "287db0f9c338c9f53123bfa8731b0996803ee50f6ee847fe388092e5e5132047"; }; exePathForLibraryCheck = null; # we don't have a library check for darwin yet archSpecificLibraries = [ @@ -97,7 +98,7 @@ let aarch64-darwin = { src = { url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-apple-darwin.tar.xz"; - sha256 = "02fbcrzcc6m25z3ji867isml38jkg4blry70ljwl3l03zxq4ws03"; + sha256 = "dc469fc3c35fd2a33a5a575ffce87f13de7b98c2d349a41002e200a56d9bba1c"; }; exePathForLibraryCheck = null; # we don't have a library check for darwin yet archSpecificLibraries = [ @@ -111,7 +112,7 @@ let x86_64-linux = { src = { url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-alpine3.10-linux-integer-simple.tar.xz"; - sha256 = "1ql2qxywbbv0b9syvrm9kyh5d8midnl676lw4698ajras6gcvmzl"; + sha256 = "16903df850ef73d5246f2ff169cbf57ecab76c2ac5acfa9928934282cfad575c"; }; exePathForLibraryCheck = "bin/ghc"; archSpecificLibraries = [ diff --git a/pkgs/development/compilers/ghc/8.10.6.nix b/pkgs/development/compilers/ghc/8.10.7.nix similarity index 97% rename from pkgs/development/compilers/ghc/8.10.6.nix rename to pkgs/development/compilers/ghc/8.10.7.nix index a11be3b47dc7..f1078a0ad340 100644 --- a/pkgs/development/compilers/ghc/8.10.6.nix +++ b/pkgs/development/compilers/ghc/8.10.7.nix @@ -136,12 +136,12 @@ let in stdenv.mkDerivation (rec { - version = "8.10.6"; + version = "8.10.7"; name = "${targetPrefix}ghc-${version}"; src = fetchurl { url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz"; - sha256 = "43afba72a533408b42c1492bd047b5e37e5f7204e41a5cedd3182cc841610ce9"; + sha256 = "e3eef6229ce9908dfe1ea41436befb0455fefb1932559e860ad4c606b0d03c9d"; }; enableParallelBuilding = true; @@ -284,6 +284,10 @@ stdenv.mkDerivation (rec { # * 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 @@ -309,7 +313,7 @@ stdenv.mkDerivation (rec { meta = { homepage = "http://haskell.org/ghc"; description = "The Glasgow Haskell Compiler"; - maintainers = with lib.maintainers; [ marcweber andres peti ]; + maintainers = with lib.maintainers; [ marcweber andres peti guibou ]; timeout = 24 * 3600; inherit (ghc.meta) license platforms; diff --git a/pkgs/development/compilers/ghc/8.6.5-binary.nix b/pkgs/development/compilers/ghc/8.6.5-binary.nix index ea4542a38b22..c2fac6faf774 100644 --- a/pkgs/development/compilers/ghc/8.6.5-binary.nix +++ b/pkgs/development/compilers/ghc/8.6.5-binary.nix @@ -192,5 +192,6 @@ stdenv.mkDerivation rec { hydraPlatforms = builtins.filter (p: p != "aarch64-linux") platforms; # build segfaults, use ghc8102Binary which has proper musl support instead broken = stdenv.hostPlatform.isMusl; + maintainers = with lib.maintainers; [ guibou ]; }; } diff --git a/pkgs/development/compilers/ghc/8.8.4.nix b/pkgs/development/compilers/ghc/8.8.4.nix index bb2267c930de..66862fca7318 100644 --- a/pkgs/development/compilers/ghc/8.8.4.nix +++ b/pkgs/development/compilers/ghc/8.8.4.nix @@ -316,7 +316,7 @@ stdenv.mkDerivation (rec { meta = { homepage = "http://haskell.org/ghc"; description = "The Glasgow Haskell Compiler"; - maintainers = with lib.maintainers; [ marcweber andres peti ]; + maintainers = with lib.maintainers; [ marcweber andres peti guibou ]; timeout = 24 * 3600; inherit (ghc.meta) license platforms; diff --git a/pkgs/development/compilers/ghc/9.0.1.nix b/pkgs/development/compilers/ghc/9.0.1.nix index 30a7f7a4f40a..c2cc1358e821 100644 --- a/pkgs/development/compilers/ghc/9.0.1.nix +++ b/pkgs/development/compilers/ghc/9.0.1.nix @@ -268,6 +268,10 @@ stdenv.mkDerivation (rec { # * 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 @@ -293,7 +297,7 @@ stdenv.mkDerivation (rec { meta = { homepage = "http://haskell.org/ghc"; description = "The Glasgow Haskell Compiler"; - maintainers = with lib.maintainers; [ marcweber andres peti ]; + maintainers = with lib.maintainers; [ marcweber andres peti guibou ]; timeout = 24 * 3600; inherit (ghc.meta) license platforms; diff --git a/pkgs/development/compilers/ghc/9.2.1.nix b/pkgs/development/compilers/ghc/9.2.1.nix new file mode 100644 index 000000000000..4664ed834f57 --- /dev/null +++ b/pkgs/development/compilers/ghc/9.2.1.nix @@ -0,0 +1,320 @@ +{ lib, stdenv, pkgsBuildTarget, targetPackages + +# build-tools +, bootPkgs +, autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx, xattr +, bash + +, libiconv ? null, ncurses +, glibcLocales ? null + +, # GHC can be built with system libffi or a bundled one. + libffi ? null + +, useLLVM ? !stdenv.targetPlatform.isx86 +, # LLVM is conceptually a run-time-only depedendency, but for + # non-x86, we need LLVM to bootstrap later stages, so it becomes a + # build-time dependency too. + buildLlvmPackages, llvmPackages + +, # If enabled, GHC will be built with the GPL-free but slower integer-simple + # library instead of the faster but GPLed integer-gmp library. + enableIntegerSimple ? !(lib.meta.availableOn stdenv.hostPlatform gmp), gmp + +, # If enabled, use -fPIC when compiling static libs. + enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform + + # aarch64 outputs otherwise exceed 2GB limit +, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64 + +, # Whether to build dynamic libs for the standard library (on the target + # platform). Static libs are always built. + enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt + +, # 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` pullls 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.isDarwin && stdenv.targetPlatform.isAarch64 +}: + +assert !enableIntegerSimple -> 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"} + DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"} + INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"} + '' + lib.optionalString (targetPlatform != hostPlatform) '' + Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"} + CrossCompilePrefix = ${targetPrefix} + '' + lib.optionalString (!enableProfiledLibs) '' + GhcLibWays = "v dyn" + '' + lib.optionalString enableRelocatedStaticLibs '' + GhcLibHcOpts += -fPIC + GhcRtsHcOpts += -fPIC + '' + lib.optionalString targetPlatform.useAndroidPrebuilt '' + EXTRA_CC_OPTS += -std=gnu99 + ''; + + # Splicer will pull out correct variations + libDeps = platform: lib.optional enableTerminfo ncurses + ++ [libffi] + ++ lib.optional (!enableIntegerSimple) gmp + ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv; + + toolsForTarget = [ + pkgsBuildTarget.targetPackages.stdenv.cc + ] ++ lib.optional useLLVM buildLlvmPackages.llvm; + + targetCC = builtins.head toolsForTarget; + + # 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" && !targetPlatform.isMusl); + + runtimeDeps = [ + targetPackages.stdenv.cc.bintools + coreutils + ] + # On darwin, we need unwrapped bintools as well (for otool) + ++ lib.optionals (stdenv.targetPlatform.linker == "cctools") [ + targetPackages.stdenv.cc.bintools.bintools + ]; + +in +stdenv.mkDerivation (rec { + version = "9.2.0.20210821"; + name = "${targetPrefix}ghc-${version}"; + + src = fetchurl { + url = "https://downloads.haskell.org/ghc/9.2.1-rc1/ghc-${version}-src.tar.xz"; + sha256 = "1q2pppxv2avhykyxvyq72r5p97rkkiqp19b77yhp85ralbcp4ivw"; + }; + + enableParallelBuilding = true; + + outputs = [ "out" "doc" ]; + + 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. + 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}cxx" + # 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="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip" + + 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" + '' + 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 + ''; + + # 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 && !enableIntegerSimple) [ + "--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 enableDocs [ + sphinx + ] ++ lib.optionals stdenv.isDarwin [ + # TODO(@sternenseemann): use XATTR env var after backport of + # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6447 + xattr + ]; + + # For building runtime libs + depsBuildTarget = toolsForTarget; + + buildInputs = [ perl bash ] ++ (libDeps hostPlatform); + + propagatedBuildInputs = [ targetPackages.stdenv.cc ] + ++ lib.optional useLLVM llvmPackages.llvm; + + 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 + + # Patch scripts to include "readelf" and "cat" in $PATH. + for i in "$out/bin/"*; do + test ! -h $i || continue + egrep --quiet '^#!' <(head -n 1 $i) || continue + sed -i -e '2i export PATH="$PATH:${lib.makeBinPath runtimeDeps}"' $i + done + ''; + + passthru = { + inherit bootPkgs targetPrefix; + + inherit llvmPackages; + inherit enableShared; + + # Our Cabal compiler name + haskellCompilerName = "ghc-${version}"; + }; + + meta = { + homepage = "http://haskell.org/ghc"; + description = "The Glasgow Haskell Compiler"; + maintainers = with lib.maintainers; [ marcweber andres peti guibou ]; + timeout = 24 * 3600; + inherit (ghc.meta) license platforms; + + # integer-simple builds are broken when GHC links against musl. + # See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881323743. + # Linker failure on macOS: + # https://gitlab.haskell.org/ghc/ghc/-/issues/19950#note_373726 + broken = (enableIntegerSimple && hostPlatform.isMusl) + || stdenv.hostPlatform.isDarwin; + }; + +} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt { + dontStrip = true; + dontPatchELF = true; + noAuditTmpdir = true; +}) diff --git a/pkgs/development/compilers/ghc/head.nix b/pkgs/development/compilers/ghc/head.nix index 35c0bd76214d..d39adcaab540 100644 --- a/pkgs/development/compilers/ghc/head.nix +++ b/pkgs/development/compilers/ghc/head.nix @@ -2,7 +2,7 @@ # build-tools , bootPkgs -, autoconf, autoreconfHook, automake, coreutils, fetchgit, perl, python3, m4, sphinx +, autoconf, autoreconfHook, automake, coreutils, fetchgit, perl, python3, m4, sphinx, xattr , bash , libiconv ? null, ncurses @@ -255,6 +255,10 @@ stdenv.mkDerivation (rec { ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour ] ++ lib.optionals enableDocs [ sphinx + ] ++ lib.optionals stdenv.isDarwin [ + # TODO(@sternenseemann): use XATTR env var once we have + # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6447 + xattr ]; # For building runtime libs @@ -285,6 +289,10 @@ stdenv.mkDerivation (rec { # * 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 @@ -310,7 +318,7 @@ stdenv.mkDerivation (rec { meta = { homepage = "http://haskell.org/ghc"; description = "The Glasgow Haskell Compiler"; - maintainers = with lib.maintainers; [ marcweber andres peti ]; + maintainers = with lib.maintainers; [ marcweber andres peti guibou ]; timeout = 24 * 3600; inherit (ghc.meta) license platforms; # ghcHEAD times out on aarch64-linux on Hydra. diff --git a/pkgs/development/haskell-modules/cabal2nix-unstable.nix b/pkgs/development/haskell-modules/cabal2nix-unstable.nix index 0e8fc7c69cf9..be80f3ed5ce6 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-2021-08-21"; + version = "unstable-2021-08-27"; src = fetchzip { - url = "https://github.com/NixOS/cabal2nix/archive/51a4082fefad4642af67a0ae4bf3bb3a7d9b45e0.tar.gz"; - sha256 = "1qd991ziv54drb0n655dg4ymknlfa0ndx9nq9wb5v00a15i4c04x"; + url = "https://github.com/NixOS/cabal2nix/archive/05b1b404e20eb6252f93c821d4d7974ab7277d90.tar.gz"; + sha256 = "03zvp3wwqph9niadgbvkfcqabafgyhnw12r09cw23hm69hsb64d5"; }; isLibrary = true; isExecutable = true; diff --git a/pkgs/development/haskell-modules/configuration-common.nix b/pkgs/development/haskell-modules/configuration-common.nix index 8f45269c3008..069b90f04372 100644 --- a/pkgs/development/haskell-modules/configuration-common.nix +++ b/pkgs/development/haskell-modules/configuration-common.nix @@ -120,14 +120,6 @@ self: super: { # Jailbreak is necessary for QuickCheck dependency. vector = doJailbreak (if pkgs.stdenv.isi686 then appendConfigureFlag super.vector "--ghc-options=-msse2" else super.vector); - # Test suite fails due golden tests checking text representation - # of normalized dhall expressions, and newer dhall versions format - # differently. - hpack-dhall = - if pkgs.lib.versionOlder "0.5.2" super.hpack-dhall.version - then throw "Drop dontCheck override for hpack-dhall > 0.5.2" - else dontCheck super.hpack-dhall; - inline-c-cpp = overrideCabal super.inline-c-cpp (drv: { postPatch = (drv.postPatch or "") + '' substituteInPlace inline-c-cpp.cabal --replace "-optc-std=c++11" "" @@ -1958,4 +1950,12 @@ EOT # 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; + distribution-nixpkgs = assert super.distribution-nixpkgs.version == "1.6.0"; + overrideCabal super.distribution-nixpkgs { + version = "1.6.1"; + revision = null; + sha256 = "136q893in07iw53m9pqr65h3mrnpvfda272bl4rq1b0z3hzpyhkm"; + editedCabalFile = null; + }; + } // 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 f23abbd167dc..bf7b05148dc7 100644 --- a/pkgs/development/haskell-modules/configuration-darwin.nix +++ b/pkgs/development/haskell-modules/configuration-darwin.nix @@ -8,7 +8,7 @@ in with haskellLib; -self: super: { +self: super: ({ # the tests for shell-conduit on Darwin illegitimatey assume non-GNU echo # see: https://github.com/psibi/shell-conduit/issues/12 @@ -196,6 +196,7 @@ self: super: { hls-ormolu-plugin = dontCheck super.hls-ormolu-plugin; hls-pragmas-plugin = dontCheck super.hls-pragmas-plugin; hls-haddock-comments-plugin = dontCheck super.hls-haddock-comments-plugin; + hls-floskell-plugin = dontCheck super.hls-floskell-plugin; # We are lacking pure pgrep at the moment for tests to work tmp-postgres = dontCheck super.tmp-postgres; @@ -252,4 +253,11 @@ self: super: { # Otherwise impure gcc is used, which is Apple's weird wrapper c2hsc = addTestToolDepends super.c2hsc [ pkgs.gcc ]; -} +} // lib.optionalAttrs pkgs.stdenv.isAarch64 { # aarch64-darwin + + # https://github.com/fpco/unliftio/issues/87 + unliftio = dontCheck super.unliftio; + + # https://github.com/fpco/inline-c/issues/127 + inline-c-cpp = dontCheck super.inline-c-cpp; +}) diff --git a/pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix b/pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix new file mode 100644 index 000000000000..f549dfbce1ad --- /dev/null +++ b/pkgs/development/haskell-modules/configuration-ghc-9.2.x.nix @@ -0,0 +1,115 @@ +{ pkgs, haskellLib }: + +with haskellLib; + +self: super: { + + # This compiler version needs llvm 10.x. + llvmPackages = pkgs.lib.dontRecurseIntoAttrs pkgs.llvmPackages_10; + + # Disable GHC 9.2.x core libraries. + array = null; + base = null; + binary = null; + bytestring = null; + Cabal = null; + containers = null; + deepseq = null; + directory = null; + exceptions = null; + filepath = null; + ghc-bignum = null; + ghc-boot = null; + ghc-boot-th = null; + ghc-compact = null; + ghc-heap = null; + ghc-prim = null; + ghci = null; + haskeline = null; + hpc = null; + integer-gmp = null; + libiserv = null; + mtl = null; + parsec = null; + pretty = null; + process = null; + rts = null; + stm = null; + template-haskell = null; + terminfo = null; + text = null; + time = null; + transformers = null; + unix = null; + xhtml = null; + + # cabal-install needs more recent versions of Cabal and base16-bytestring. + cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: { + Cabal = null; + base16-bytestring = self.base16-bytestring_0_1_1_7; + }); + + # Jailbreaks & Version Updates + async = doJailbreak super.async; + ChasingBottoms = markBrokenVersion "1.3.1.9" super.ChasingBottoms; + data-fix = doJailbreak super.data-fix; + dec = doJailbreak super.dec; + ed25519 = doJailbreak super.ed25519; + hackage-security = doJailbreak super.hackage-security; + hashable = overrideCabal (doJailbreak (dontCheck super.hashable)) (drv: { postPatch = "sed -i -e 's,integer-gmp .*<1.1,integer-gmp < 2,' hashable.cabal"; }); + hashable-time = doJailbreak super.hashable-time; + HTTP = overrideCabal (doJailbreak super.HTTP) (drv: { postPatch = "sed -i -e 's,! Socket,!Socket,' Network/TCP.hs"; }); + integer-logarithms = overrideCabal (doJailbreak super.integer-logarithms) (drv: { postPatch = "sed -i -e 's,integer-gmp <1.1,integer-gmp < 2,' integer-logarithms.cabal"; }); + 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; + vector = doJailbreak (dontCheck super.vector); + vector-binary-instances = doJailbreak super.vector-binary-instances; + vector-th-unbox = doJailbreak super.vector-th-unbox; + zlib = doJailbreak super.zlib; + + # Apply patches from head.hackage. + alex = appendPatch (dontCheck super.alex) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/fe192e12b88b09499d4aff0e562713e820544bd6/patches/alex-3.2.6.patch"; + sha256 = "1rzs764a0nhx002v4fadbys98s6qblw4kx4g46galzjf5f7n2dn4"; + }); + doctest = dontCheck (doJailbreak super.doctest_0_18_1); + language-haskell-extract = appendPatch (doJailbreak super.language-haskell-extract) (pkgs.fetchpatch { + url = "https://gitlab.haskell.org/ghc/head.hackage/-/raw/master/patches/language-haskell-extract-0.2.4.patch"; + sha256 = "0rgzrq0513nlc1vw7nw4km4bcwn4ivxcgi33jly4a7n3c1r32v1f"; + }); + + # 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; + + # 5 introduced support for GHC 9.0.x, but hasn't landed in stackage yet + lens = super.lens_5_0_1; + + # 0.16.0 introduced support for GHC 9.0.x, stackage has 0.15.0 + memory = super.memory_0_16_0; + + # 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; + + # Disable tests pending resolution of + # https://github.com/Soostone/retry/issues/71 + retry = dontCheck super.retry; + + # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage + hlint = super.hlint_3_3_1.overrideScope (self: super: { + ghc-lib-parser = overrideCabal self.ghc-lib-parser_9_0_1_20210324 { + doHaddock = false; + }; + ghc-lib-parser-ex = self.ghc-lib-parser-ex_9_0_0_4; + }); +} diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml index 94345e60295d..8a13571f0a17 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml @@ -632,7 +632,6 @@ broken-packages: - cio - cipher-blowfish - circlehs - - circular - citeproc-hs - cjk - cj-token @@ -1021,9 +1020,11 @@ broken-packages: - dgim - dgs - dhall-check + - dhall-csv - dhall-fly - dhall-text - dhall-to-cabal + - dhall-toml - dhcp-lease-parser - dhrun - dia-base @@ -2535,6 +2536,7 @@ broken-packages: - IsNull - iso8601-duration - isobmff + - isocline - isotope - itcli - itemfield @@ -3194,7 +3196,6 @@ broken-packages: - nanomsg-haskell - nanoparsec - NanoProlog - - nanovg - nanq - naperian - naqsha @@ -4802,6 +4803,7 @@ broken-packages: - th-traced - thumbnail-plus - tianbar + - ticket-management - TicTacToe - tictactoe3d - tidal-midi @@ -5329,6 +5331,7 @@ broken-packages: - yandex-translate - yaop - yap + - yapb - yarr - yaya-test - yaya-unsafe-test diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml index ec51f8c03ae4..7637972c07fd 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml @@ -63,10 +63,9 @@ core-packages: # available on Hackage, `hackage2nix` would generate two packages, `aeson` # at version 1.4.6.0 and `aeson_1_5_0_0` at version 1.5.0.0. # -# WARNING: This list is generated semiautomatically based on the most recent -# LTS package set. If you want to add entries to it, you must do so before the -# comment saying "# LTS Haskell x.y". Any changes after that comment will be -# lost the next time `update-stackage.sh` runs. +# WARNING: We import a list of default-package-overrides from stackage which is +# tracked in stackage.yaml. Adding conflicting overrides with stackage here will +# not work. default-package-overrides: # This was only intended for ghc-7.0.4, and has very old deps, one hidden behind a flag - MissingH ==1.4.2.0 @@ -91,6 +90,8 @@ default-package-overrides: - streamly-bytestring < 0.1.3 - streamly-lmdb < 0.3.0 - streamly-process + # dhall-nix is not part of stackage, remove if dhall >= 1.40 + - dhall-nix < 1.1.22 extra-packages: - base16-bytestring < 1 # required for cabal-install etc. @@ -337,130 +338,130 @@ package-maintainers: - nix-tree unsupported-platforms: - Allure: [ x86_64-darwin ] - alsa-mixer: [ x86_64-darwin ] - alsa-pcm: [ x86_64-darwin ] - alsa-seq: [ x86_64-darwin ] - AWin32Console: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] + Allure: [ x86_64-darwin, aarch64-darwin ] + alsa-mixer: [ x86_64-darwin, aarch64-darwin ] + alsa-pcm: [ x86_64-darwin, aarch64-darwin ] + alsa-seq: [ x86_64-darwin, aarch64-darwin ] + AWin32Console: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] barbly: [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ] - bdcs-api: [ x86_64-darwin ] - bindings-directfb: [ x86_64-darwin ] - bindings-parport: [ x86_64-darwin ] # parport is a linux kernel component - bindings-sane: [ x86_64-darwin ] - btrfs: [ x86_64-darwin ] # depends on linux - bustle: [ x86_64-darwin ] # uses glibc-specific ptsname_r + bdcs-api: [ x86_64-darwin, aarch64-darwin ] + bindings-directfb: [ x86_64-darwin, aarch64-darwin ] + bindings-parport: [ x86_64-darwin, aarch64-darwin ] # parport is a linux kernel component + bindings-sane: [ x86_64-darwin, aarch64-darwin ] + btrfs: [ x86_64-darwin, aarch64-darwin ] # depends on linux + bustle: [ x86_64-darwin, aarch64-darwin ] # uses glibc-specific ptsname_r charsetdetect: [ aarch64-linux ] # not supported by vendored lib / not configured properly https://github.com/batterseapower/libcharsetdetect/issues/3 crackNum: [ aarch64-linux ] # depends on sbv, which is not supported on aarch64-linux - cut-the-crap: [ x86_64-darwin ] - d3d11binding: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - DirectSound: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - dx9base: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - dx9d3d: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - dx9d3dx: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Euterpea: [ x86_64-darwin ] - follow-file: [ x86_64-darwin ] - freenect: [ x86_64-darwin ] - FTGL: [ x86_64-darwin ] - fuzzytime: [ x86_64-darwin ] # https://github.com/kamwitsta/fuzzytime/issues/2 - ghcjs-dom-hello: [ x86_64-darwin ] - gi-dbusmenugtk3: [ x86_64-darwin ] - gi-dbusmenu: [ x86_64-darwin ] - gi-ggit: [ x86_64-darwin ] - gi-ibus: [ x86_64-darwin ] - gi-ostree: [ x86_64-darwin ] - gi-vte: [ x86_64-darwin ] - gi-wnck: [ x86_64-darwin ] - gnome-keyring: [ x86_64-darwin ] + cut-the-crap: [ x86_64-darwin, aarch64-darwin ] + d3d11binding: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + DirectSound: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + dx9base: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + dx9d3d: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + dx9d3dx: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Euterpea: [ x86_64-darwin, aarch64-darwin ] + follow-file: [ x86_64-darwin, aarch64-darwin ] + freenect: [ x86_64-darwin, aarch64-darwin ] + FTGL: [ x86_64-darwin, aarch64-darwin ] + fuzzytime: [ x86_64-darwin, aarch64-darwin ] # https://github.com/kamwitsta/fuzzytime/issues/2 + ghcjs-dom-hello: [ x86_64-darwin, aarch64-darwin ] + gi-dbusmenugtk3: [ x86_64-darwin, aarch64-darwin ] + gi-dbusmenu: [ x86_64-darwin, aarch64-darwin ] + gi-ggit: [ x86_64-darwin, aarch64-darwin ] + gi-ibus: [ x86_64-darwin, aarch64-darwin ] + gi-ostree: [ x86_64-darwin, aarch64-darwin ] + gi-vte: [ x86_64-darwin, aarch64-darwin ] + gi-wnck: [ x86_64-darwin, aarch64-darwin ] + gnome-keyring: [ x86_64-darwin, aarch64-darwin ] gtk-mac-integration: [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ] - gtk-sni-tray: [ x86_64-darwin ] - haskell-snake: [ x86_64-darwin ] - hcwiid: [ x86_64-darwin ] + gtk-sni-tray: [ x86_64-darwin, aarch64-darwin ] + haskell-snake: [ x86_64-darwin, aarch64-darwin ] + hcwiid: [ x86_64-darwin, aarch64-darwin ] hevm: [ aarch64-linux ] # depends on sbv, which is not supported on aarch64-linux - HFuse: [ x86_64-darwin ] - hidapi: [ x86_64-darwin ] - hinotify-bytestring: [ x86_64-darwin ] - hommage-ds: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - honk: [ x86_64-darwin ] - hpapi: [ x86_64-darwin ] + HFuse: [ x86_64-darwin, aarch64-darwin ] + hidapi: [ x86_64-darwin, aarch64-darwin ] + hinotify-bytestring: [ x86_64-darwin, aarch64-darwin ] + hommage-ds: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + honk: [ x86_64-darwin, aarch64-darwin ] + hpapi: [ x86_64-darwin, aarch64-darwin ] HQu: [ aarch64-linux, armv7l-linux ] # unsupported by vendored C++ library, TODO: explicitly list supported platforms - HSoM: [ x86_64-darwin ] - iwlib: [ x86_64-darwin ] - jsaddle-webkit2gtk: [ x86_64-darwin ] + HSoM: [ x86_64-darwin, aarch64-darwin ] + iwlib: [ x86_64-darwin, aarch64-darwin ] + jsaddle-webkit2gtk: [ x86_64-darwin, aarch64-darwin ] kqueue: [ x86_64-linux, aarch64-linux, i686-linux, armv7l-linux ] # BSD / Darwin only API - LambdaHack: [ x86_64-darwin ] + LambdaHack: [ x86_64-darwin, aarch64-darwin ] large-hashable: [ aarch64-linux ] # https://github.com/factisresearch/large-hashable/issues/17 - libmodbus: [ x86_64-darwin ] - libsystemd-journal: [ x86_64-darwin ] - libtelnet: [ x86_64-darwin ] - libzfs: [ x86_64-darwin ] + libmodbus: [ x86_64-darwin, aarch64-darwin ] + libsystemd-journal: [ x86_64-darwin, aarch64-darwin ] + libtelnet: [ x86_64-darwin, aarch64-darwin ] + libzfs: [ x86_64-darwin, aarch64-darwin ] linearEqSolver: [ aarch64-linux ] - linux-evdev: [ x86_64-darwin ] - linux-file-extents: [ x86_64-darwin ] - linux-inotify: [ x86_64-darwin ] - linux-mount: [ x86_64-darwin ] - linux-namespaces: [ x86_64-darwin ] - lio-fs: [ x86_64-darwin ] - logging-facade-journald: [ x86_64-darwin ] - midi-alsa: [ x86_64-darwin ] - mpi-hs: [ aarch64-linux, x86_64-darwin ] - mpi-hs-binary: [ aarch64-linux, x86_64-darwin ] - mpi-hs-cereal: [ aarch64-linux, x86_64-darwin ] - mpi-hs-store: [ aarch64-linux, x86_64-darwin ] + linux-evdev: [ x86_64-darwin, aarch64-darwin ] + linux-file-extents: [ x86_64-darwin, aarch64-darwin ] + linux-inotify: [ x86_64-darwin, aarch64-darwin ] + linux-mount: [ x86_64-darwin, aarch64-darwin ] + linux-namespaces: [ x86_64-darwin, aarch64-darwin ] + lio-fs: [ x86_64-darwin, aarch64-darwin ] + logging-facade-journald: [ x86_64-darwin, aarch64-darwin ] + midi-alsa: [ x86_64-darwin, aarch64-darwin ] + mpi-hs: [ aarch64-linux, x86_64-darwin, aarch64-darwin ] + mpi-hs-binary: [ aarch64-linux, x86_64-darwin, aarch64-darwin ] + mpi-hs-cereal: [ aarch64-linux, x86_64-darwin, aarch64-darwin ] + mpi-hs-store: [ aarch64-linux, x86_64-darwin, aarch64-darwin ] mplayer-spot: [ aarch64-linux ] - mptcp-pm: [ x86_64-darwin ] - netlink: [ x86_64-darwin ] - notifications-tray-icon: [ x86_64-darwin ] # depends on gi-dbusmenu - oculus: [ x86_64-darwin ] - pam: [ x86_64-darwin ] - parport: [ x86_64-darwin ] + mptcp-pm: [ x86_64-darwin, aarch64-darwin ] + netlink: [ x86_64-darwin, aarch64-darwin ] + notifications-tray-icon: [ x86_64-darwin, aarch64-darwin ] # depends on gi-dbusmenu + oculus: [ x86_64-darwin, aarch64-darwin ] + pam: [ x86_64-darwin, aarch64-darwin ] + parport: [ x86_64-darwin, aarch64-darwin ] password: [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86 password-instances: [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86 persist-state: [ aarch64-linux, armv7l-linux ] # https://github.com/minad/persist-state/blob/6fd68c0b8b93dec78218f6d5a1f4fa06ced4e896/src/Data/PersistState.hs#L122-L128 - piyo: [ x86_64-darwin ] - PortMidi-simple: [ x86_64-darwin ] - PortMidi: [ x86_64-darwin ] - posix-api: [ x86_64-darwin ] - Raincat: [ x86_64-darwin ] - reactive-balsa: [ x86_64-darwin ] # depends on alsa-core - reactivity: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - reflex-dom-fragment-shader-canvas: [ x86_64-darwin, aarch64-linux ] - reflex-dom: [ x86_64-darwin, aarch64-linux ] - reflex-localize-dom: [ x86_64-darwin, aarch64-linux ] - rtlsdr: [ x86_64-darwin ] - rubberband: [ x86_64-darwin ] + piyo: [ x86_64-darwin, aarch64-darwin ] + PortMidi-simple: [ x86_64-darwin, aarch64-darwin ] + PortMidi: [ x86_64-darwin, aarch64-darwin ] + posix-api: [ x86_64-darwin, aarch64-darwin ] + Raincat: [ x86_64-darwin, aarch64-darwin ] + reactive-balsa: [ x86_64-darwin, aarch64-darwin ] # depends on alsa-core + reactivity: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + reflex-dom-fragment-shader-canvas: [ x86_64-darwin, aarch64-darwin, aarch64-linux ] + reflex-dom: [ x86_64-darwin, aarch64-darwin, aarch64-linux ] + reflex-localize-dom: [ x86_64-darwin, aarch64-darwin, aarch64-linux ] + rtlsdr: [ x86_64-darwin, aarch64-darwin ] + rubberband: [ x86_64-darwin, aarch64-darwin ] sbv: [ aarch64-linux ] scat: [ aarch64-linux, armv7l-linux ] # uses scrypt, which requries x86 scrypt: [ aarch64-linux, armv7l-linux ] # https://github.com/informatikr/scrypt/issues/8 - sdl2-mixer: [ x86_64-darwin ] - sdl2-ttf: [ x86_64-darwin ] - synthesizer-alsa: [ x86_64-darwin ] - taffybar: [ x86_64-darwin ] - termonad: [ x86_64-darwin ] - tokyotyrant-haskell: [ x86_64-darwin ] - udev: [ x86_64-darwin ] - Unixutils-shadow: [ x86_64-darwin ] + sdl2-mixer: [ x86_64-darwin, aarch64-darwin ] + sdl2-ttf: [ x86_64-darwin, aarch64-darwin ] + synthesizer-alsa: [ x86_64-darwin, aarch64-darwin ] + taffybar: [ x86_64-darwin, aarch64-darwin ] + termonad: [ x86_64-darwin, aarch64-darwin ] + tokyotyrant-haskell: [ x86_64-darwin, aarch64-darwin ] + udev: [ x86_64-darwin, aarch64-darwin ] + Unixutils-shadow: [ x86_64-darwin, aarch64-darwin ] verifiable-expressions: [ aarch64-linux ] - vrpn: [ x86_64-darwin ] - vulkan: [ i686-linux, armv7l-linux, x86_64-darwin ] - VulkanMemoryAllocator: [ i686-linux, armv7l-linux, x86_64-darwin ] - vulkan-utils: [ x86_64-darwin ] - webkit2gtk3-javascriptcore: [ x86_64-darwin ] - Win32-console: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-dhcp-server: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-errors: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-extras: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-junction-point: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-notify: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-security: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-services: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - Win32-services-wrapper: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - xattr: [ x86_64-darwin ] + vrpn: [ x86_64-darwin, aarch64-darwin ] + vulkan: [ i686-linux, armv7l-linux, x86_64-darwin, aarch64-darwin ] + VulkanMemoryAllocator: [ i686-linux, armv7l-linux, x86_64-darwin, aarch64-darwin ] + vulkan-utils: [ x86_64-darwin, aarch64-darwin ] + webkit2gtk3-javascriptcore: [ x86_64-darwin, aarch64-darwin ] + Win32-console: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-dhcp-server: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-errors: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-extras: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-junction-point: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-notify: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-security: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-services: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + Win32-services-wrapper: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + xattr: [ x86_64-darwin, aarch64-darwin ] xgboost-haskell: [ aarch64-linux, armv7l-linux ] - XInput: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ] - xmobar: [ x86_64-darwin ] - xmonad-extras: [ x86_64-darwin ] - xmonad-volume: [ x86_64-darwin ] + XInput: [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-darwin, aarch64-linux, armv7l-linux ] + xmobar: [ x86_64-darwin, aarch64-darwin ] + xmonad-extras: [ x86_64-darwin, aarch64-darwin ] + xmonad-volume: [ x86_64-darwin, aarch64-darwin ] dont-distribute-packages: # Depends on shine, which is a ghcjs project. diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml index 5d19b8439015..cb8c927bad33 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 18.5 +# Stackage LTS 18.7 # This file is auto-generated by # maintainers/scripts/haskell/update-stackage.sh default-package-overrides: @@ -11,8 +11,8 @@ default-package-overrides: - ad ==4.4.1 - adjunctions ==4.4 - adler32 ==0.1.2.0 - - aern2-mp ==0.2.7.0 - - aern2-real ==0.2.7.0 + - aern2-mp ==0.2.8.0 + - aern2-real ==0.2.8.0 - aeson ==1.5.6.0 - aeson-attoparsec ==0.0.0 - aeson-better-errors ==0.9.1.0 @@ -145,7 +145,7 @@ default-package-overrides: - ansi-terminal ==0.11 - ansi-wl-pprint ==0.6.9 - ANum ==0.2.0.2 - - apecs ==0.9.2 + - apecs ==0.9.3 - apecs-gloss ==0.2.4 - apecs-physics ==0.4.5 - api-field-json-th ==0.1.0.2 @@ -269,7 +269,7 @@ default-package-overrides: - blake2 ==0.3.0 - blanks ==0.5.0 - blas-carray ==0.1.0.1 - - blas-comfort-array ==0.0.0.2 + - blas-comfort-array ==0.0.0.3 - blas-ffi ==0.1 - blaze-bootstrap ==0.1.0.1 - blaze-builder ==0.4.2.1 @@ -288,7 +288,7 @@ default-package-overrides: - boots ==0.2.0.1 - bordacount ==0.1.0.0 - boring ==0.2 - - both ==0.1.1.1 + - both ==0.1.1.2 - bound ==2.0.3 - BoundedChan ==1.0.3.0 - bounded-queue ==1.0.0 @@ -311,7 +311,7 @@ default-package-overrides: - bv ==0.5 - bv-little ==1.1.1 - byteable ==0.1.1 - - byte-count-reader ==0.10.1.3 + - byte-count-reader ==0.10.1.5 - bytedump ==1.0 - byte-order ==0.1.2.0 - byteorder ==1.0.4 @@ -331,13 +331,15 @@ default-package-overrides: - c2hs ==0.28.8 - cabal2spec ==2.6.2 - cabal-appimage ==0.3.0.2 + - cabal-clean ==0.1.20210815 - cabal-debian ==5.1 - cabal-doctest ==1.0.8 - cabal-file ==0.1.1 - cabal-flatpak ==0.1.0.2 - cabal-plan ==0.7.2.0 - - cabal-rpm ==2.0.9 + - cabal-rpm ==2.0.10 - cache ==0.1.3.0 + - cached-json-file ==0.1.0 - cacophony ==0.10.1 - calendar-recycling ==0.0.0.1 - call-stack ==0.3.0 @@ -381,7 +383,7 @@ default-package-overrides: - cheapskate-lucid ==0.1.0.0 - checkers ==0.5.6 - checksum ==0.0 - - chimera ==0.3.1.0 + - chimera ==0.3.2.0 - chiphunk ==0.1.4.0 - choice ==0.2.2 - chronologique ==0.3.1.3 @@ -395,9 +397,9 @@ default-package-overrides: - circle-packing ==0.1.0.6 - circular ==0.4.0.0 - citeproc ==0.4.0.1 - - clash-ghc ==1.4.2 - - clash-lib ==1.4.2 - - clash-prelude ==1.4.2 + - clash-ghc ==1.4.3 + - clash-lib ==1.4.3 + - clash-prelude ==1.4.3 - classy-prelude ==1.5.0 - classy-prelude-conduit ==1.5.0 - clay ==0.13.3 @@ -415,7 +417,7 @@ default-package-overrides: - codec-beam ==0.2.0 - code-page ==0.2.1 - collect-errors ==0.1.5.0 - - co-log-concurrent ==0.5.0.0 + - co-log-concurrent ==0.5.1.0 - co-log-core ==0.2.1.1 - Color ==0.3.2 - colorful-monoids ==0.2.1.3 @@ -439,7 +441,7 @@ default-package-overrides: - composition ==1.0.2.2 - composition-extra ==2.0.0 - concise ==0.1.0.1 - - concurrency ==1.11.0.1 + - concurrency ==1.11.0.2 - concurrent-extra ==0.7.0.12 - concurrent-output ==1.10.12 - concurrent-split ==0.0.1.1 @@ -579,7 +581,7 @@ default-package-overrides: - deepseq-generics ==0.2.0.0 - deepseq-instances ==0.1.0.1 - deferred-folds ==0.9.17 - - dejafu ==2.4.0.2 + - dejafu ==2.4.0.3 - dense-linear-algebra ==0.1.0.0 - dependent-map ==0.4.0.0 - dependent-sum ==0.7.1.0 @@ -743,7 +745,7 @@ default-package-overrides: - fakefs ==0.3.0.2 - fakepull ==0.3.0.2 - faktory ==1.0.3.1 - - fast-digits ==0.3.0.0 + - fast-digits ==0.3.1.0 - fast-logger ==3.0.5 - fast-math ==1.0.2 - fb ==2.1.1 @@ -759,7 +761,7 @@ default-package-overrides: - file-embed-lzma ==0 - filelock ==0.1.1.5 - filemanip ==0.3.6.3 - - filepath-bytestring ==1.4.2.1.7 + - filepath-bytestring ==1.4.2.1.8 - file-path-th ==0.1.0.0 - filepattern ==0.1.2 - fileplow ==0.1.0.0 @@ -890,9 +892,9 @@ default-package-overrides: - ghcid ==0.8.7 - ghci-hexcalc ==0.1.1.0 - ghcjs-codemirror ==0.0.0.2 - - ghc-lib ==8.10.5.20210606 - - ghc-lib-parser ==8.10.5.20210606 - - ghc-lib-parser-ex ==8.10.0.21 + - ghc-lib ==8.10.6.20210814 + - ghc-lib-parser ==8.10.6.20210814 + - ghc-lib-parser-ex ==8.10.0.22 - ghc-parser ==0.2.3.0 - ghc-paths ==0.1.0.12 - ghc-prof ==1.4.1.9 @@ -985,7 +987,7 @@ default-package-overrides: - hashing ==0.1.0.1 - hashmap ==1.3.3 - hashtables ==1.2.4.1 - - haskeline ==0.8.1.2 + - haskeline ==0.8.2 - haskell-awk ==1.2.0.1 - haskell-gi ==0.25.0 - haskell-gi-base ==0.25.0 @@ -1081,7 +1083,7 @@ default-package-overrides: - hourglass-orphans ==0.1.0.0 - hp2pretty ==0.10 - hpack ==0.34.4 - - hpack-dhall ==0.5.2 + - hpack-dhall ==0.5.3 - hpc-codecov ==0.3.0.0 - hpc-lcov ==1.0.1 - hprotoc ==2.4.17 @@ -1134,7 +1136,7 @@ default-package-overrides: - hs-php-session ==0.0.9.3 - hsshellscript ==3.5.0 - hs-tags ==0.1.5 - - HStringTemplate ==0.8.7 + - HStringTemplate ==0.8.8 - HSvm ==0.1.1.3.22 - HsYAML ==0.2.1.0 - HsYAML-aeson ==0.2.0.0 @@ -1142,7 +1144,7 @@ default-package-overrides: - htaglib ==1.2.0 - HTF ==0.14.0.6 - html ==1.0.1.2 - - html-conduit ==1.3.2.1 + - html-conduit ==1.3.2.2 - html-entities ==1.1.4.5 - html-entity-map ==0.1.0.0 - htoml ==1.0.0.3 @@ -1168,7 +1170,7 @@ default-package-overrides: - human-readable-duration ==0.2.1.4 - HUnit ==1.6.2.0 - HUnit-approx ==1.1.1.1 - - hunit-dejafu ==2.0.0.4 + - hunit-dejafu ==2.0.0.5 - hvect ==0.4.0.0 - hvega ==0.11.0.1 - hw-balancedparens ==0.4.1.1 @@ -1255,7 +1257,7 @@ default-package-overrides: - intern ==0.9.4 - interpolate ==0.2.1 - interpolatedstring-perl6 ==1.0.2 - - interpolation ==0.1.1.1 + - interpolation ==0.1.1.2 - interpolator ==1.1.0.2 - IntervalMap ==0.6.1.2 - intervals ==0.9.2 @@ -1278,9 +1280,9 @@ default-package-overrides: - ipynb ==0.1.0.1 - ipython-kernel ==0.10.2.1 - irc ==0.6.1.0 - - irc-client ==1.1.2.1 - - irc-conduit ==0.3.0.4 - - irc-ctcp ==0.1.3.0 + - irc-client ==1.1.2.2 + - irc-conduit ==0.3.0.5 + - irc-ctcp ==0.1.3.1 - isbn ==1.1.0.2 - islink ==0.1.0.0 - iso3166-country-codes ==0.20140203.8 @@ -1294,6 +1296,7 @@ default-package-overrides: - ix-shapable ==0.1.0 - jack ==0.7.2 - jalaali ==1.0.0.0 + - java-adt ==0.2018.11.4 - jira-wiki-markup ==1.4.0 - jose ==0.8.4 - jose-jwt ==0.9.2 @@ -1335,14 +1338,14 @@ default-package-overrides: - l10n ==0.1.0.1 - labels ==0.3.3 - lackey ==1.0.15 - - lambdabot-core ==5.3.0.1 + - lambdabot-core ==5.3.0.2 - LambdaHack ==0.10.2.0 - lame ==0.2.0 - language-avro ==0.1.3.1 - language-bash ==0.9.2 - language-c ==0.9.0.1 - language-c-quote ==0.13 - - language-docker ==10.0.1 + - language-docker ==10.0.2 - language-java ==0.2.9 - language-javascript ==0.7.1.0 - language-protobuf ==1.0.1 @@ -1350,7 +1353,7 @@ default-package-overrides: - language-thrift ==0.12.0.0 - lapack ==0.3.2 - lapack-carray ==0.0.3 - - lapack-comfort-array ==0.0.0.1 + - lapack-comfort-array ==0.0.1 - lapack-ffi ==0.0.3 - lapack-ffi-tools ==0.1.2.1 - largeword ==1.2.5 @@ -1510,7 +1513,7 @@ default-package-overrides: - min-max-pqueue ==0.1.0.2 - mintty ==0.1.2 - missing-foreign ==0.1.1 - - mixed-types-num ==0.5.8.0 + - mixed-types-num ==0.5.9.1 - mltool ==0.2.0.1 - mmap ==0.5.9 - mmark ==0.0.7.2 @@ -1526,9 +1529,9 @@ default-package-overrides: - modern-uri ==0.3.4.1 - modular ==0.1.0.8 - monad-chronicle ==1.0.0.1 - - monad-control ==1.0.3 + - monad-control ==1.0.3.1 - monad-control-aligned ==0.0.1.1 - - monad-coroutine ==0.9.1.2 + - monad-coroutine ==0.9.1.3 - monad-extras ==0.6.0 - monadic-arrays ==0.2.2 - monad-journal ==0.8.1 @@ -1541,7 +1544,7 @@ default-package-overrides: - monad-memo ==0.5.3 - monad-metrics ==0.2.2.0 - monad-par ==0.3.5 - - monad-parallel ==0.7.2.4 + - monad-parallel ==0.7.2.5 - monad-par-extras ==0.3.3 - monad-peel ==0.2.1.2 - monad-primitive ==0.1 @@ -1586,7 +1589,7 @@ default-package-overrides: - mustache ==2.3.1 - mutable-containers ==0.3.4 - mwc-probability ==2.3.1 - - mwc-random ==0.15.0.1 + - mwc-random ==0.15.0.2 - mwc-random-monad ==0.7.3.1 - mx-state-codes ==1.0.0.0 - mysql ==0.2.0.1 @@ -1604,7 +1607,7 @@ default-package-overrides: - neat-interpolation ==0.5.1.2 - netcode-io ==0.0.2 - netlib-carray ==0.1 - - netlib-comfort-array ==0.0.0.1 + - netlib-comfort-array ==0.0.0.2 - netlib-ffi ==0.1.1 - net-mqtt ==0.7.1.1 - net-mqtt-lens ==0.1.1.0 @@ -1674,7 +1677,7 @@ default-package-overrides: - OneTuple ==0.2.2.1 - Only ==0.1 - oo-prototypes ==0.1.0.0 - - opaleye ==0.7.3.0 + - opaleye ==0.7.4.0 - OpenAL ==1.7.0.5 - openapi3 ==3.1.0 - open-browser ==0.2.1.0 @@ -1803,6 +1806,7 @@ default-package-overrides: - pointedlist ==0.6.1 - pointless-fun ==1.1.0.6 - poll ==0.0.0.2 + - polling-cache ==0.1.1.0 - poly ==0.5.0.0 - poly-arity ==0.1.0 - polynomials-bernstein ==1.1.2 @@ -1844,7 +1848,7 @@ default-package-overrides: - pretty-sop ==0.2.0.3 - pretty-terminal ==0.1.0.0 - primes ==0.2.1.0 - - primitive ==0.7.1.0 + - primitive ==0.7.2.0 - primitive-addr ==0.1.0.2 - primitive-extras ==0.10.1 - primitive-unaligned ==0.1.1.1 @@ -1971,6 +1975,7 @@ default-package-overrides: - regex-pcre ==0.95.0.0 - regex-pcre-builtin ==0.95.2.3.8.43 - regex-posix ==0.96.0.1 + - regex-posix-clib ==2.7 - regex-tdfa ==1.3.1.1 - regex-with-pcre ==1.1.0.0 - registry ==0.2.0.3 @@ -1983,17 +1988,17 @@ default-package-overrides: - reliable-io ==0.0.1 - relude ==0.7.0.0 - renderable ==0.2.0.1 - - replace-attoparsec ==1.4.4.0 + - replace-attoparsec ==1.4.5.0 - replace-megaparsec ==1.4.4.0 - repline ==0.4.0.0 - req ==3.9.0 - - req-conduit ==1.0.0 + - req-conduit ==1.0.1 - rerebase ==1.13.0.1 - rescue ==0.4.2.1 - resistor-cube ==0.0.1.2 - resolv ==0.1.2.0 - resource-pool ==0.2.3.2 - - resourcet ==1.2.4.2 + - resourcet ==1.2.4.3 - result ==0.2.6.0 - rethinkdb-client-driver ==0.0.25 - retry ==0.8.1.2 @@ -2004,7 +2009,7 @@ default-package-overrides: - rhine ==0.7.0 - rhine-gloss ==0.7.0 - rigel-viz ==0.2.0.0 - - rio ==0.1.20.0 + - rio ==0.1.21.0 - rio-orphans ==0.1.2.0 - rio-prettyprint ==0.1.1.0 - roc-id ==0.1.0.0 @@ -2158,6 +2163,7 @@ default-package-overrides: - singletons ==2.7 - singletons-presburger ==0.6.0.0 - siphash ==1.0.3 + - Sit ==0.2021.1.18 - sitemap-gen ==0.1.0.0 - sized ==1.0.0.0 - skein ==1.0.9.4 @@ -2239,7 +2245,7 @@ default-package-overrides: - storable-record ==0.0.5 - storable-tuple ==0.0.3.3 - storablevector ==0.2.13.1 - - store ==0.7.11 + - store ==0.7.12 - store-core ==0.4.4.4 - store-streaming ==0.2.0.3 - stratosphere ==0.59.1 @@ -2315,7 +2321,7 @@ default-package-overrides: - tasty ==1.4.1 - tasty-ant-xml ==1.1.8 - tasty-bench ==0.2.5 - - tasty-dejafu ==2.0.0.7 + - tasty-dejafu ==2.0.0.8 - tasty-discover ==4.2.2 - tasty-expected-failure ==0.12.3 - tasty-focus ==1.0.1 @@ -2356,7 +2362,7 @@ default-package-overrides: - test-framework-smallcheck ==0.2 - test-fun ==0.1.0.0 - testing-type-modifiers ==0.1.0.1 - - texmath ==0.12.3 + - texmath ==0.12.3.1 - text-ansi ==0.1.1 - text-binary ==0.2.1.1 - text-builder ==0.6.6.2 @@ -2427,7 +2433,7 @@ default-package-overrides: - timezone-series ==0.1.9 - tinylog ==0.15.0 - titlecase ==1.0.1 - - tldr ==0.9.0 + - tldr ==0.9.1 - tls ==1.5.5 - tls-debug ==0.4.8 - tls-session-manager ==0.0.4 @@ -2441,7 +2447,7 @@ default-package-overrides: - torsor ==0.1 - tostring ==0.2.1.1 - transaction ==0.1.1.3 - - transformers-base ==0.4.5.2 + - transformers-base ==0.4.6 - transformers-bifunctors ==0.1 - transformers-compat ==0.6.6 - transformers-fix ==1.0 @@ -2463,11 +2469,11 @@ default-package-overrides: - turtle ==1.5.22 - typecheck-plugin-nat-simple ==0.1.0.2 - TypeCompose ==0.9.14 - - typed-process ==0.2.6.0 + - typed-process ==0.2.6.1 - typed-uuid ==0.1.0.0 - type-equality ==1 - type-errors ==0.2.0.0 - - type-errors-pretty ==0.0.1.1 + - type-errors-pretty ==0.0.1.2 - type-hint ==0.1 - type-level-integers ==0.0.1 - type-level-kv-list ==1.1.0 @@ -2593,7 +2599,7 @@ default-package-overrides: - wai-feature-flags ==0.1.0.1 - wai-handler-launch ==3.0.3.1 - wai-logger ==2.3.6 - - wai-middleware-auth ==0.2.5.0 + - wai-middleware-auth ==0.2.5.1 - wai-middleware-caching ==0.1.0.2 - wai-middleware-clacks ==0.1.0.1 - wai-middleware-prometheus ==1.0.0 @@ -2649,7 +2655,7 @@ default-package-overrides: - writer-cps-transformers ==0.5.6.1 - wss-client ==0.3.0.0 - wuss ==1.1.18 - - X11 ==1.10 + - X11 ==1.10.1 - X11-xft ==0.3.1 - x11-xim ==0.0.9.0 - x509 ==1.7.5 diff --git a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml index b0548975db78..d44ef0dafcc8 100644 --- a/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml +++ b/pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml @@ -391,7 +391,6 @@ dont-distribute-packages: - adict - adp-multi-monadiccp - aern2-real - - aern2-real_0_2_8_0 - aeson-native - afv - agda-server @@ -712,14 +711,14 @@ dont-distribute-packages: - claferwiki - clash - clash-ghc - - clash-ghc_1_4_3 - clash-lib - - clash-lib_1_4_3 - clash-multisignal - clash-prelude-quickcheck + - clash-shake - clash-systemverilog - clash-verilog - clash-vhdl + - clashilator - classify-frog - classy-miso - clckwrks @@ -1063,7 +1062,6 @@ dont-distribute-packages: - falling-turnip - fallingblocks - family-tree - - fast-digits - fastirc - fault-tree - fbrnch @@ -1131,6 +1129,7 @@ dont-distribute-packages: - fplll - fpnla-examples - frame-markdown + - freckle-app - free-theorems-counterexamples - free-theorems-seq - free-theorems-seq-webui @@ -1855,7 +1854,6 @@ dont-distribute-packages: - knots - korfu - ks-test - - kubernetes-client - kurita - laborantin-hs - labsat @@ -1895,7 +1893,6 @@ dont-distribute-packages: - lapack - lapack-carray - lapack-comfort-array - - lapack-comfort-array_0_0_1 - lapack-hmatrix - lapack_0_4 - lat @@ -2006,7 +2003,6 @@ dont-distribute-packages: - loup - ls-usb - lsystem - - lti13 - luachunk - lucid-colonnade - lucienne @@ -2064,7 +2060,6 @@ dont-distribute-packages: - maxent - maxent-learner-hw-gui - maxsharing - - mcmc - mcmc-samplers - mealy - mediabus-fdk-aac @@ -2114,7 +2109,6 @@ dont-distribute-packages: - monetdb-mapi - mongrel2-handler - monky - - monomer - monte-carlo - moo - moo-nad @@ -2172,7 +2166,6 @@ dont-distribute-packages: - mywatch - n2o-web - nakadi-client - - nanovg-simple - nats-queue - natural-number - nemesis-titan @@ -2591,6 +2584,8 @@ dont-distribute-packages: - restful-snap - restricted-workers - rethinkdb-model + - retroclash-lib + - retroclash-sim - rewrite - rewriting - rezoom @@ -3270,7 +3265,6 @@ dont-distribute-packages: - yeshql - yesod-articles - yesod-auth-ldap - - yesod-auth-lti13 - yesod-colonnade - yesod-continuations - yesod-examples diff --git a/pkgs/development/haskell-modules/configuration-nix.nix b/pkgs/development/haskell-modules/configuration-nix.nix index 97a751a2e43c..3553b4fe6a13 100644 --- a/pkgs/development/haskell-modules/configuration-nix.nix +++ b/pkgs/development/haskell-modules/configuration-nix.nix @@ -223,7 +223,11 @@ self: super: builtins.intersectAttrs super { wxcore = super.wxcore.override { wxGTK = pkgs.wxGTK30; }; # Test suite wants to connect to $DISPLAY. + bindings-GLFW = dontCheck super.bindings-GLFW; + gi-gtk-declarative = dontCheck super.gi-gtk-declarative; + gi-gtk-declarative-app-simple = dontCheck super.gi-gtk-declarative-app-simple; hsqml = dontCheck (addExtraLibraries (super.hsqml.override { qt5 = pkgs.qt5Full; }) [pkgs.libGLU pkgs.libGL]); + monomer = dontCheck super.monomer; # Wants to check against a real DB, Needs freetds odbc = dontCheck (addExtraLibraries super.odbc [ pkgs.freetds ]); @@ -352,13 +356,6 @@ self: super: builtins.intersectAttrs super { # Looks like Avahi provides the missing library dnssd = super.dnssd.override { dns_sd = pkgs.avahi.override { withLibdnssdCompat = true; }; }; - # requires an X11 display - bindings-GLFW = dontCheck super.bindings-GLFW; - - # requires an X11 display in test suite - gi-gtk-declarative = dontCheck super.gi-gtk-declarative; - gi-gtk-declarative-app-simple = dontCheck super.gi-gtk-declarative-app-simple; - # tests depend on executable ghcide = overrideCabal super.ghcide (drv: { preCheck = ''export PATH="$PWD/dist/build/ghcide:$PATH"''; diff --git a/pkgs/development/haskell-modules/hackage-packages.nix b/pkgs/development/haskell-modules/hackage-packages.nix index 2125e9341f0a..22c4b4143c89 100644 --- a/pkgs/development/haskell-modules/hackage-packages.nix +++ b/pkgs/development/haskell-modules/hackage-packages.nix @@ -8804,7 +8804,7 @@ self: { }) {}; "HMock" = callPackage - ({ mkDerivation, base, constraints, containers, data-default + ({ mkDerivation, array, base, constraints, containers, data-default , deepseq, directory, doctest-exitcode-stdio, doctest-lib , exceptions, extra, hspec, monad-control, mono-traversable, mtl , QuickCheck, regex-tdfa, stm, syb, template-haskell @@ -8812,10 +8812,10 @@ self: { }: mkDerivation { pname = "HMock"; - version = "0.3.0.0"; - sha256 = "0rvb3a0nbf8i0qfg7na5rvd966amids07l8w8ka6b7hdw46lkczn"; + version = "0.4.0.0"; + sha256 = "1xkb4qyccpp5iws0jysgmcypbcab8yig6hnc756890z1dz5d1vy5"; libraryHaskellDepends = [ - base constraints containers data-default exceptions extra + array base constraints containers data-default exceptions extra monad-control mono-traversable mtl regex-tdfa stm syb template-haskell transformers-base unliftio ]; @@ -9041,7 +9041,9 @@ self: { benchmarkHaskellDepends = [ base gauge ]; description = "quantitative finance library"; license = lib.licenses.mit; - platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ]; + platforms = [ + "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; }) {inherit (pkgs) gsl;}; "HROOT" = callPackage @@ -9328,26 +9330,6 @@ self: { }) {}; "HStringTemplate" = callPackage - ({ mkDerivation, array, base, blaze-builder, bytestring, containers - , deepseq, directory, filepath, mtl, old-locale, parsec, pretty - , semigroups, syb, template-haskell, text, time, void - }: - mkDerivation { - pname = "HStringTemplate"; - version = "0.8.7"; - sha256 = "03kbmyh0713j3qhhrl7jqbmsvyq1q82h2yxq45cc9rs55sma8kjg"; - revision = "2"; - editedCabalFile = "082d1lm6q1jb7rrl20jz0y4ca1qf87ihbq3v6mji9ibacl6adjaq"; - libraryHaskellDepends = [ - array base blaze-builder bytestring containers deepseq directory - filepath mtl old-locale parsec pretty semigroups syb - template-haskell text time void - ]; - description = "StringTemplate implementation in Haskell"; - license = lib.licenses.bsd3; - }) {}; - - "HStringTemplate_0_8_8" = callPackage ({ mkDerivation, array, base, blaze-builder, bytestring, containers , deepseq, directory, filepath, HUnit, mtl, old-locale, parsec , pretty, QuickCheck, random, semigroups, syb, template-haskell @@ -9365,7 +9347,6 @@ self: { testHaskellDepends = [ base containers HUnit QuickCheck random ]; description = "StringTemplate implementation in Haskell"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "HStringTemplateHelpers" = callPackage @@ -17794,6 +17775,23 @@ self: { license = lib.licenses.bsd3; }) {}; + "STMonadTrans_0_4_6" = callPackage + ({ mkDerivation, array, base, mtl, tasty, tasty-hunit + , tasty-quickcheck, transformers + }: + mkDerivation { + pname = "STMonadTrans"; + version = "0.4.6"; + sha256 = "0rvhh0hhwz601ibpzisry7xf3j61r5sxfgp47imaa37i5bvrlynb"; + libraryHaskellDepends = [ array base mtl ]; + testHaskellDepends = [ + array base tasty tasty-hunit tasty-quickcheck transformers + ]; + description = "A monad transformer version of the ST monad"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "SVD2HS" = callPackage ({ mkDerivation, base, containers, pretty, text, xml-conduit , xml-lens @@ -17839,6 +17837,8 @@ self: { pname = "SVGFonts"; version = "1.7.0.1"; sha256 = "06vnpkkr19s9b1wjp7l2w29vr7fsghcrffd2knlxvdhjacrfpc9h"; + revision = "1"; + editedCabalFile = "110zlafis1rivba3za7in92fq6a7738hh57w5gkivi50d7pfbw24"; enableSeparateDataOutput = true; libraryHaskellDepends = [ attoparsec base blaze-markup blaze-svg bytestring cereal @@ -21497,24 +21497,6 @@ self: { }) {}; "X11" = callPackage - ({ mkDerivation, base, data-default-class, libX11, libXext - , libXinerama, libXrandr, libXrender, libXScrnSaver - }: - mkDerivation { - pname = "X11"; - version = "1.10"; - sha256 = "1zrdqryx99izjvsrsalb65ihpmikm9r6cjlci7cfp6wlwa3i585n"; - libraryHaskellDepends = [ base data-default-class ]; - librarySystemDepends = [ - libX11 libXext libXinerama libXrandr libXrender libXScrnSaver - ]; - description = "A binding to the X11 graphics library"; - license = lib.licenses.bsd3; - }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; - inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; - inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;}; - - "X11_1_10_1" = callPackage ({ mkDerivation, base, data-default-class, libX11, libXext , libXinerama, libXrandr, libXrender, libXScrnSaver }: @@ -21528,7 +21510,6 @@ self: { ]; description = "A binding to the X11 graphics library"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXScrnSaver; inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXrender;}; @@ -24370,29 +24351,6 @@ self: { }) {}; "aern2-mp" = callPackage - ({ mkDerivation, base, cdar-mBound, collect-errors, deepseq, hspec - , integer-logarithms, mixed-types-num, QuickCheck, reflection - , regex-tdfa, template-haskell - }: - mkDerivation { - pname = "aern2-mp"; - version = "0.2.7.0"; - sha256 = "1gsqaggg6mpcpl9s3z566gmbynj4l6n1fhni5b0p8pf5hj8n93gg"; - libraryHaskellDepends = [ - base cdar-mBound collect-errors deepseq hspec integer-logarithms - mixed-types-num QuickCheck reflection regex-tdfa template-haskell - ]; - testHaskellDepends = [ - base cdar-mBound collect-errors deepseq hspec integer-logarithms - mixed-types-num QuickCheck reflection regex-tdfa template-haskell - ]; - description = "Multi-precision ball (interval) arithmetic"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "aern2-mp_0_2_8_0" = callPackage ({ mkDerivation, base, cdar-mBound, collect-errors, deepseq, hspec , integer-logarithms, mixed-types-num, QuickCheck, reflection , regex-tdfa, template-haskell @@ -24416,27 +24374,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.7.0"; - sha256 = "0dsph1775rifr9vvx4w7v55bryqmh04fhk6nyk7d91yhn1sf6wc9"; - 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 sequences of MPBalls"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - - "aern2-real_0_2_8_0" = callPackage ({ mkDerivation, aern2-mp, base, collect-errors, hspec , integer-logarithms, mixed-types-num, QuickCheck }: @@ -31160,23 +31097,6 @@ self: { }) {}; "apecs" = callPackage - ({ mkDerivation, array, base, containers, criterion, exceptions - , linear, mtl, QuickCheck, template-haskell, vector - }: - mkDerivation { - pname = "apecs"; - version = "0.9.2"; - sha256 = "1ca9wpp60jslj63q77v55qql46f20jknfqsz7cjmqns41ml5g3q8"; - libraryHaskellDepends = [ - array base containers exceptions mtl template-haskell vector - ]; - testHaskellDepends = [ base containers linear QuickCheck vector ]; - benchmarkHaskellDepends = [ base criterion linear ]; - description = "Fast Entity-Component-System library for game programming"; - license = lib.licenses.bsd3; - }) {}; - - "apecs_0_9_3" = callPackage ({ mkDerivation, array, base, containers, criterion, exceptions , linear, mtl, QuickCheck, template-haskell, vector }: @@ -31191,7 +31111,6 @@ self: { benchmarkHaskellDepends = [ base criterion linear ]; description = "Fast Entity-Component-System library for game programming"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "apecs-gloss" = callPackage @@ -38156,7 +38075,7 @@ self: { ]; description = "Create status bar menus for macOS from executables"; license = lib.licenses.bsd3; - platforms = [ "x86_64-darwin" ]; + platforms = [ "aarch64-darwin" "x86_64-darwin" ]; }) {}; "barchart" = callPackage @@ -43839,22 +43758,6 @@ self: { }) {}; "blas-comfort-array" = callPackage - ({ mkDerivation, base, blas-ffi, comfort-array - , netlib-comfort-array, netlib-ffi, storable-complex, transformers - }: - mkDerivation { - pname = "blas-comfort-array"; - version = "0.0.0.2"; - sha256 = "1n9w905ppb08w0d8xbxvgipr9fv1iapwq3ybvk0dbj009w341kd1"; - libraryHaskellDepends = [ - base blas-ffi comfort-array netlib-comfort-array netlib-ffi - storable-complex transformers - ]; - description = "Auto-generated interface to Fortran BLAS via comfort-array"; - license = lib.licenses.bsd3; - }) {}; - - "blas-comfort-array_0_0_0_3" = callPackage ({ mkDerivation, base, blas-ffi, comfort-array , netlib-comfort-array, netlib-ffi, storable-complex, transformers }: @@ -43868,7 +43771,6 @@ self: { ]; description = "Auto-generated interface to Fortran BLAS via comfort-array"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "blas-ffi" = callPackage @@ -45549,17 +45451,6 @@ self: { }) {}; "both" = callPackage - ({ mkDerivation, base, semigroups, zero }: - mkDerivation { - pname = "both"; - version = "0.1.1.1"; - sha256 = "0kdqz901fpdgggmkm9rpnpv7gma9c8d887bszhnz6xd3v96gg7xn"; - libraryHaskellDepends = [ base semigroups zero ]; - description = "Like Maybe, but with a different Monoid instance"; - license = lib.licenses.mit; - }) {}; - - "both_0_1_1_2" = callPackage ({ mkDerivation, base, semigroups, zero }: mkDerivation { pname = "both"; @@ -45568,7 +45459,6 @@ self: { libraryHaskellDepends = [ base semigroups zero ]; description = "Like Maybe, but with a different Monoid instance"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "botpp" = callPackage @@ -47658,21 +47548,6 @@ self: { }) {}; "byte-count-reader" = callPackage - ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text - }: - mkDerivation { - pname = "byte-count-reader"; - version = "0.10.1.3"; - sha256 = "1z02g8mkjwxdrbyxncbvrwg18knyiqa3w9n0x01y2xmbr279rsh0"; - libraryHaskellDepends = [ base extra parsec parsec-numbers text ]; - testHaskellDepends = [ - base extra hspec parsec parsec-numbers text - ]; - description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB"; - license = lib.licenses.gpl3Only; - }) {}; - - "byte-count-reader_0_10_1_5" = callPackage ({ mkDerivation, base, extra, hspec, parsec, parsec-numbers, text }: mkDerivation { @@ -47685,7 +47560,6 @@ self: { ]; description = "Read strings describing a number of bytes like 2Kb and 0.5 MiB"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "byte-order" = callPackage @@ -49594,27 +49468,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.9"; - sha256 = "1r6a0dki4wsrmq5xfjb9bkj0dl7cnhwdf46427k71ay90hmc6ncq"; - 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; - }) {}; - - "cabal-rpm_2_0_10" = callPackage ({ mkDerivation, base, bytestring, Cabal, directory, extra , filepath, http-client, http-client-tls, http-conduit , optparse-applicative, process, simple-cabal, simple-cmd @@ -49633,7 +49486,6 @@ self: { ]; description = "RPM packaging tool for Haskell Cabal-based packages"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "cabal-scripts" = callPackage @@ -53814,7 +53666,8 @@ self: { description = "Character set detection using Mozilla's Universal Character Set Detector"; license = "LGPL"; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; }) {}; @@ -54391,8 +54244,8 @@ self: { }: mkDerivation { pname = "chessIO"; - version = "0.9.0.0"; - sha256 = "0f8dd3w8az8fzidwiv2h6m52fppfp5b9zd0c1s4c815z3a3rxr4v"; + version = "0.9.1.0"; + sha256 = "19lkjrqji01kmfjm065xmlxsrwwr0z2vz2cz19wr0bx6sz4hw3zr"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -54491,27 +54344,6 @@ self: { }) {}; "chimera" = callPackage - ({ mkDerivation, adjunctions, base, distributive, gauge, mtl - , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck - , tasty-smallcheck, vector - }: - mkDerivation { - pname = "chimera"; - version = "0.3.1.0"; - sha256 = "09dk9x2har2k6apm1wlm2k5k97jf3qxy4rzx94rbfmhs5fhz0i99"; - libraryHaskellDepends = [ - adjunctions base distributive mtl vector - ]; - testHaskellDepends = [ - base QuickCheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck - vector - ]; - benchmarkHaskellDepends = [ base gauge mtl random ]; - description = "Lazy infinite streams with O(1) indexing"; - license = lib.licenses.bsd3; - }) {}; - - "chimera_0_3_2_0" = callPackage ({ mkDerivation, adjunctions, base, distributive, mtl, QuickCheck , random, tasty, tasty-bench, tasty-hunit, tasty-quickcheck , tasty-smallcheck, vector @@ -54530,7 +54362,6 @@ self: { benchmarkHaskellDepends = [ base mtl random tasty-bench ]; description = "Lazy infinite streams with O(1) indexing and applications for memoization"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "chiphunk" = callPackage @@ -55475,8 +55306,6 @@ self: { benchmarkHaskellDepends = [ base criterion vector ]; description = "Circular fixed-sized mutable vectors"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; }) {}; "circus" = callPackage @@ -55948,37 +55777,6 @@ self: { }) {}; "clash-ghc" = callPackage - ({ mkDerivation, array, base, bifunctors, bytestring, Cabal - , clash-lib, clash-prelude, concurrent-supply, containers, deepseq - , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim - , ghc-typelits-extra, ghc-typelits-knownnat - , ghc-typelits-natnormalise, ghci, hashable, haskeline, integer-gmp - , lens, mtl, primitive, process, reflection, split - , template-haskell, text, time, transformers, uniplate, unix - , unordered-containers, utf8-string, vector - }: - mkDerivation { - pname = "clash-ghc"; - version = "1.4.2"; - sha256 = "04sj88mcxszgbr8rxnrwa48r2pkf7h612507gcyk131f5kf6mkss"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - array base bifunctors bytestring Cabal clash-lib clash-prelude - concurrent-supply containers deepseq directory exceptions extra - filepath ghc ghc-boot ghc-prim ghc-typelits-extra - ghc-typelits-knownnat ghc-typelits-natnormalise ghci hashable - haskeline integer-gmp lens mtl primitive process reflection split - template-haskell text time transformers uniplate unix - unordered-containers utf8-string vector - ]; - executableHaskellDepends = [ base ]; - description = "Clash: a functional hardware description language - GHC frontend"; - license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - }) {}; - - "clash-ghc_1_4_3" = callPackage ({ mkDerivation, array, base, bifunctors, bytestring, Cabal , clash-lib, clash-prelude, concurrent-supply, containers, deepseq , directory, exceptions, extra, filepath, ghc, ghc-boot, ghc-prim @@ -56010,49 +55808,6 @@ self: { }) {}; "clash-lib" = callPackage - ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array - , attoparsec, base, base16-bytestring, binary, bytestring - , clash-prelude, concurrent-supply, containers, cryptohash-sha256 - , data-binary-ieee754, data-default, deepseq, directory, dlist - , errors, exceptions, extra, filepath, ghc, ghc-boot-th - , ghc-typelits-knownnat, hashable, haskell-src-exts - , haskell-src-meta, hint, integer-gmp, interpolate, lens, mtl - , ordered-containers, parsers, pretty-show, prettyprinter - , primitive, process, quickcheck-text, reducers, tasty, tasty-hunit - , tasty-quickcheck, template-haskell, temporary, terminal-size - , text, text-show, time, transformers, trifecta - , unordered-containers, utf8-string, vector - , vector-binary-instances - }: - mkDerivation { - pname = "clash-lib"; - version = "1.4.2"; - sha256 = "1gismfz0pahhgfgra8kn34i3g82ip5nfy9aj38ym3rcnpg4aw10m"; - enableSeparateDataOutput = true; - libraryHaskellDepends = [ - aeson aeson-pretty ansi-terminal array attoparsec base - base16-bytestring binary bytestring clash-prelude concurrent-supply - containers cryptohash-sha256 data-binary-ieee754 data-default - deepseq directory dlist errors exceptions extra filepath ghc - ghc-boot-th hashable haskell-src-meta hint integer-gmp interpolate - lens mtl ordered-containers parsers pretty-show prettyprinter - primitive process reducers template-haskell temporary terminal-size - text text-show time transformers trifecta unordered-containers - utf8-string vector vector-binary-instances - ]; - testHaskellDepends = [ - aeson aeson-pretty base base16-bytestring bytestring clash-prelude - concurrent-supply containers data-default deepseq ghc - ghc-typelits-knownnat haskell-src-exts lens pretty-show - quickcheck-text tasty tasty-hunit tasty-quickcheck template-haskell - text transformers unordered-containers - ]; - description = "Clash: a functional hardware description language - As a library"; - license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - }) {}; - - "clash-lib_1_4_3" = callPackage ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, array , attoparsec, base, base16-bytestring, binary, bytestring , clash-prelude, concurrent-supply, containers, cryptohash-sha256 @@ -56111,48 +55866,6 @@ self: { }) {}; "clash-prelude" = callPackage - ({ mkDerivation, array, arrows, base, bifunctors, binary - , bytestring, Cabal, cabal-doctest, constraints, containers - , criterion, data-binary-ieee754, data-default-class, deepseq - , doctest, ghc-prim, ghc-typelits-extra, ghc-typelits-knownnat - , ghc-typelits-natnormalise, half, hashable, hedgehog, hint - , integer-gmp, interpolate, lens, QuickCheck - , quickcheck-classes-base, recursion-schemes, reflection - , singletons, tasty, tasty-hedgehog, tasty-hunit, tasty-quickcheck - , tasty-th, template-haskell, text, text-show, th-abstraction - , th-lift, th-orphans, time, transformers, type-errors, uniplate - , vector - }: - mkDerivation { - pname = "clash-prelude"; - version = "1.4.2"; - sha256 = "04hshjdddd9sk697zvbwlq6cdvyvdfrw670ksfdxxgssyrcsid95"; - setupHaskellDepends = [ base Cabal cabal-doctest ]; - libraryHaskellDepends = [ - array arrows base bifunctors binary bytestring constraints - containers data-binary-ieee754 data-default-class deepseq ghc-prim - ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise - half hashable integer-gmp interpolate lens QuickCheck - recursion-schemes reflection singletons template-haskell text - text-show th-abstraction th-lift th-orphans time transformers - type-errors uniplate vector - ]; - testHaskellDepends = [ - base deepseq doctest ghc-typelits-extra ghc-typelits-knownnat - ghc-typelits-natnormalise hedgehog hint quickcheck-classes-base - tasty tasty-hedgehog tasty-hunit tasty-quickcheck tasty-th - template-haskell - ]; - benchmarkHaskellDepends = [ - base criterion deepseq template-haskell - ]; - description = "Clash: a functional hardware description language - Prelude library"; - license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "clash-prelude_1_4_3" = callPackage ({ mkDerivation, array, arrows, base, bifunctors, binary , bytestring, Cabal, cabal-doctest, constraints, containers , criterion, data-binary-ieee754, data-default-class, deepseq @@ -56207,6 +55920,26 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "clash-shake" = callPackage + ({ mkDerivation, aeson, base, bytestring, clash-ghc, clash-lib + , clash-prelude, directory, ghc-typelits-extra + , ghc-typelits-knownnat, ghc-typelits-natnormalise, shake, split + , stache, text, unordered-containers + }: + mkDerivation { + pname = "clash-shake"; + version = "0.1.0"; + sha256 = "0zjlbi8p0wxaxgfxhljbp9vzhki3ll8g1qqv3gghqkh7cym73kgq"; + libraryHaskellDepends = [ + aeson base bytestring clash-ghc clash-lib clash-prelude directory + ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise + shake split stache text unordered-containers + ]; + description = "Shake rules for building Clash programs"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "clash-systemverilog" = callPackage ({ mkDerivation, base, clash-lib, clash-prelude, fgl, hashable , lens, mtl, text, unordered-containers, wl-pprint-text @@ -56261,6 +55994,30 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "clashilator" = callPackage + ({ mkDerivation, aeson, base, Cabal, clash-ghc, clash-lib + , containers, filepath, ghc, lens, optparse-applicative, shake + , stache, text, unordered-containers + }: + mkDerivation { + pname = "clashilator"; + version = "0.1.0"; + sha256 = "0nlyjhf4vy5ypimdv3ac9qw9aljm2k99y42b2pkhhw84iblv4qgy"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base Cabal clash-ghc clash-lib containers filepath ghc lens + optparse-applicative shake stache text unordered-containers + ]; + executableHaskellDepends = [ + aeson base Cabal clash-ghc clash-lib containers filepath ghc lens + optparse-applicative shake stache text unordered-containers + ]; + description = "Automated Clash to Verilator bridge"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "classify" = callPackage ({ mkDerivation, base, containers, mtl }: mkDerivation { @@ -58183,17 +57940,6 @@ self: { }) {}; "co-log-concurrent" = callPackage - ({ mkDerivation, base, co-log-core, stm }: - mkDerivation { - pname = "co-log-concurrent"; - version = "0.5.0.0"; - sha256 = "07z4aklk7dc2fhbc30kd9hbdvq71sa4ip6r2pyifcpn3p2pr3mna"; - libraryHaskellDepends = [ base co-log-core stm ]; - description = "Asynchronous backend for co-log library"; - license = lib.licenses.mpl20; - }) {}; - - "co-log-concurrent_0_5_1_0" = callPackage ({ mkDerivation, base, co-log-core, stm }: mkDerivation { pname = "co-log-concurrent"; @@ -58202,7 +57948,6 @@ self: { libraryHaskellDepends = [ base co-log-core stm ]; description = "Asynchronous backend for co-log library"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; }) {}; "co-log-core" = callPackage @@ -58722,10 +58467,8 @@ self: { ({ mkDerivation, base, profunctors }: mkDerivation { pname = "coercible-subtypes"; - version = "0.1.0.0"; - sha256 = "1z5fmdgv52x410x2z4gxyac18f98226dymzdvhcvkx7mw2k9q44x"; - revision = "1"; - editedCabalFile = "05bd9lp5jp31ac039vq0p58kr03g5ai3cyymc4ikhbnl3x44hx4d"; + version = "0.1.1.0"; + sha256 = "1q6a38y49a31vl19i5c5kym36fjxspxj6vfi0b35j4gb9b7r642r"; libraryHaskellDepends = [ base profunctors ]; description = "Coercible but only in one direction"; license = lib.licenses.bsd3; @@ -61419,22 +61162,6 @@ self: { }) {}; "concurrency" = callPackage - ({ mkDerivation, array, atomic-primops, base, exceptions - , monad-control, mtl, stm, transformers - }: - mkDerivation { - pname = "concurrency"; - version = "1.11.0.1"; - sha256 = "0ds55wpkxlrw2x5ql34p9b05xlycnc4v7962f27a54nhrjfhb2ah"; - libraryHaskellDepends = [ - array atomic-primops base exceptions monad-control mtl stm - transformers - ]; - description = "Typeclasses, functions, and data types for concurrency and STM"; - license = lib.licenses.mit; - }) {}; - - "concurrency_1_11_0_2" = callPackage ({ mkDerivation, array, atomic-primops, base, exceptions , monad-control, mtl, stm, transformers }: @@ -61448,7 +61175,6 @@ self: { ]; description = "Typeclasses, functions, and data types for concurrency and STM"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "concurrency-benchmarks" = callPackage @@ -65811,7 +65537,8 @@ self: { description = "Crack various integer, floating-point data formats"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; hydraPlatforms = lib.platforms.none; }) {}; @@ -65832,7 +65559,8 @@ self: { description = "Crack various integer and floating-point data formats"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; }) {}; @@ -65852,7 +65580,8 @@ self: { description = "Crack various integer and floating-point data formats"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; hydraPlatforms = lib.platforms.none; }) {}; @@ -66094,8 +65823,8 @@ self: { }: mkDerivation { pname = "creatur"; - version = "5.9.28"; - sha256 = "11fscbkzyzajgg6m50s5x4rmxy1mxrgiqflamqxiwsyj9szw16xl"; + version = "5.9.30"; + sha256 = "1zxg8zkm1n78c80z6xqnnx6x8jzpfx0lfdjn26i9p3rr3wd78bf3"; libraryHaskellDepends = [ array base binary bytestring cereal cond directory exceptions filepath gray-extended hdaemonize hsyslog MonadRandom mtl random @@ -66323,6 +66052,44 @@ self: { license = lib.licenses.bsd3; }) {}; + "criterion_1_5_10_0" = 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 { + pname = "criterion"; + version = "1.5.10.0"; + sha256 = "0akws27z3i9381xrb0p0h5qicz4w5nnxy8jq7gk68gi50gj0flxq"; + 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 + ]; + executableHaskellDepends = [ + base base-compat-batteries optparse-applicative + ]; + testHaskellDepends = [ + aeson base base-compat base-compat-batteries bytestring deepseq + directory HUnit QuickCheck statistics tasty tasty-hunit + tasty-quickcheck vector + ]; + description = "Robust, reliable performance measurement and analysis"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "criterion-cmp" = callPackage ({ mkDerivation, ansi-terminal, base, boxes, bytestring, cassava , containers, filepath, optparse-applicative, vector @@ -73181,22 +72948,6 @@ self: { }) {}; "dejafu" = callPackage - ({ mkDerivation, base, concurrency, containers, contravariant - , deepseq, exceptions, leancheck, profunctors, random, transformers - }: - mkDerivation { - pname = "dejafu"; - version = "2.4.0.2"; - sha256 = "1hwhyxjjwapk6jgsbs0vh033xbc9b8mr5iqd93vskvvljnb40v9h"; - libraryHaskellDepends = [ - base concurrency containers contravariant deepseq exceptions - leancheck profunctors random transformers - ]; - description = "A library for unit-testing concurrent programs"; - license = lib.licenses.mit; - }) {}; - - "dejafu_2_4_0_3" = callPackage ({ mkDerivation, base, concurrency, containers, contravariant , deepseq, exceptions, leancheck, profunctors, random, transformers }: @@ -73210,7 +72961,6 @@ self: { ]; description = "A library for unit-testing concurrent programs"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "deka" = callPackage @@ -74686,6 +74436,61 @@ self: { maintainers = with lib.maintainers; [ Gabriel439 ]; }) {}; + "dhall_1_40_0" = callPackage + ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, atomic-write + , base, bytestring, case-insensitive, cborg, cborg-json, containers + , contravariant, cryptonite, data-fix, deepseq, Diff, directory + , doctest, dotgen, either, exceptions, filepath, foldl, gauge + , generic-random, half, hashable, haskeline, http-client + , http-client-tls, http-types, lens-family-core, megaparsec, memory + , mmorph, mockery, mtl, network-uri, optparse-applicative + , parser-combinators, parsers, pretty-simple, prettyprinter + , prettyprinter-ansi-terminal, profunctors, QuickCheck + , quickcheck-instances, repline, scientific, serialise + , special-values, spoon, tasty, tasty-expected-failure, tasty-hunit + , tasty-quickcheck, tasty-silver, template-haskell, temporary, text + , text-manipulate, th-lift-instances, time, transformers, turtle + , unordered-containers, uri-encode, vector + }: + mkDerivation { + pname = "dhall"; + version = "1.40.0"; + sha256 = "1a5hvfrygk9y9jlldyrbhfv9nzl03s6lqlmzf5dkwycwmfb7cc66"; + isLibrary = true; + isExecutable = true; + enableSeparateDataOutput = true; + libraryHaskellDepends = [ + aeson aeson-pretty ansi-terminal atomic-write base bytestring + case-insensitive cborg cborg-json containers contravariant + cryptonite data-fix deepseq Diff directory dotgen either exceptions + filepath half hashable haskeline http-client http-client-tls + http-types lens-family-core megaparsec memory mmorph mtl + network-uri optparse-applicative parser-combinators parsers + pretty-simple prettyprinter prettyprinter-ansi-terminal profunctors + repline scientific serialise template-haskell text text-manipulate + th-lift-instances time transformers unordered-containers uri-encode + vector + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ + base bytestring cborg containers data-fix deepseq directory doctest + either filepath foldl generic-random http-client http-client-tls + lens-family-core megaparsec mockery prettyprinter QuickCheck + quickcheck-instances scientific serialise special-values spoon + tasty tasty-expected-failure tasty-hunit tasty-quickcheck + tasty-silver template-haskell temporary text time transformers + turtle unordered-containers vector + ]; + benchmarkHaskellDepends = [ + base bytestring containers directory gauge text + ]; + doCheck = false; + description = "A configuration language guaranteed to terminate"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = with lib.maintainers; [ Gabriel439 ]; + }) {}; + "dhall-bash" = callPackage ({ mkDerivation, base, bytestring, containers, dhall , neat-interpolation, optparse-generic, shell-escape, text @@ -74708,6 +74513,29 @@ self: { maintainers = with lib.maintainers; [ Gabriel439 ]; }) {}; + "dhall-bash_1_0_38" = callPackage + ({ mkDerivation, base, bytestring, containers, dhall + , neat-interpolation, optparse-generic, shell-escape, text + }: + mkDerivation { + pname = "dhall-bash"; + version = "1.0.38"; + sha256 = "0pfwqz4l3nn4mr16pv5703j517g3nsgzpmiv18kzl4fs6141d881"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring containers dhall neat-interpolation shell-escape + text + ]; + executableHaskellDepends = [ + base bytestring dhall optparse-generic text + ]; + description = "Compile Dhall to Bash"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = with lib.maintainers; [ Gabriel439 ]; + }) {}; + "dhall-check" = callPackage ({ mkDerivation, base, containers, dhall, directory, filepath , fsnotify, text, trifecta @@ -74727,6 +74555,38 @@ self: { broken = true; }) {}; + "dhall-csv" = callPackage + ({ mkDerivation, ansi-terminal, base, bytestring, cassava + , containers, dhall, either, exceptions, filepath + , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal + , tasty, tasty-hunit, tasty-silver, text, unordered-containers + , vector + }: + mkDerivation { + pname = "dhall-csv"; + version = "1.0.0"; + sha256 = "1dg310mq4c00ykkm1vsvrcicls25zbx7iypcg0nqa8ggchac5jmh"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring cassava containers dhall either exceptions filepath + optparse-applicative prettyprinter text unordered-containers vector + ]; + executableHaskellDepends = [ + ansi-terminal base bytestring cassava dhall optparse-applicative + prettyprinter prettyprinter-ansi-terminal text unordered-containers + vector + ]; + testHaskellDepends = [ + base bytestring cassava dhall filepath tasty tasty-hunit + tasty-silver text unordered-containers vector + ]; + description = "Convert bidirectionally between Dhall and CSV files"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "dhall-docs" = callPackage ({ mkDerivation, base, bytestring, containers, cryptonite, dhall , directory, doctest, file-embed, filepath, foldl, hashable @@ -74736,10 +74596,8 @@ self: { }: mkDerivation { pname = "dhall-docs"; - version = "1.0.6"; - sha256 = "004n8kh8riw67aqwp6z9199jwv2c9r1dbkg92s71vd9zc04wxljv"; - revision = "2"; - editedCabalFile = "1z41z96qawc1i818ycp1ycdpxnysynipjjbi1pmrrgglv89hqjlq"; + version = "1.0.7"; + sha256 = "1h7bzpp3xa5m8zknhi24q0wh1n6w6z26ka780mdsbmchhhj59njm"; isLibrary = true; isExecutable = true; enableSeparateDataOutput = true; @@ -74824,6 +74682,37 @@ self: { maintainers = with lib.maintainers; [ Gabriel439 ]; }) {}; + "dhall-json_1_7_8" = callPackage + ({ mkDerivation, aeson, aeson-pretty, aeson-yaml, ansi-terminal + , base, bytestring, containers, dhall, exceptions, filepath + , lens-family-core, optparse-applicative, prettyprinter + , prettyprinter-ansi-terminal, scientific, tasty, tasty-hunit + , tasty-silver, text, unordered-containers, vector + }: + mkDerivation { + pname = "dhall-json"; + version = "1.7.8"; + sha256 = "0g4c71di93r6vnbhajsj5k3ivhzvn0n0aicvvc2j9nbjfhvahd3h"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty aeson-yaml base bytestring containers dhall + exceptions filepath lens-family-core optparse-applicative + prettyprinter scientific text unordered-containers vector + ]; + executableHaskellDepends = [ + aeson aeson-pretty ansi-terminal base bytestring dhall exceptions + optparse-applicative prettyprinter prettyprinter-ansi-terminal text + ]; + testHaskellDepends = [ + aeson base bytestring dhall tasty tasty-hunit tasty-silver text + ]; + description = "Convert between Dhall and JSON or YAML"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = with lib.maintainers; [ Gabriel439 ]; + }) {}; + "dhall-lex" = callPackage ({ mkDerivation, alex, array, base, bytestring, criterion, deepseq , hspec, hspec-dirstream, scientific @@ -74875,6 +74764,37 @@ self: { maintainers = with lib.maintainers; [ Gabriel439 ]; }) {}; + "dhall-lsp-server_1_0_16" = callPackage + ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers + , data-default, dhall, dhall-json, directory, doctest, filepath + , haskell-lsp, haskell-lsp-types, hslogger, hspec, lens, lsp-test + , megaparsec, mtl, network-uri, optparse-applicative, prettyprinter + , QuickCheck, rope-utf16-splay, tasty, tasty-hspec, text + , transformers, unordered-containers, uri-encode + }: + mkDerivation { + pname = "dhall-lsp-server"; + version = "1.0.16"; + sha256 = "04s4kvbjp4ai17l64syram0br3qc4fpz669ps24r8fkcbbaczckq"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson aeson-pretty base bytestring containers data-default dhall + dhall-json directory filepath haskell-lsp hslogger lens megaparsec + mtl network-uri prettyprinter rope-utf16-splay text transformers + unordered-containers uri-encode + ]; + executableHaskellDepends = [ base optparse-applicative ]; + testHaskellDepends = [ + base directory doctest filepath haskell-lsp-types hspec lsp-test + QuickCheck tasty tasty-hspec text + ]; + description = "Language Server Protocol (LSP) server for Dhall"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + maintainers = with lib.maintainers; [ Gabriel439 ]; + }) {}; + "dhall-nix" = callPackage ({ mkDerivation, base, containers, data-fix, dhall, hnix , lens-family-core, neat-interpolation, optparse-generic, text @@ -74899,6 +74819,29 @@ self: { maintainers = with lib.maintainers; [ Gabriel439 ]; }) {}; + "dhall-nix_1_1_22" = callPackage + ({ mkDerivation, base, containers, data-fix, dhall, hnix + , lens-family-core, neat-interpolation, optparse-generic, text + }: + mkDerivation { + pname = "dhall-nix"; + version = "1.1.22"; + sha256 = "1da64h52fz4imvk7hqblri27zg54r9rcs6hlyzkbnqg4yivpiclg"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers data-fix dhall hnix lens-family-core + neat-interpolation text + ]; + executableHaskellDepends = [ + base dhall hnix optparse-generic text + ]; + description = "Dhall to Nix compiler"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + maintainers = with lib.maintainers; [ Gabriel439 ]; + }) {}; + "dhall-nixpkgs" = callPackage ({ mkDerivation, aeson, base, data-fix, dhall, foldl, hnix , lens-family-core, megaparsec, mmorph, neat-interpolation @@ -74907,10 +74850,8 @@ self: { }: mkDerivation { pname = "dhall-nixpkgs"; - version = "1.0.5"; - sha256 = "10gvkw2rdmz7pgr9675xqnhkgi8pwjid77mwsriid81d703z2b6j"; - revision = "2"; - editedCabalFile = "1kb2bn9v6p6ma016gaq3332vpcd6rdalrmcvxzzys4vaa0l6nl68"; + version = "1.0.6"; + sha256 = "12sfxz7n86m69m1xbnrrr1ybggh70rfwmr4maflq522bhkc2hgvk"; isLibrary = false; isExecutable = true; executableHaskellDepends = [ @@ -74930,10 +74871,8 @@ self: { }: mkDerivation { pname = "dhall-openapi"; - version = "1.0.1"; - sha256 = "1n34amb97dqpvz0s3mhqb46gjq1ix1gicsq700z6v6y7xssrgbz2"; - revision = "1"; - editedCabalFile = "03axb4pqa5p8fkdqxjz1xni8fxg66xr3pshfs2p3y13bgn0kn5z2"; + version = "1.0.2"; + sha256 = "1p678nn1gfj2xp0kmw8i5pzsv6s5bpnsmyng45adb9pnpiyxbcyj"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -74958,6 +74897,8 @@ self: { pname = "dhall-recursive-adt"; version = "0.1.0.1"; sha256 = "09s3m86vflj5im2walab8d0wpvihsvxc5mzy55m10pfzr3gxsd11"; + revision = "1"; + editedCabalFile = "0phfa1y6fic6wyvm3bp56z4sj43wbf75rzggzgf763vivlnvc7xw"; libraryHaskellDepends = [ base data-fix dhall recursion-schemes ]; testHaskellDepends = [ base dhall either hedgehog recursion-schemes tasty tasty-hedgehog @@ -75017,6 +74958,32 @@ self: { broken = true; }) {}; + "dhall-toml" = callPackage + ({ mkDerivation, base, containers, dhall, directory, doctest + , filepath, prettyprinter, tasty, tasty-hunit, text, tomland + , unordered-containers + }: + mkDerivation { + pname = "dhall-toml"; + version = "1.0.0"; + sha256 = "13pz6y0l70h3x62wkhay2jiws6s5m6dy9v7kpd2c5mqzaspfy0w2"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base containers dhall prettyprinter text tomland + unordered-containers + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ + base dhall directory doctest filepath tasty tasty-hunit text + tomland + ]; + description = "Convert between Dhall and TOML"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "dhall-yaml" = callPackage ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall , dhall-json, exceptions, HsYAML, HsYAML-aeson @@ -75046,6 +75013,36 @@ self: { maintainers = with lib.maintainers; [ Gabriel439 ]; }) {}; + "dhall-yaml_1_2_8" = callPackage + ({ mkDerivation, aeson, ansi-terminal, base, bytestring, dhall + , dhall-json, exceptions, HsYAML, HsYAML-aeson + , optparse-applicative, prettyprinter, prettyprinter-ansi-terminal + , tasty, tasty-expected-failure, tasty-hunit, text, vector + }: + mkDerivation { + pname = "dhall-yaml"; + version = "1.2.8"; + sha256 = "1p766ybwib3f2i5h7m1hh71vc255ahvf7237bpprdapqw3ag8nak"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + aeson base bytestring dhall dhall-json HsYAML HsYAML-aeson + optparse-applicative text vector + ]; + executableHaskellDepends = [ + aeson ansi-terminal base bytestring dhall dhall-json exceptions + optparse-applicative prettyprinter prettyprinter-ansi-terminal text + ]; + testHaskellDepends = [ + base bytestring dhall dhall-json tasty tasty-expected-failure + tasty-hunit text + ]; + description = "Convert between Dhall and YAML"; + license = lib.licenses.gpl3Only; + hydraPlatforms = lib.platforms.none; + maintainers = with lib.maintainers; [ Gabriel439 ]; + }) {}; + "dhcp-lease-parser" = callPackage ({ mkDerivation, attoparsec, base, bytestring, chronos, ip, tasty , tasty-hunit, text @@ -75297,8 +75294,8 @@ self: { pname = "diagrams-builder"; version = "0.8.0.5"; sha256 = "0dz617kfkvjf3f2zbphkdx1scglcjj162qsfk9xj7slbapnj918m"; - revision = "1"; - editedCabalFile = "0rcj755n729gs9rgmjwai1xacigwpyk4b91x0cadfsl7xrgqax0c"; + revision = "2"; + editedCabalFile = "1jys7j2s8shwh5yr7w597qd46ip5xqvszaqgpjvnx9fxazqp6r0v"; configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ]; isLibrary = true; isExecutable = true; @@ -75328,8 +75325,8 @@ self: { pname = "diagrams-cairo"; version = "1.4.1.1"; sha256 = "0vyd2yr55n7x71194i18lnbcshdjpnqw4qyq7vj5zx377rsz711k"; - revision = "2"; - editedCabalFile = "0ngbshqmb86sc9djmgkn3zc9l69bn3kdml7ld6qx36dsyq6mafq9"; + revision = "3"; + editedCabalFile = "16jm9g9rfc7d1dy2kwq3n9wfgcj8l6c0d54lym1r6b0arc7yjqlb"; libraryHaskellDepends = [ array base bytestring cairo colour containers data-default-class diagrams-core diagrams-lib filepath hashable JuicyPixels lens mtl @@ -75349,8 +75346,8 @@ self: { pname = "diagrams-canvas"; version = "1.4.1"; sha256 = "1ihmv42412d8dk3s894zd70xd386wrk9ycxkid19barry1vz5plj"; - revision = "1"; - editedCabalFile = "12p6n6g4ab81b39d031vzwfj89qi5wm27srpyigf2v0zswppdyvn"; + revision = "2"; + editedCabalFile = "0x8iv0998nn42l0ph90xq50ca514m3zhac4s9zl1hc5hzivj10sl"; libraryHaskellDepends = [ base blank-canvas cmdargs containers data-default-class diagrams-core diagrams-lib lens mtl NumInstances @@ -75374,8 +75371,8 @@ self: { pname = "diagrams-contrib"; version = "1.4.4"; sha256 = "043jpr7lqg708lzmv6cqys7312lfdwnf8ijcnpl4jkbvcwl87c1m"; - revision = "2"; - editedCabalFile = "1mkpq356z7b2q6ifa4f1k7whsmhgn3hww8scacca0q2wnc8p4xjg"; + revision = "3"; + editedCabalFile = "03drxpqhyv62kzsxiabhfjiayk79fpv8wrq4qapsjbv7ph2jhx2v"; libraryHaskellDepends = [ base circle-packing colour containers cubicbezier data-default data-default-class diagrams-core diagrams-lib diagrams-solve @@ -75437,8 +75434,8 @@ self: { pname = "diagrams-graphviz"; version = "1.4.1.1"; sha256 = "0lscrxd682jvyrl5bj4dxp7593qwyis01sl0p4jm2jfn335wdq40"; - revision = "1"; - editedCabalFile = "1qx69541pxf71whfz2a913yzbhfcks2pyzfprkgrcmiiyv0a3i7b"; + revision = "2"; + editedCabalFile = "0cxg21lsahkrf129k5h82d4znm3861dqc597mgzwyl5f0ywhllzr"; libraryHaskellDepends = [ base containers diagrams-lib fgl graphviz split ]; @@ -75476,6 +75473,8 @@ self: { pname = "diagrams-haddock"; version = "0.4.1"; sha256 = "0p978saxsfad6d8wkjnp6i300cf58ps02yw7a1zzhjfgk5ih2qlb"; + revision = "1"; + editedCabalFile = "063j6drlybzbm6bf9yfix86hs3hvgb98sgh4rzgrqkq9kvarj2ij"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -75675,8 +75674,8 @@ self: { pname = "diagrams-postscript"; version = "1.5"; sha256 = "00j58mc84srjvrf21v6zjxxlbw6b8ahhn1jmbq697w8kw3cvygpa"; - revision = "2"; - editedCabalFile = "0dyji1b8mcxaxwzgckkk3p3ji0prrp7rsin98f1hmyjlj3ih735b"; + revision = "3"; + editedCabalFile = "1aq214837jk85b2l79adm5rcrv8y929aspvix7yjq1skyrqgk7pa"; libraryHaskellDepends = [ base bytestring containers data-default-class diagrams-core diagrams-lib hashable lens monoid-extras mtl semigroups split @@ -75712,8 +75711,8 @@ self: { pname = "diagrams-rasterific"; version = "1.4.2.1"; sha256 = "09a1jnpc4kplg1yhv5kxhi0ph22m5xyr0vmnjv2c5wlz72c72z2z"; - revision = "1"; - editedCabalFile = "1nc12hm4qbj2lmbpk3a77cd46n5bcf20vwd075qj2vglbca2yl9b"; + revision = "2"; + editedCabalFile = "1vd8njhanjaa86h0g8hb6khz11bv9zvg8l4pfx0dj4ypknz4hwak"; libraryHaskellDepends = [ base bytestring containers data-default-class diagrams-core diagrams-lib file-embed filepath FontyFruity hashable JuicyPixels @@ -75785,8 +75784,8 @@ self: { pname = "diagrams-svg"; version = "1.4.3"; sha256 = "1ysv6cz0fngrndl4wjmw4hrdj2rik5fxa1dkxzwnlgf1xwpvxgk8"; - revision = "3"; - editedCabalFile = "19n3g9wvp2fj4dlz3ssyjqx1b6ihskg5s595x9z2c99bpbzyykkv"; + revision = "4"; + editedCabalFile = "0irjf0g1barr06fy409r0ld2hypihrhh6n80ig3487xxny6gfzs0"; libraryHaskellDepends = [ base base64-bytestring bytestring colour containers diagrams-core diagrams-lib filepath hashable JuicyPixels lens monoid-extras mtl @@ -89798,16 +89797,16 @@ self: { broken = true; }) {}; - "faktory_1_1_0_0" = callPackage - ({ mkDerivation, aeson, aeson-casing, async, base, bytestring - , connection, cryptonite, errors, hspec, markdown-unlit, megaparsec - , memory, mtl, network, random, safe-exceptions, scanner - , semigroups, text, time, unix, unordered-containers + "faktory_1_1_1_0" = callPackage + ({ mkDerivation, aeson, aeson-casing, aeson-qq, async, base + , bytestring, connection, cryptonite, errors, hspec, markdown-unlit + , megaparsec, memory, mtl, network, random, safe-exceptions + , scanner, semigroups, text, time, unix, unordered-containers }: mkDerivation { pname = "faktory"; - version = "1.1.0.0"; - sha256 = "0bxwrrypkwhq7whaj79dkibad022bdxd8r5vh1dnd4aka3bdk8mj"; + version = "1.1.1.0"; + sha256 = "1lh427lq991pclzqr112dw4jjalcxpkwl440ygg2fhl6bgn082wx"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -89817,7 +89816,7 @@ self: { ]; executableHaskellDepends = [ aeson base safe-exceptions ]; testHaskellDepends = [ - aeson async base hspec markdown-unlit mtl time + aeson aeson-qq async base hspec markdown-unlit mtl time ]; testToolDepends = [ markdown-unlit ]; description = "Faktory Worker for Haskell"; @@ -89942,8 +89941,8 @@ self: { }: mkDerivation { pname = "fast-builder"; - version = "0.1.2.1"; - sha256 = "0j11ahdmbni56car4zblwz9yz1qkrr6qbmpbah4fgpiyq6177cn9"; + version = "0.1.3.0"; + sha256 = "0j2dfh6y689sk5ahh232zl8glbmwp34xnqkmaq9n9jwbddw4fg5z"; libraryHaskellDepends = [ base bytestring ghc-prim ]; testHaskellDepends = [ base bytestring process QuickCheck stm ]; benchmarkHaskellDepends = [ @@ -89975,26 +89974,6 @@ self: { }) {}; "fast-digits" = callPackage - ({ mkDerivation, base, digits, gauge, integer-gmp, QuickCheck - , smallcheck, tasty, tasty-quickcheck, tasty-smallcheck - }: - mkDerivation { - pname = "fast-digits"; - version = "0.3.0.0"; - sha256 = "1vlmjlkmv1nmw1rriafm2hzkmqd5xnwgzmvrg6xxqj1ab5sdsafs"; - libraryHaskellDepends = [ base integer-gmp ]; - testHaskellDepends = [ - base digits QuickCheck smallcheck tasty tasty-quickcheck - tasty-smallcheck - ]; - benchmarkHaskellDepends = [ base digits gauge ]; - doHaddock = false; - description = "Integer-to-digits conversion"; - license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; - }) {}; - - "fast-digits_0_3_1_0" = callPackage ({ mkDerivation, base, integer-gmp, QuickCheck, smallcheck, tasty , tasty-bench, tasty-quickcheck, tasty-smallcheck }: @@ -90010,7 +89989,6 @@ self: { doHaddock = false; description = "Integer-to-digits conversion"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "fast-downward" = callPackage @@ -92104,18 +92082,6 @@ self: { }) {}; "filepath-bytestring" = callPackage - ({ mkDerivation, base, bytestring, filepath, QuickCheck, unix }: - mkDerivation { - pname = "filepath-bytestring"; - version = "1.4.2.1.7"; - sha256 = "00xayqjq2qvb4yj0ppx838cabg5cx9swh0mzfb8c6njk9y5rc41n"; - libraryHaskellDepends = [ base bytestring unix ]; - testHaskellDepends = [ base bytestring filepath QuickCheck ]; - description = "Library for manipulating RawFilePaths in a cross platform way"; - license = lib.licenses.bsd3; - }) {}; - - "filepath-bytestring_1_4_2_1_8" = callPackage ({ mkDerivation, base, bytestring, criterion, filepath, QuickCheck , unix }: @@ -92128,7 +92094,6 @@ self: { benchmarkHaskellDepends = [ base criterion filepath ]; description = "Library for manipulating RawFilePaths in a cross platform way"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "filepath-crypto" = callPackage @@ -96179,6 +96144,43 @@ self: { broken = true; }) {}; + "freckle-app" = callPackage + ({ mkDerivation, aeson, ansi-terminal, base, bytestring + , case-insensitive, conduit, data-default, datadog, directory + , doctest, errors, exceptions, fast-logger, filepath, Glob, hspec + , hspec-core, hspec-expectations-lifted, hspec-junit-formatter + , http-client, http-conduit, http-link-header, http-types, immortal + , iproute, lens, lens-aeson, load-env, monad-control, monad-logger + , MonadRandom, mtl, network, network-uri, persistent + , persistent-postgresql, postgresql-simple, primitive, process + , resource-pool, retry, rio, temporary, text, time, transformers + , transformers-base, unliftio, unliftio-core, wai, wai-extra, yaml + , yesod, yesod-core + }: + mkDerivation { + pname = "freckle-app"; + version = "1.0.0.2"; + sha256 = "1mrydqmwzwa391cb6pzxmjd5yl04f5xggz0wha7rm2a0pksgxphy"; + libraryHaskellDepends = [ + aeson ansi-terminal base bytestring case-insensitive conduit + data-default datadog doctest errors exceptions fast-logger filepath + Glob hspec hspec-core hspec-expectations-lifted + hspec-junit-formatter http-client http-conduit http-link-header + http-types immortal iproute lens load-env monad-control + monad-logger MonadRandom mtl network network-uri persistent + persistent-postgresql postgresql-simple primitive process + resource-pool retry rio text time transformers transformers-base + unliftio unliftio-core wai wai-extra yaml yesod yesod-core + ]; + testHaskellDepends = [ + aeson base bytestring directory hspec http-types lens lens-aeson + process temporary text time wai wai-extra + ]; + description = "Haskell application toolkit used at Freckle"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "freddy" = callPackage ({ mkDerivation, amqp, async, base, broadcast-chan, bytestring , data-default, hspec, random, text, uuid @@ -101931,8 +101933,8 @@ self: { ({ mkDerivation, base, ghc }: mkDerivation { pname = "ghc-api-compat"; - version = "8.10.5"; - sha256 = "09g04k7zvzjs312yn9hhk8bk3l6k2vbb8qrdpnlr12a6az4adq3s"; + version = "8.10.6"; + sha256 = "1zrwa266v776w8rvcjggdpnyhs8kk36w5wrh63l16kxh58yc2vjz"; libraryHaskellDepends = [ base ghc ]; doHaddock = false; description = "GHC-API compatibility helpers"; @@ -102528,8 +102530,8 @@ self: { }: mkDerivation { pname = "ghc-lib"; - version = "8.10.5.20210606"; - sha256 = "0bl2jp44s3pd1a1sg0kslkhi97f4z2423kdkizg65m6cvmk25ijs"; + version = "8.10.6.20210814"; + sha256 = "0gnjps6xf5wq0nl4rlm4c1mqp3a3rbkwskv85fm852n5cf7bicd6"; enableSeparateDataOutput = true; libraryHaskellDepends = [ array base binary bytestring containers deepseq directory filepath @@ -102564,17 +102566,17 @@ self: { "ghc-lib-parser" = callPackage ({ mkDerivation, alex, array, base, binary, bytestring, containers - , deepseq, directory, filepath, ghc-prim, happy, hpc, pretty - , process, time, transformers, unix + , deepseq, directory, filepath, ghc-prim, happy, pretty, process + , time, transformers, unix }: mkDerivation { pname = "ghc-lib-parser"; - version = "8.10.5.20210606"; - sha256 = "0pqsq49kvqwgbi6jw0dycbdzyldi0sannyqkfzavhqjf4mwjzn4a"; + version = "8.10.6.20210814"; + sha256 = "16kmm5wv3kym3qjq43pldycnira64zyga2c4b2vccvlvbi0v40hi"; enableSeparateDataOutput = true; libraryHaskellDepends = [ array base binary bytestring containers deepseq directory filepath - ghc-prim hpc pretty process time transformers unix + ghc-prim pretty process time transformers unix ]; libraryToolDepends = [ alex happy ]; description = "The GHC API, decoupled from GHC versions"; @@ -102609,8 +102611,8 @@ self: { }: mkDerivation { pname = "ghc-lib-parser-ex"; - version = "8.10.0.21"; - sha256 = "0ynrn7qdmim35fs9qdlbajqwyz559x1l9cqmjhb54vbrs2xnk6vp"; + version = "8.10.0.22"; + sha256 = "1a1yhm8rflln6m8sn2bbh5x6cbn20zfq91vfk1ywmia0v5y2sx03"; libraryHaskellDepends = [ base bytestring containers ghc ghc-boot ghc-boot-th uniplate ]; @@ -112156,8 +112158,8 @@ self: { }: mkDerivation { pname = "gray-extended"; - version = "1.5.8"; - sha256 = "1vli6dc0wc1an6vfhchai6s8xrg8rfds2k07x2xszaqg7r2njc9k"; + version = "1.5.9"; + sha256 = "0j2qw42fv5pg6v6bq51hk6lw3gcz35xd1gfvm8i74irv6bqialgy"; libraryHaskellDepends = [ base ]; testHaskellDepends = [ base QuickCheck test-framework test-framework-quickcheck2 @@ -112396,8 +112398,8 @@ self: { }: mkDerivation { pname = "grid"; - version = "7.8.14"; - sha256 = "11rnsl6bs6qpx90p8jzdigncv6m5wbn6sav8gb3mlbm40fpi3p93"; + version = "7.8.15"; + sha256 = "0fsgax3xpdhnwn67s4wqqpvmm98j7b1fp6lrx98m15nxmjqb7rcc"; libraryHaskellDepends = [ base containers ]; testHaskellDepends = [ base QuickCheck test-framework test-framework-quickcheck2 @@ -113330,7 +113332,7 @@ self: { libraryPkgconfigDepends = [ gtk-mac-integration-gtk2 ]; description = "Bindings for the Gtk/OS X integration library"; license = lib.licenses.lgpl21Only; - platforms = [ "x86_64-darwin" ]; + platforms = [ "aarch64-darwin" "x86_64-darwin" ]; hydraPlatforms = lib.platforms.none; broken = true; }) {inherit (pkgs) gtk-mac-integration-gtk2;}; @@ -118869,6 +118871,8 @@ self: { pname = "hashable"; version = "1.3.2.0"; sha256 = "0dyn343wdwbm1facpcjiyd8w0s0hk23jqh7mbj108az5dx5rdgar"; + revision = "1"; + editedCabalFile = "05jwmd6d127vykb1y13q7sjn5mhfs5pbbkal33jq5kg1rx3hj6kq"; libraryHaskellDepends = [ base bytestring deepseq ghc-prim integer-gmp text ]; @@ -122173,8 +122177,8 @@ self: { }: mkDerivation { pname = "hasklepias"; - version = "0.15.1"; - sha256 = "00n9fan0g3xdl9k0f0rw32xgrwzxb8x85vrj98yyk1dk490pgfhm"; + version = "0.16.1"; + sha256 = "19bskg552zfkfxrkgp7s3pcwjccn3ra3qc13inis55gxg56gwcs0"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -127511,7 +127515,8 @@ self: { description = "Ethereum virtual machine evaluator"; license = lib.licenses.agpl3Only; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; }) {inherit (pkgs) libff; inherit (pkgs) secp256k1;}; @@ -128147,7 +128152,7 @@ self: { libraryToolDepends = [ CoreServices ]; description = "File/folder watching for OS X"; license = lib.licenses.bsd3; - platforms = [ "x86_64-darwin" ]; + platforms = [ "aarch64-darwin" "x86_64-darwin" ]; }) {inherit (pkgs.darwin.apple_sdk.frameworks) Cocoa; inherit (pkgs.darwin.apple_sdk.frameworks) CoreServices;}; @@ -134725,36 +134730,6 @@ self: { }) {}; "hpack-dhall" = callPackage - ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal - , dhall, dhall-json, Diff, directory, filepath, hpack, megaparsec - , microlens, optparse-applicative, prettyprinter, tasty - , tasty-golden, text, transformers, utf8-string, yaml - }: - mkDerivation { - pname = "hpack-dhall"; - version = "0.5.2"; - sha256 = "16mnh9hwp0224cn3rlpbjgqklgvbaffbzjskyksakpgxc0phk1zi"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson aeson-pretty base bytestring dhall dhall-json filepath hpack - megaparsec microlens prettyprinter text transformers yaml - ]; - executableHaskellDepends = [ - aeson aeson-pretty base bytestring dhall dhall-json filepath hpack - megaparsec microlens optparse-applicative prettyprinter text - transformers yaml - ]; - testHaskellDepends = [ - aeson aeson-pretty base bytestring Cabal dhall dhall-json Diff - directory filepath hpack megaparsec microlens prettyprinter tasty - tasty-golden text transformers utf8-string yaml - ]; - description = "hpack's dhalling"; - license = lib.licenses.bsd3; - }) {}; - - "hpack-dhall_0_5_3" = callPackage ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal , dhall, dhall-json, Diff, directory, filepath, hlint, hpack , megaparsec, microlens, optparse-applicative, prettyprinter, tasty @@ -134782,7 +134757,6 @@ self: { ]; description = "hpack's dhalling"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "hpaco" = callPackage @@ -136650,6 +136624,26 @@ self: { broken = true; }) {}; + "hs-tags_0_1_5_1" = callPackage + ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc + , ghc-paths, mtl, process, strict + }: + mkDerivation { + pname = "hs-tags"; + version = "0.1.5.1"; + sha256 = "1yk1x24qar19hx47yjlr4f1qz3ld45hzpc74yxak73rsz08c08dx"; + isLibrary = false; + isExecutable = true; + executableHaskellDepends = [ + base Cabal containers directory filepath ghc ghc-paths mtl process + strict + ]; + description = "Create tag files (ctags and etags) for Haskell code"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "hs-term-emulator" = callPackage ({ mkDerivation, ansi-terminal, attoparsec, base, bytestring , containers, criterion, hspec, hspec-discover, lens, text, vector @@ -140087,8 +140081,8 @@ self: { }: mkDerivation { pname = "hspretty"; - version = "0.1.0.0"; - sha256 = "11mbrr785j6pa02zil705sy67cdvjhwq9l927mm74barf9ph776r"; + version = "0.2.0.0"; + sha256 = "1nxsw25a8g8xhfbcybsamn64bzrr7gl2q6ydd62zj073bkh413iq"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -141128,26 +141122,6 @@ self: { }) {}; "html-conduit" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, conduit - , conduit-extra, containers, deepseq, hspec, HUnit, resourcet, text - , transformers, xml-conduit, xml-types - }: - mkDerivation { - pname = "html-conduit"; - version = "1.3.2.1"; - sha256 = "196c8zcnjp1pc5qvqxd8arx3xkw0a90rvg9mmiw2l4zwnx65709n"; - libraryHaskellDepends = [ - attoparsec base bytestring conduit conduit-extra containers - resourcet text transformers xml-conduit xml-types - ]; - testHaskellDepends = [ - base bytestring containers deepseq hspec HUnit text xml-conduit - ]; - description = "Parse HTML documents using xml-conduit datatypes"; - license = lib.licenses.mit; - }) {}; - - "html-conduit_1_3_2_2" = callPackage ({ mkDerivation, attoparsec, base, bytestring, conduit , conduit-extra, containers, deepseq, hspec, HUnit, resourcet, text , transformers, xml-conduit, xml-types @@ -141165,7 +141139,6 @@ self: { ]; description = "Parse HTML documents using xml-conduit datatypes"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "html-email-validate" = callPackage @@ -141979,6 +141952,24 @@ self: { license = lib.licenses.bsd3; }) {}; + "http-common_0_8_3_4" = callPackage + ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring + , case-insensitive, directory, mtl, network, random, text + , transformers, unordered-containers + }: + mkDerivation { + pname = "http-common"; + version = "0.8.3.4"; + sha256 = "1xpbnfac0fqa5r670ggwm4kq3cmz9jpaw9bx40j9w9qiw6xi4i28"; + libraryHaskellDepends = [ + base base64-bytestring blaze-builder bytestring case-insensitive + directory mtl network random text transformers unordered-containers + ]; + description = "Common types for HTTP clients and servers"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "http-conduit" = callPackage ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring , case-insensitive, conduit, conduit-extra, connection, cookie @@ -142628,6 +142619,38 @@ self: { license = lib.licenses.bsd3; }) {}; + "http-streams_0_8_9_4" = callPackage + ({ mkDerivation, aeson, aeson-pretty, attoparsec, base + , base64-bytestring, blaze-builder, bytestring, case-insensitive + , directory, filepath, ghc-prim, HsOpenSSL, hspec + , hspec-expectations, http-common, HUnit, io-streams, lifted-base + , mtl, network, network-uri, openssl-streams, random, snap-core + , snap-server, system-fileio, system-filepath, text, transformers + , unordered-containers + }: + mkDerivation { + pname = "http-streams"; + version = "0.8.9.4"; + sha256 = "03xdcb0v735xdrkjlm1w56mskh3x08cbsjrcd7wn4li65ixc20xa"; + libraryHaskellDepends = [ + aeson attoparsec base base64-bytestring blaze-builder bytestring + case-insensitive directory filepath HsOpenSSL http-common + io-streams mtl network network-uri openssl-streams text + transformers unordered-containers + ]; + testHaskellDepends = [ + aeson aeson-pretty attoparsec base base64-bytestring blaze-builder + bytestring case-insensitive directory ghc-prim HsOpenSSL hspec + hspec-expectations http-common HUnit io-streams lifted-base mtl + network network-uri openssl-streams random snap-core snap-server + system-fileio system-filepath text transformers + unordered-containers + ]; + description = "An HTTP client using io-streams"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "http-test" = callPackage ({ mkDerivation, aeson, base, bytestring, http-client, lens , lens-aeson, mtl, tasty, tasty-hunit, text, time, wreq @@ -143273,17 +143296,6 @@ self: { }) {}; "hunit-dejafu" = callPackage - ({ mkDerivation, base, dejafu, exceptions, HUnit }: - mkDerivation { - pname = "hunit-dejafu"; - version = "2.0.0.4"; - sha256 = "11d52blw31mcsg7c3w1f7khy3vk2p03h4c5z6ja6wb9k5bg4d004"; - libraryHaskellDepends = [ base dejafu exceptions HUnit ]; - description = "Deja Fu support for the HUnit test framework"; - license = lib.licenses.mit; - }) {}; - - "hunit-dejafu_2_0_0_5" = callPackage ({ mkDerivation, base, dejafu, exceptions, HUnit }: mkDerivation { pname = "hunit-dejafu"; @@ -143292,7 +143304,6 @@ self: { libraryHaskellDepends = [ base dejafu exceptions HUnit ]; description = "Deja Fu support for the HUnit test framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "hunit-gui" = callPackage @@ -149434,6 +149445,23 @@ self: { license = lib.licenses.mit; }) {}; + "inspection-testing_0_4_6_0" = callPackage + ({ mkDerivation, base, containers, ghc, mtl, template-haskell + , transformers + }: + mkDerivation { + pname = "inspection-testing"; + version = "0.4.6.0"; + sha256 = "0qz1npyycj4bvyly9xmjbnhw569l52h38gx02rk0r7zhapw83aig"; + 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 @@ -150214,22 +150242,6 @@ self: { }) {}; "interpolation" = callPackage - ({ mkDerivation, array, base, containers, QuickCheck, utility-ht }: - mkDerivation { - pname = "interpolation"; - version = "0.1.1.1"; - sha256 = "081xlf59xp0j1svigkqfcz5an3yl3p8f5402i6492hz9rpv5qwy5"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ base utility-ht ]; - testHaskellDepends = [ - array base containers QuickCheck utility-ht - ]; - description = "piecewise linear and cubic Hermite interpolation"; - license = lib.licenses.bsd3; - }) {}; - - "interpolation_0_1_1_2" = callPackage ({ mkDerivation, array, base, containers, doctest-exitcode-stdio , doctest-lib, QuickCheck, utility-ht }: @@ -150246,7 +150258,6 @@ self: { ]; description = "piecewise linear and cubic Hermite interpolation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "interpolator" = callPackage @@ -150337,8 +150348,8 @@ self: { }: mkDerivation { pname = "interval-algebra"; - version = "0.10.0"; - sha256 = "1b1a78rssxaqiw42hbb1zqmlq4lmxkxxkhrm3ybqpmrqk492mckv"; + version = "0.10.1"; + sha256 = "1nplznmspji7g51g2xxsr2b5lahhxqnmbs180mm3zmvkam8zizri"; libraryHaskellDepends = [ base containers foldl QuickCheck safe time witherable ]; @@ -151382,27 +151393,6 @@ self: { }) {}; "irc-client" = callPackage - ({ mkDerivation, base, bytestring, conduit, connection, containers - , contravariant, exceptions, irc-conduit, irc-ctcp, mtl - , network-conduit-tls, old-locale, profunctors, stm, stm-chans - , text, time, tls, transformers, x509, x509-store, x509-validation - }: - mkDerivation { - pname = "irc-client"; - version = "1.1.2.1"; - sha256 = "1zaa8na730m96flgiyzcwq95v2ianvflsw3abvdavf7xpq4s71ld"; - libraryHaskellDepends = [ - base bytestring conduit connection containers contravariant - exceptions irc-conduit irc-ctcp mtl network-conduit-tls old-locale - profunctors stm stm-chans text time tls transformers x509 - x509-store x509-validation - ]; - description = "An IRC client library"; - license = lib.licenses.mit; - maintainers = with lib.maintainers; [ sternenseemann ]; - }) {}; - - "irc-client_1_1_2_2" = callPackage ({ mkDerivation, base, bytestring, conduit, connection, containers , contravariant, exceptions, irc-conduit, irc-ctcp, mtl , network-conduit-tls, old-locale, profunctors, stm, stm-chans @@ -151420,7 +151410,6 @@ self: { ]; description = "An IRC client library"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; maintainers = with lib.maintainers; [ sternenseemann ]; }) {}; @@ -151436,24 +151425,6 @@ self: { }) {}; "irc-conduit" = callPackage - ({ mkDerivation, async, base, bytestring, conduit, conduit-extra - , connection, irc, irc-ctcp, network-conduit-tls, profunctors, text - , time, tls, transformers, x509-validation - }: - mkDerivation { - pname = "irc-conduit"; - version = "0.3.0.4"; - sha256 = "0asaddcbdcnbp0bbhvzaq5514nw2l1cp1gac3jbn4mh7brgfwjc1"; - libraryHaskellDepends = [ - async base bytestring conduit conduit-extra connection irc irc-ctcp - network-conduit-tls profunctors text time tls transformers - x509-validation - ]; - description = "Streaming IRC message library using conduits"; - license = lib.licenses.mit; - }) {}; - - "irc-conduit_0_3_0_5" = callPackage ({ mkDerivation, async, base, bytestring, conduit, conduit-extra , connection, irc, irc-ctcp, network-conduit-tls, profunctors, text , time, tls, transformers, x509-validation @@ -151469,7 +151440,6 @@ self: { ]; description = "Streaming IRC message library using conduits"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "irc-core" = callPackage @@ -151491,17 +151461,6 @@ self: { }) {}; "irc-ctcp" = callPackage - ({ mkDerivation, base, bytestring, text }: - mkDerivation { - pname = "irc-ctcp"; - version = "0.1.3.0"; - sha256 = "16mp9dpp57id760zc932dszd5r1ncskwwxrp0djka5r1alddjz6n"; - libraryHaskellDepends = [ base bytestring text ]; - description = "A CTCP encoding and decoding library for IRC clients"; - license = lib.licenses.mit; - }) {}; - - "irc-ctcp_0_1_3_1" = callPackage ({ mkDerivation, base, bytestring, text }: mkDerivation { pname = "irc-ctcp"; @@ -151510,7 +151469,6 @@ self: { libraryHaskellDepends = [ base bytestring text ]; description = "A CTCP encoding and decoding library for IRC clients"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "irc-dcc" = callPackage @@ -152006,6 +151964,23 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "isocline" = callPackage + ({ mkDerivation, base, bytestring, text }: + mkDerivation { + pname = "isocline"; + version = "1.0.1"; + sha256 = "1s57gqzhic1zjc0fn1j8l834cfa24w9q2rvhbxdfkb442qpw4piw"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ base bytestring text ]; + executableHaskellDepends = [ base bytestring text ]; + testHaskellDepends = [ base bytestring text ]; + description = "A portable alternative to GNU Readline"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "isohunt" = callPackage ({ mkDerivation, aeson, base, bytestring, data-default, ghc-prim , http-conduit, text, unordered-containers, uri, vector @@ -158256,7 +158231,7 @@ self: { libraryToolDepends = [ c2hs ]; description = "A binding to the kqueue event library"; license = lib.licenses.bsd3; - platforms = [ "x86_64-darwin" ]; + platforms = [ "aarch64-darwin" "x86_64-darwin" ]; }) {}; "kraken" = callPackage @@ -158453,7 +158428,6 @@ self: { ]; description = "Client library for Kubernetes"; license = lib.licenses.asl20; - hydraPlatforms = lib.platforms.none; }) {}; "kubernetes-client-core" = callPackage @@ -158907,6 +158881,22 @@ self: { broken = true; }) {}; + "lambda-cube" = callPackage + ({ mkDerivation, base, hspec, megaparsec, QuickCheck + , template-haskell, text + }: + mkDerivation { + pname = "lambda-cube"; + version = "0.1.0.0"; + sha256 = "0s5sh4r43r5xhlldxqy2snddc5dgnx2rpawk4pipxp69983xhazi"; + revision = "3"; + editedCabalFile = "0ycaf4j9g0zsbw4qjwd6san4vn7h6iiyyf0dqgqwcl0vfv7z2hf0"; + libraryHaskellDepends = [ base megaparsec template-haskell text ]; + testHaskellDepends = [ base hspec QuickCheck ]; + description = "Haskell implementation of (some of) lambda cube calculi"; + license = lib.licenses.mit; + }) {}; + "lambda-devs" = callPackage ({ mkDerivation, base, binary, containers, dimensional , distributed-process, HUnit, numtype, QuickCheck, test-framework @@ -159075,31 +159065,6 @@ self: { }) {}; "lambdabot-core" = callPackage - ({ mkDerivation, base, binary, bytestring, containers - , dependent-map, dependent-sum, dependent-sum-template, directory - , edit-distance, exceptions, filepath, haskeline, hslogger, HTTP - , lifted-base, monad-control, mtl, network, network-bsd, parsec - , prim-uniq, random, random-fu, random-source, regex-tdfa - , SafeSemaphore, split, syb, template-haskell, time, transformers - , transformers-base, unix, utf8-string, zlib - }: - mkDerivation { - pname = "lambdabot-core"; - version = "5.3.0.1"; - sha256 = "05xx68f3gpc7s1k8p81pwphmiznf7niradf52p39rss3nx8rr3ay"; - libraryHaskellDepends = [ - base binary bytestring containers dependent-map dependent-sum - dependent-sum-template directory edit-distance exceptions filepath - haskeline hslogger HTTP lifted-base monad-control mtl network - network-bsd parsec prim-uniq random random-fu random-source - regex-tdfa SafeSemaphore split syb template-haskell time - transformers transformers-base unix utf8-string zlib - ]; - description = "Lambdabot core functionality"; - license = "GPL"; - }) {}; - - "lambdabot-core_5_3_0_2" = callPackage ({ mkDerivation, base, binary, bytestring, containers , dependent-map, dependent-sum, dependent-sum-template, directory , edit-distance, exceptions, filepath, haskeline, hslogger, HTTP @@ -159122,7 +159087,6 @@ self: { ]; description = "Lambdabot core functionality"; license = "GPL"; - hydraPlatforms = lib.platforms.none; }) {}; "lambdabot-haskell-plugins" = callPackage @@ -160079,27 +160043,6 @@ self: { }) {}; "language-docker" = callPackage - ({ mkDerivation, base, bytestring, containers, data-default-class - , hspec, HUnit, megaparsec, prettyprinter, QuickCheck, split, text - , time - }: - mkDerivation { - pname = "language-docker"; - version = "10.0.1"; - sha256 = "19pyms0ik37wpzjnlplj2vwikbjdjaw78llpfjp0a0467wlk7na6"; - libraryHaskellDepends = [ - base bytestring containers data-default-class megaparsec - prettyprinter split text time - ]; - testHaskellDepends = [ - base bytestring containers data-default-class hspec HUnit - megaparsec prettyprinter QuickCheck split text time - ]; - description = "Dockerfile parser, pretty-printer and embedded DSL"; - license = lib.licenses.gpl3Only; - }) {}; - - "language-docker_10_0_2" = callPackage ({ mkDerivation, base, bytestring, containers, data-default-class , hspec, hspec-megaparsec, HUnit, megaparsec, prettyprinter , QuickCheck, split, text, time @@ -160119,7 +160062,6 @@ self: { ]; description = "Dockerfile parser, pretty-printer and embedded DSL"; license = lib.licenses.gpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "language-dockerfile" = callPackage @@ -161154,23 +161096,6 @@ self: { }) {}; "lapack-comfort-array" = callPackage - ({ mkDerivation, base, comfort-array, lapack-ffi - , netlib-comfort-array, netlib-ffi, storable-complex, transformers - }: - mkDerivation { - pname = "lapack-comfort-array"; - version = "0.0.0.1"; - sha256 = "0kn9bb3q772sbzm54rdqbqrmp21kck2gvc0xagi974dq7b1wilh1"; - libraryHaskellDepends = [ - base comfort-array lapack-ffi netlib-comfort-array netlib-ffi - storable-complex transformers - ]; - description = "Auto-generated interface to Fortran LAPACK via comfort-array"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - }) {}; - - "lapack-comfort-array_0_0_1" = callPackage ({ mkDerivation, base, comfort-array, lapack-ffi , netlib-comfort-array, netlib-ffi, storable-complex, transformers }: @@ -161271,11 +161196,42 @@ self: { description = "Efficiently hash (large) Haskell values"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; maintainers = with lib.maintainers; [ sternenseemann ]; }) {}; + "large-records" = callPackage + ({ mkDerivation, aeson, base, containers, generic-deriving + , generics-sop, ghc-dump-core, haskell-src-exts, haskell-src-meta + , json-sop, microlens, mtl, newtype, QuickCheck + , record-dot-preprocessor, record-hasfield, sop-core, syb, tasty + , tasty-hunit, tasty-quickcheck, template-haskell, text + , transformers, vector + }: + mkDerivation { + pname = "large-records"; + version = "0.1.0.0"; + sha256 = "1l4j7vb3lckqn1cvyvcg6g3bnvi8x69nsjmkmmi7666025bxfw61"; + revision = "1"; + editedCabalFile = "1j89aypcp97vwb7qyg4n2ffilsp064z1w7kck1wh2rp69wk5r51n"; + libraryHaskellDepends = [ + aeson base containers generics-sop haskell-src-exts + haskell-src-meta microlens mtl record-hasfield sop-core syb + template-haskell text vector + ]; + testHaskellDepends = [ + aeson base generic-deriving generics-sop ghc-dump-core json-sop + microlens mtl newtype QuickCheck record-dot-preprocessor + record-hasfield sop-core tasty tasty-hunit tasty-quickcheck + template-haskell transformers vector + ]; + testToolDepends = [ record-dot-preprocessor ]; + description = "Efficient compilation for large records, linear in the size of the record"; + license = lib.licenses.bsd3; + }) {}; + "largeword" = callPackage ({ mkDerivation, base, binary, bytestring, HUnit, QuickCheck , test-framework, test-framework-hunit, test-framework-quickcheck2 @@ -165595,7 +165551,8 @@ self: { description = "Use SMT solvers to solve linear systems over integers and rationals"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; }) {}; @@ -169871,7 +169828,6 @@ self: { ]; description = "Core functionality for LTI 1.3."; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "ltiv1p1" = callPackage @@ -174208,7 +174164,6 @@ self: { ]; description = "Sample from a posterior using Markov chain Monte Carlo"; license = lib.licenses.gpl3Plus; - hydraPlatforms = lib.platforms.none; }) {}; "mcmc-samplers" = callPackage @@ -177854,25 +177809,6 @@ self: { }) {}; "mixed-types-num" = callPackage - ({ mkDerivation, base, collect-errors, hspec, hspec-smallcheck, mtl - , QuickCheck, smallcheck, template-haskell - }: - mkDerivation { - pname = "mixed-types-num"; - version = "0.5.8.0"; - sha256 = "1i40g6kf4my91i7xg54wfi6n2s8ivmx5k08ccqz3iycn6gha8pr7"; - libraryHaskellDepends = [ - base collect-errors hspec hspec-smallcheck mtl QuickCheck - smallcheck template-haskell - ]; - testHaskellDepends = [ - base collect-errors hspec hspec-smallcheck QuickCheck smallcheck - ]; - description = "Alternative Prelude with numeric and logic expressions typed bottom-up"; - license = lib.licenses.bsd3; - }) {}; - - "mixed-types-num_0_5_9_1" = callPackage ({ mkDerivation, base, collect-errors, hspec, hspec-smallcheck, mtl , QuickCheck, smallcheck, template-haskell }: @@ -177889,7 +177825,6 @@ self: { ]; description = "Alternative Prelude with numeric and logic expressions typed bottom-up"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "mixpanel-client" = callPackage @@ -179175,21 +179110,6 @@ self: { }) {}; "monad-control" = callPackage - ({ mkDerivation, base, stm, transformers, transformers-base - , transformers-compat - }: - mkDerivation { - pname = "monad-control"; - version = "1.0.3"; - sha256 = "16rdv4s85ni1xdbd8nzarm4sh331198jnmakrn5wxla9hrfwg2fi"; - libraryHaskellDepends = [ - base stm transformers transformers-base transformers-compat - ]; - description = "Lift control operations, like exception catching, through monad transformers"; - license = lib.licenses.bsd3; - }) {}; - - "monad-control_1_0_3_1" = callPackage ({ mkDerivation, base, stm, transformers, transformers-base , transformers-compat }: @@ -179202,7 +179122,6 @@ self: { ]; description = "Lift control operations, like exception catching, through monad transformers"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "monad-control-aligned" = callPackage @@ -179236,21 +179155,6 @@ self: { }) {}; "monad-coroutine" = callPackage - ({ mkDerivation, base, monad-parallel, transformers - , transformers-compat - }: - mkDerivation { - pname = "monad-coroutine"; - version = "0.9.1.2"; - sha256 = "1s4975q1k23b2skyq9mwkkda08f2zxkv96x0yplzhz9n64kchhf3"; - libraryHaskellDepends = [ - base monad-parallel transformers transformers-compat - ]; - description = "Coroutine monad transformer for suspending and resuming monadic computations"; - license = "GPL"; - }) {}; - - "monad-coroutine_0_9_1_3" = callPackage ({ mkDerivation, base, monad-parallel, transformers , transformers-compat }: @@ -179263,7 +179167,6 @@ self: { ]; description = "Coroutine monad transformer for suspending and resuming monadic computations"; license = "GPL"; - hydraPlatforms = lib.platforms.none; }) {}; "monad-dijkstra" = callPackage @@ -179834,20 +179737,6 @@ self: { }) {}; "monad-parallel" = callPackage - ({ mkDerivation, base, parallel, transformers, transformers-compat - }: - mkDerivation { - pname = "monad-parallel"; - version = "0.7.2.4"; - sha256 = "1h36hwbk800v0cq2x8kxf7v3gkr8maws7ijxckvsqp480xr4r5xx"; - libraryHaskellDepends = [ - base parallel transformers transformers-compat - ]; - description = "Parallel execution of monadic computations"; - license = lib.licenses.bsd3; - }) {}; - - "monad-parallel_0_7_2_5" = callPackage ({ mkDerivation, base, parallel, transformers, transformers-compat }: mkDerivation { @@ -179859,7 +179748,6 @@ self: { ]; description = "Parallel execution of monadic computations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "monad-parallel-progressbar" = callPackage @@ -180163,6 +180051,17 @@ self: { broken = true; }) {}; + "monad-tree" = callPackage + ({ mkDerivation, base }: + mkDerivation { + pname = "monad-tree"; + version = "0.1.0"; + sha256 = "1rjrcai2wqz3qkn3sk1fj6c0vvzk58gmghzwp9w9xvr09kd7zyd2"; + libraryHaskellDepends = [ base ]; + description = "Tree data structure for nondeterministic computations"; + license = lib.licenses.mit; + }) {}; + "monad-tx" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -181020,8 +180919,8 @@ self: { }: mkDerivation { pname = "monomer"; - version = "1.0.0.1"; - sha256 = "1ns4zm1vny8r49k0iq77b75s17gqmzxjv3kj70a4k5j4jx5s70fr"; + version = "1.0.0.2"; + sha256 = "1m0c6ldc5sg2if4b21n7b13f5rpyws0vmw9nn8gjqly7rbq446az"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ @@ -181048,7 +180947,6 @@ self: { ]; description = "A GUI library for writing native Haskell applications"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) glew;}; "monomorphic" = callPackage @@ -182086,7 +181984,8 @@ self: { description = "Save your spot when watching movies with @mplayer@"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; }) {}; @@ -184704,32 +184603,6 @@ self: { }) {}; "mwc-random" = callPackage - ({ mkDerivation, base, bytestring, doctest, gauge, math-functions - , mersenne-random, primitive, QuickCheck, random, tasty - , tasty-hunit, tasty-quickcheck, time, vector - }: - mkDerivation { - pname = "mwc-random"; - version = "0.15.0.1"; - sha256 = "1p8c5g4hb72k90ai39rgpn6cr942i6636l1y0zfp9xgjb3v0a2q3"; - revision = "2"; - editedCabalFile = "0si7d23ycyg1072w10v06zh1xx4yy5jxwmrrs65inrs7fhdb1r28"; - libraryHaskellDepends = [ - base math-functions primitive random time vector - ]; - testHaskellDepends = [ - base bytestring doctest primitive QuickCheck random tasty - tasty-hunit tasty-quickcheck vector - ]; - benchmarkHaskellDepends = [ - base gauge mersenne-random random vector - ]; - doCheck = false; - description = "Fast, high quality pseudo random number generation"; - license = lib.licenses.bsd3; - }) {}; - - "mwc-random_0_15_0_2" = callPackage ({ mkDerivation, base, bytestring, doctest, gauge, math-functions , mersenne-random, primitive, QuickCheck, random, tasty , tasty-hunit, tasty-quickcheck, time, vector @@ -184751,7 +184624,6 @@ self: { doCheck = false; description = "Fast, high quality pseudo random number generation"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "mwc-random-accelerate" = callPackage @@ -185847,19 +185719,17 @@ self: { }: mkDerivation { pname = "nanovg"; - version = "0.7.0.0"; - sha256 = "1mrn5dy05nl5kkxw5vfgf57wifllq7jnv0akd1wi9wnlgvvqjnqz"; + version = "0.8.0.0"; + sha256 = "1il4305wv7f53225jv5s04nf7gf5rw6cfxm8j3v1di2xvhdingz5"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ base bytestring containers text vector ]; - librarySystemDepends = [ freetype glew libGL libGLU libX11 ]; - libraryPkgconfigDepends = [ glew ]; + librarySystemDepends = [ glew libGL libGLU libX11 ]; + libraryPkgconfigDepends = [ freetype glew ]; libraryToolDepends = [ c2hs ]; testHaskellDepends = [ base containers hspec inline-c QuickCheck ]; description = "Haskell bindings for nanovg"; license = lib.licenses.isc; - hydraPlatforms = lib.platforms.none; - broken = true; }) {inherit (pkgs) freetype; inherit (pkgs) glew; inherit (pkgs) libGL; inherit (pkgs) libGLU; inherit (pkgs.xorg) libX11;}; @@ -185879,7 +185749,6 @@ self: { ]; description = "Simple interface to rendering with NanoVG"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "nanq" = callPackage @@ -187049,19 +186918,6 @@ self: { }) {}; "netlib-comfort-array" = callPackage - ({ mkDerivation, base, comfort-array, netlib-ffi, transformers }: - mkDerivation { - pname = "netlib-comfort-array"; - version = "0.0.0.1"; - sha256 = "0v4p1l8gjqkxncjrp6bv664x6xs3y6n5h76pvgccsja5rammwbp3"; - libraryHaskellDepends = [ - base comfort-array netlib-ffi transformers - ]; - description = "Helper modules for comfort-array wrappers to BLAS and LAPACK"; - license = lib.licenses.bsd3; - }) {}; - - "netlib-comfort-array_0_0_0_2" = callPackage ({ mkDerivation, base, comfort-array, netlib-ffi, transformers }: mkDerivation { pname = "netlib-comfort-array"; @@ -187072,7 +186928,6 @@ self: { ]; description = "Helper modules for comfort-array wrappers to BLAS and LAPACK"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "netlib-ffi" = callPackage @@ -190578,6 +190433,22 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "not-prelude" = callPackage + ({ mkDerivation, base-noprelude, data-default, exceptions, failable + , mtl, text, transformers + }: + mkDerivation { + pname = "not-prelude"; + version = "0.1.0.0"; + sha256 = "0hb3ri6g1v21wi3saaai56b1a2r76g2dgaa7xqqchi31lh004131"; + libraryHaskellDepends = [ + base-noprelude data-default exceptions failable mtl text + transformers + ]; + description = "An opinionated Prelude replacement library"; + license = lib.licenses.mit; + }) {}; + "notcpp" = callPackage ({ mkDerivation, base, template-haskell }: mkDerivation { @@ -193349,34 +193220,6 @@ self: { }) {}; "opaleye" = 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-locale-compat, transformers, uuid - , void - }: - mkDerivation { - pname = "opaleye"; - version = "0.7.3.0"; - sha256 = "0ls8hk8iy47hna1y7kbakzv9ihp61lv605f1ap4di95fv03wy288"; - libraryHaskellDepends = [ - aeson base base16-bytestring bytestring case-insensitive - contravariant postgresql-simple pretty product-profunctors - profunctors scientific semigroups text time 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 transformers uuid - ]; - testToolDepends = [ hspec-discover ]; - description = "An SQL-generating DSL targeting PostgreSQL"; - license = lib.licenses.bsd3; - }) {}; - - "opaleye_0_7_4_0" = callPackage ({ mkDerivation, aeson, base, base16-bytestring, bytestring , case-insensitive, containers, contravariant, dotenv, hspec , hspec-discover, multiset, postgresql-simple, pretty @@ -193402,7 +193245,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "An SQL-generating DSL targeting PostgreSQL"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "opaleye-classy" = callPackage @@ -197108,7 +196950,7 @@ self: { maintainers = with lib.maintainers; [ peti ]; }) {}; - "pandoc_2_14_1" = callPackage + "pandoc_2_14_2" = callPackage ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base , base64-bytestring, binary, blaze-html, blaze-markup, bytestring , case-insensitive, citeproc, commonmark, commonmark-extensions @@ -197116,19 +196958,19 @@ self: { , Diff, directory, doclayout, doctemplates, emojis, exceptions , file-embed, filepath, Glob, haddock-library, hslua , hslua-module-path, hslua-module-system, hslua-module-text, HsYAML - , HTTP, http-client, http-client-tls, http-types, ipynb - , jira-wiki-markup, JuicyPixels, mtl, network, network-uri - , pandoc-types, parsec, process, QuickCheck, random, safe - , scientific, 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 - , unordered-containers, xml, xml-conduit, zip-archive, zlib + , http-client, http-client-tls, http-types, ipynb, jira-wiki-markup + , JuicyPixels, mtl, network, network-uri, pandoc-types, parsec + , process, QuickCheck, random, safe, scientific, 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, unordered-containers, xml, xml-conduit + , zip-archive, zlib }: mkDerivation { pname = "pandoc"; - version = "2.14.1"; - sha256 = "1jj011az45zpd201f3dwb90m22p60nv5bmpbh39li885xwv46qyq"; + version = "2.14.2"; + sha256 = "1bjw5di5dwfpnxgkj2qmri8f1nv6yin23cd8s38chwan29vd7xrc"; configureFlags = [ "-fhttps" "-f-trypandoc" ]; isLibrary = true; isExecutable = true; @@ -197139,7 +196981,7 @@ self: { commonmark commonmark-extensions commonmark-pandoc connection containers data-default deepseq directory doclayout doctemplates emojis exceptions file-embed filepath Glob haddock-library hslua - hslua-module-path hslua-module-system hslua-module-text HsYAML HTTP + hslua-module-path hslua-module-system hslua-module-text HsYAML http-client http-client-tls http-types ipynb jira-wiki-markup JuicyPixels mtl network network-uri pandoc-types parsec process random safe scientific SHA skylighting skylighting-core split syb @@ -197575,6 +197417,41 @@ self: { license = lib.licenses.gpl2Plus; }) {}; + "pandoc-plot_1_3_0" = callPackage + ({ mkDerivation, base, bytestring, containers, criterion + , data-default, directory, filepath, gitrev, hashable, hspec + , 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.3.0"; + sha256 = "0d33cbw0ygsdwh718q7q5gw2s6565dbrjwi3rz0qdf78q14wiayi"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + 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 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; + hydraPlatforms = lib.platforms.none; + }) {}; + "pandoc-pyplot" = callPackage ({ mkDerivation, base, containers, data-default-class, deepseq , directory, filepath, hashable, hspec, hspec-expectations, mtl @@ -199759,7 +199636,9 @@ self: { ]; description = "Hashing and checking of passwords"; license = lib.licenses.bsd3; - platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ]; + platforms = [ + "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; maintainers = with lib.maintainers; [ cdepillabout ]; }) {}; @@ -199784,7 +199663,9 @@ self: { ]; description = "typeclass instances for password package"; license = lib.licenses.bsd3; - platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ]; + platforms = [ + "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; maintainers = with lib.maintainers; [ cdepillabout ]; }) {}; @@ -200787,24 +200668,25 @@ self: { license = lib.licenses.asl20; }) {}; - "pcre2_2_0_0" = callPackage - ({ mkDerivation, base, containers, criterion, hspec + "pcre2_2_0_1" = callPackage + ({ mkDerivation, base, containers, criterion, hspec, microlens , microlens-platform, mtl, pcre-light, regex-pcre-builtin , template-haskell, text }: mkDerivation { pname = "pcre2"; - version = "2.0.0"; - sha256 = "1jkyc2s3x5n7zrw9b78gk8jj262xfmg8cva2gr7mlzzl0hd9r11y"; + version = "2.0.1"; + sha256 = "0f93z99qhlhyvq7xsfn0nap9cxpxg2hs7790jqc5hi5kmqxlwvmy"; libraryHaskellDepends = [ - base containers mtl template-haskell text + base containers microlens mtl template-haskell text ]; testHaskellDepends = [ - base containers hspec microlens-platform mtl template-haskell text + base containers hspec microlens microlens-platform mtl + template-haskell text ]; benchmarkHaskellDepends = [ - base containers criterion microlens-platform mtl pcre-light - regex-pcre-builtin template-haskell text + 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; @@ -201959,7 +201841,9 @@ self: { ]; description = "Serialization library with state and leb128 encoding"; license = lib.licenses.bsd3; - platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ]; + platforms = [ + "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; }) {}; "persist2er" = callPackage @@ -204517,8 +204401,8 @@ self: { }: mkDerivation { pname = "pinned-warnings"; - version = "0.1.0.6"; - sha256 = "1n0h2v71x3j0wn0g2f3zq3xw681s16hl7ffywi83z50hacd8x6kx"; + version = "0.1.0.8"; + sha256 = "0ky5lqvf1bfbjzblqgnj47jhkxw4fb7gz7k268hnf41gfnbsy3i4"; libraryHaskellDepends = [ base bytestring containers directory ghc time transformers ]; @@ -212007,27 +211891,6 @@ self: { }) {inherit (pkgs) primesieve;}; "primitive" = callPackage - ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck - , quickcheck-classes-base, semigroups, tagged, tasty - , tasty-quickcheck, transformers, transformers-compat - }: - mkDerivation { - pname = "primitive"; - version = "0.7.1.0"; - sha256 = "1w53i4mk248g58xrffmksznr4nmn2bbbycajzpcqfxx5ybyyrsvb"; - revision = "3"; - editedCabalFile = "03vgkhib8w3g0m0zwpz74hsixrf0pvgh6ql0xcy05fpq1kynppi9"; - libraryHaskellDepends = [ base deepseq transformers ]; - testHaskellDepends = [ - base base-orphans ghc-prim QuickCheck quickcheck-classes-base - semigroups tagged tasty tasty-quickcheck transformers - transformers-compat - ]; - description = "Primitive memory-related operations"; - license = lib.licenses.bsd3; - }) {}; - - "primitive_0_7_2_0" = callPackage ({ mkDerivation, base, base-orphans, deepseq, ghc-prim, QuickCheck , quickcheck-classes-base, tagged, tasty, tasty-quickcheck , transformers, transformers-compat @@ -212043,7 +211906,6 @@ self: { ]; description = "Primitive memory-related operations"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "primitive-addr" = callPackage @@ -224878,21 +224740,6 @@ self: { }) {}; "replace-attoparsec" = callPackage - ({ mkDerivation, attoparsec, base, bytestring, Cabal, parsers, text - }: - mkDerivation { - pname = "replace-attoparsec"; - version = "1.4.4.0"; - sha256 = "06js4adbzvm2qn18vlaaxhav2dq1hqp825lmsvpg69cylp72fzif"; - 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_4_5_0" = callPackage ({ mkDerivation, attoparsec, base, bytestring, Cabal, parsers, text }: mkDerivation { @@ -224905,7 +224752,6 @@ self: { ]; description = "Find, replace, and split string patterns with Attoparsec parsers (instead of regex)"; license = lib.licenses.bsd2; - hydraPlatforms = lib.platforms.none; }) {}; "replace-megaparsec" = callPackage @@ -225197,32 +225043,6 @@ self: { }) {}; "req-conduit" = callPackage - ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec - , http-client, req, resourcet, temporary, transformers, weigh - }: - mkDerivation { - pname = "req-conduit"; - version = "1.0.0"; - sha256 = "193bv4jp7rrbpb1i9as9s2l978wz5kbz5kvr7ppllif5ppj699qx"; - revision = "8"; - editedCabalFile = "1md7zajmw87qrx6rvs35yrkbjs3s9nm0akg35jmf7a34xccrr7a7"; - libraryHaskellDepends = [ - base bytestring conduit http-client req resourcet transformers - ]; - testHaskellDepends = [ - base bytestring conduit conduit-extra hspec req resourcet temporary - transformers - ]; - benchmarkHaskellDepends = [ - base bytestring conduit conduit-extra req resourcet temporary weigh - ]; - description = "Conduit helpers for the req HTTP client library"; - license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; - broken = true; - }) {}; - - "req-conduit_1_0_1" = callPackage ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec , hspec-discover, http-client, req, resourcet, temporary , transformers, weigh @@ -225725,22 +225545,6 @@ self: { }) {}; "resourcet" = callPackage - ({ mkDerivation, base, containers, exceptions, hspec, mtl - , primitive, transformers, unliftio-core - }: - mkDerivation { - pname = "resourcet"; - version = "1.2.4.2"; - sha256 = "11zb4figcs22hjaq6zsknf70kf9k2bxnw6w03ab9kl9s0i10iwhp"; - libraryHaskellDepends = [ - base containers exceptions mtl primitive transformers unliftio-core - ]; - testHaskellDepends = [ base exceptions hspec transformers ]; - description = "Deterministic allocation and freeing of scarce resources"; - license = lib.licenses.bsd3; - }) {}; - - "resourcet_1_2_4_3" = callPackage ({ mkDerivation, base, containers, exceptions, hspec, mtl , primitive, transformers, unliftio-core }: @@ -225754,7 +225558,6 @@ self: { testHaskellDepends = [ base exceptions hspec transformers ]; description = "Deterministic allocation and freeing of scarce resources"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "resourcet-pool" = callPackage @@ -226221,6 +226024,47 @@ self: { license = lib.licenses.mit; }) {}; + "retroclash-lib" = callPackage + ({ mkDerivation, barbies, base, clash-ghc, clash-lib, clash-prelude + , containers, ghc-typelits-extra, ghc-typelits-knownnat + , ghc-typelits-natnormalise, lens, lift-type, monoidal-containers + , mtl, template-haskell, transformers + }: + mkDerivation { + pname = "retroclash-lib"; + version = "0.1.0"; + sha256 = "062pjqhba41d4bb9gb8wxpd87mpsmzj3np8y9ymagjrnv5iyaf5w"; + libraryHaskellDepends = [ + barbies base clash-ghc clash-lib clash-prelude containers + ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise + lens lift-type monoidal-containers mtl template-haskell + transformers + ]; + description = "Code shared across the code samples in the book \"Retrocomputing with Clash\""; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + + "retroclash-sim" = callPackage + ({ mkDerivation, array, arrows, base, clash-ghc, clash-lib + , clash-prelude, ghc-typelits-extra, ghc-typelits-knownnat + , ghc-typelits-natnormalise, lens, mtl, retroclash-lib, sdl2, text + , transformers + }: + mkDerivation { + pname = "retroclash-sim"; + version = "0.1.0"; + sha256 = "1wv8is17ds9y49an832dlgixly9b98h8x6ybc5dj7zzf1jwplyp8"; + libraryHaskellDepends = [ + array arrows base clash-ghc clash-lib clash-prelude + ghc-typelits-extra ghc-typelits-knownnat ghc-typelits-natnormalise + lens mtl retroclash-lib sdl2 text transformers + ]; + description = "High-level simulators from the book \"Retrocomputing with Clash\""; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "retry" = callPackage ({ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, mtl , random, stm, tasty, tasty-hedgehog, tasty-hunit, time @@ -227164,32 +227008,6 @@ self: { }) {}; "rio" = callPackage - ({ mkDerivation, base, bytestring, containers, deepseq, directory - , exceptions, filepath, hashable, hspec, microlens, microlens-mtl - , mtl, primitive, process, QuickCheck, text, time, typed-process - , unix, unliftio, unliftio-core, unordered-containers, vector - }: - mkDerivation { - pname = "rio"; - version = "0.1.20.0"; - sha256 = "0x5b5c0y97b5n1lvbcsqlkhbv4nbbznx1w1fp3a17a03pz7qf61s"; - libraryHaskellDepends = [ - base bytestring containers deepseq directory exceptions filepath - hashable microlens microlens-mtl mtl primitive process text time - typed-process unix unliftio unliftio-core unordered-containers - vector - ]; - testHaskellDepends = [ - base bytestring containers deepseq directory exceptions filepath - hashable hspec microlens microlens-mtl mtl primitive process - QuickCheck text time typed-process unix unliftio unliftio-core - unordered-containers vector - ]; - description = "A standard library for Haskell"; - license = lib.licenses.mit; - }) {}; - - "rio_0_1_21_0" = callPackage ({ mkDerivation, base, bytestring, containers, deepseq, directory , exceptions, filepath, hashable, hspec, hspec-discover, microlens , microlens-mtl, mtl, primitive, process, QuickCheck, text, time @@ -227215,7 +227033,6 @@ self: { testToolDepends = [ hspec-discover ]; description = "A standard library for Haskell"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "rio-app" = callPackage @@ -231350,7 +231167,8 @@ self: { description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; hydraPlatforms = lib.platforms.none; }) {inherit (pkgs) z3;}; @@ -231385,10 +231203,47 @@ self: { description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving"; license = lib.licenses.bsd3; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; }) {inherit (pkgs) z3;}; + "sbv_8_16" = callPackage + ({ mkDerivation, array, async, base, bench-show, bytestring + , containers, deepseq, directory, doctest, filepath, gauge, Glob + , hlint, libBF, mtl, pretty, process, QuickCheck, random, silently + , syb, tasty, tasty-golden, tasty-hunit, tasty-quickcheck + , template-haskell, text, time, transformers, uniplate, z3 + }: + mkDerivation { + pname = "sbv"; + version = "8.16"; + sha256 = "1jmcc9qz659my5i3ir6lq34zfbjp9wcnq61fppic1hlwm39qjppd"; + 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 doctest filepath Glob hlint + mtl QuickCheck random tasty tasty-golden tasty-hunit + tasty-quickcheck + ]; + testSystemDepends = [ z3 ]; + benchmarkHaskellDepends = [ + base bench-show containers deepseq directory filepath gauge mtl + process random silently syb text time + ]; + description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving"; + license = lib.licenses.bsd3; + platforms = [ + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" + ]; + hydraPlatforms = lib.platforms.none; + }) {inherit (pkgs) z3;}; + "sbvPlugin" = callPackage ({ mkDerivation, base, containers, directory, filepath, ghc , ghc-prim, mtl, process, sbv, tasty, tasty-golden @@ -231748,7 +231603,9 @@ self: { ]; description = "Generates unique passwords for various websites from a single password"; license = lib.licenses.bsd3; - platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ]; + platforms = [ + "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; }) {}; "scc" = callPackage @@ -232931,7 +232788,9 @@ self: { ]; description = "Stronger password hashing via sequential memory-hard functions"; license = lib.licenses.bsd3; - platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ]; + platforms = [ + "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; }) {}; "scrz" = callPackage @@ -240294,6 +240153,30 @@ self: { broken = true; }) {}; + "shortbytestring" = callPackage + ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim + , primitive, random, tasty, tasty-bench, tasty-quickcheck + , template-haskell, text, word16, word8 + }: + mkDerivation { + pname = "shortbytestring"; + version = "0.1.0.0"; + sha256 = "1wjk73xlrk0qgnn8j53ngnikh034v295mm7w9nqadvwg9y3absfy"; + libraryHaskellDepends = [ + base bytestring exceptions primitive template-haskell text word16 + word8 + ]; + testHaskellDepends = [ + base bytestring deepseq ghc-prim tasty tasty-quickcheck word16 + word8 + ]; + benchmarkHaskellDepends = [ + base bytestring deepseq random tasty-bench + ]; + description = "Additional ShortByteString API"; + license = lib.licenses.mit; + }) {}; + "shortcircuit" = callPackage ({ mkDerivation, base }: mkDerivation { @@ -246608,6 +246491,18 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "some-dict-of" = callPackage + ({ mkDerivation, base, constraints }: + mkDerivation { + pname = "some-dict-of"; + version = "0.1.0.0"; + sha256 = "0c7gr41fqak777wnh0q81mkpv89j6m1q3qqca5r2mzqhkqli4d4d"; + libraryHaskellDepends = [ base constraints ]; + testHaskellDepends = [ base constraints ]; + description = "Carry evidence of constraints around"; + license = lib.licenses.bsd3; + }) {}; + "sonic-visualiser" = callPackage ({ mkDerivation, array, base, bytestring, bzlib, containers, mtl , pretty, utf8-string, xml @@ -248861,6 +248756,8 @@ self: { pname = "srt-dhall"; version = "0.1.0.0"; sha256 = "16ygxiqb9d0js3gr4823fdkk8pzsairby6iywnvsafas1qvhm0yp"; + revision = "1"; + editedCabalFile = "0y1x65mmhsa78svk19nwf7211fny9c4w3gf9d31d10j9bglyly8f"; libraryHaskellDepends = [ attoparsec base dhall either formatting simple-media-timestamp simple-media-timestamp-formatting srt srt-attoparsec srt-formatting @@ -251915,54 +251812,6 @@ self: { }) {}; "store" = callPackage - ({ mkDerivation, array, async, base, base-orphans - , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector - , clock, containers, contravariant, criterion, cryptohash, deepseq - , directory, filepath, free, ghc-prim, hashable, hspec - , hspec-smallcheck, integer-gmp, lifted-base, monad-control - , mono-traversable, nats, network, primitive, resourcet, safe - , smallcheck, store-core, syb, template-haskell, text, th-lift - , th-lift-instances, th-orphans, th-reify-many, th-utilities, time - , transformers, unordered-containers, vector - , vector-binary-instances, void, weigh - }: - mkDerivation { - pname = "store"; - version = "0.7.11"; - sha256 = "03i9gd18xqbfmj5kmiv4k4sw44gn6mn4faj71r2723abm3qwklwr"; - libraryHaskellDepends = [ - array async base base-orphans base64-bytestring bifunctors - bytestring containers contravariant cryptohash deepseq directory - filepath free ghc-prim hashable hspec hspec-smallcheck integer-gmp - lifted-base monad-control mono-traversable nats network primitive - resourcet safe smallcheck store-core syb template-haskell text - th-lift th-lift-instances th-orphans th-reify-many th-utilities - time transformers unordered-containers vector void - ]; - testHaskellDepends = [ - array async base base-orphans base64-bytestring bifunctors - bytestring clock containers contravariant cryptohash deepseq - directory filepath free ghc-prim hashable hspec hspec-smallcheck - integer-gmp lifted-base monad-control mono-traversable nats network - primitive resourcet safe smallcheck store-core syb template-haskell - text th-lift th-lift-instances th-orphans th-reify-many - th-utilities time transformers unordered-containers vector void - ]; - benchmarkHaskellDepends = [ - array async base base-orphans base64-bytestring bifunctors - bytestring cereal cereal-vector containers contravariant criterion - cryptohash deepseq directory filepath free ghc-prim hashable hspec - hspec-smallcheck integer-gmp lifted-base monad-control - mono-traversable nats network primitive resourcet safe smallcheck - store-core syb template-haskell text th-lift th-lift-instances - th-orphans th-reify-many th-utilities time transformers - unordered-containers vector vector-binary-instances void weigh - ]; - description = "Fast binary serialization"; - license = lib.licenses.mit; - }) {}; - - "store_0_7_12" = callPackage ({ mkDerivation, array, async, base, base-orphans , base64-bytestring, bifunctors, bytestring, cereal, cereal-vector , clock, containers, contravariant, criterion, cryptohash, deepseq @@ -252008,7 +251857,6 @@ self: { ]; description = "Fast binary serialization"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "store-core" = callPackage @@ -259523,6 +259371,24 @@ self: { license = lib.licenses.mit; }) {}; + "tasty_1_4_2" = callPackage + ({ mkDerivation, ansi-terminal, base, clock, containers, mtl + , optparse-applicative, stm, tagged, unbounded-delays, unix + , wcwidth + }: + mkDerivation { + pname = "tasty"; + version = "1.4.2"; + sha256 = "0574hbqzxzyv6vsk5kzbf04kz58y0iy8x9ydcj4b8fpncgmgy63g"; + libraryHaskellDepends = [ + ansi-terminal base clock containers mtl optparse-applicative stm + tagged unbounded-delays unix wcwidth + ]; + description = "Modern and extensible testing framework"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "tasty-ant-xml" = callPackage ({ mkDerivation, base, containers, directory, filepath , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers @@ -259636,17 +259502,6 @@ self: { }) {}; "tasty-dejafu" = callPackage - ({ mkDerivation, base, dejafu, random, tagged, tasty }: - mkDerivation { - pname = "tasty-dejafu"; - version = "2.0.0.7"; - sha256 = "0jzaqra7gsrvy33j1g6bnrwg7x5pyg5p50l5mgvpz71kd946725l"; - libraryHaskellDepends = [ base dejafu random tagged tasty ]; - description = "Deja Fu support for the Tasty test framework"; - license = lib.licenses.mit; - }) {}; - - "tasty-dejafu_2_0_0_8" = callPackage ({ mkDerivation, base, dejafu, random, tagged, tasty }: mkDerivation { pname = "tasty-dejafu"; @@ -259655,7 +259510,6 @@ self: { libraryHaskellDepends = [ base dejafu random tagged tasty ]; description = "Deja Fu support for the Tasty test framework"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "tasty-discover" = callPackage @@ -262910,28 +262764,6 @@ self: { }) {}; "texmath" = callPackage - ({ mkDerivation, base, bytestring, containers, directory, filepath - , mtl, pandoc-types, parsec, process, split, syb, temporary, text - , utf8-string, xml - }: - mkDerivation { - pname = "texmath"; - version = "0.12.3"; - sha256 = "0lhbgnswhss56lrp25i70hvmn6zg6xcfwdigfmwjggmhz0h5q88x"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - base containers mtl pandoc-types parsec split syb text xml - ]; - testHaskellDepends = [ - base bytestring directory filepath process temporary text - utf8-string xml - ]; - description = "Conversion between formats used to represent mathematics"; - license = lib.licenses.gpl2Only; - }) {}; - - "texmath_0_12_3_1" = callPackage ({ mkDerivation, base, bytestring, containers, directory, filepath , mtl, pandoc-types, parsec, process, split, syb, temporary, text , utf8-string, xml @@ -262951,7 +262783,6 @@ self: { ]; description = "Conversion between formats used to represent mathematics"; license = lib.licenses.gpl2Only; - hydraPlatforms = lib.platforms.none; }) {}; "texrunner" = callPackage @@ -263457,6 +263288,22 @@ self: { license = lib.licenses.bsd3; }) {}; + "text-metrics_0_3_1" = callPackage + ({ mkDerivation, base, containers, criterion, deepseq, hspec + , QuickCheck, text, vector, weigh + }: + mkDerivation { + pname = "text-metrics"; + version = "0.3.1"; + sha256 = "17bp1lnbkqr5ykrcd6v5sqv0fhljck7hky8zrrpw7rlkb1f3sdc2"; + libraryHaskellDepends = [ base containers text vector ]; + testHaskellDepends = [ base hspec QuickCheck text ]; + benchmarkHaskellDepends = [ base criterion deepseq text weigh ]; + description = "Calculate various string metrics efficiently"; + license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + }) {}; + "text-normal" = callPackage ({ mkDerivation, base, deepseq, hspec, QuickCheck , quickcheck-instances, text, text-icu @@ -265577,6 +265424,28 @@ self: { license = lib.licenses.bsd3; }) {}; + "ticket-management" = callPackage + ({ mkDerivation, base, bytestring, cereal, containers, directory + , optparse-applicative, QuickCheck, text, time, unliftio + }: + mkDerivation { + pname = "ticket-management"; + version = "0.2.0.0"; + sha256 = "0cbdkjjh2sfsj4cjgxvxjrva6rb0gli36q3g8idhwf7wa2llyz4w"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring cereal containers directory optparse-applicative + QuickCheck text time unliftio + ]; + executableHaskellDepends = [ base ]; + testHaskellDepends = [ base QuickCheck text ]; + description = "A basic implementation of a personal ticket management system"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + broken = true; + }) {}; + "tickle" = callPackage ({ mkDerivation, base, bifunctors, bytestring, checkers, filepath , lens, mtl, papa, QuickCheck, semigroupoids, semigroups, tasty @@ -267088,27 +266957,6 @@ self: { }) {}; "tldr" = callPackage - ({ mkDerivation, ansi-terminal, base, bytestring, cmark, containers - , directory, filepath, http-conduit, optparse-applicative - , semigroups, tasty, tasty-golden, text, time, zip-archive - }: - mkDerivation { - pname = "tldr"; - version = "0.9.0"; - sha256 = "0dixx8i6ka3ksfcr6bjybs1i3ry0wpiffsmskh56cxxcys0jgm5h"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - ansi-terminal base bytestring cmark containers directory filepath - http-conduit optparse-applicative semigroups text time zip-archive - ]; - executableHaskellDepends = [ base ]; - testHaskellDepends = [ base tasty tasty-golden ]; - description = "Haskell tldr client"; - license = lib.licenses.bsd3; - }) {}; - - "tldr_0_9_1" = callPackage ({ mkDerivation, ansi-terminal, base, bytestring, cmark, containers , directory, filepath, http-conduit, optparse-applicative , semigroups, tasty, tasty-golden, text, time, zip-archive @@ -267127,7 +266975,6 @@ self: { testHaskellDepends = [ base tasty tasty-golden ]; description = "Haskell tldr client"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "tlex" = callPackage @@ -269120,23 +268967,6 @@ self: { }) {}; "transformers-base" = callPackage - ({ mkDerivation, base, base-orphans, stm, transformers - , transformers-compat - }: - mkDerivation { - pname = "transformers-base"; - version = "0.4.5.2"; - sha256 = "1s256bi0yh0x2hp2gwd30f3mg1cv53zz397dv1yhfsnfzmihrj6h"; - revision = "1"; - editedCabalFile = "18j122ypx12rbl9bbf622fvj8nif4rsci8z4qw2llmznbvfl09s0"; - libraryHaskellDepends = [ - base base-orphans stm transformers transformers-compat - ]; - description = "Lift computations from the bottom of a transformer stack"; - license = lib.licenses.bsd3; - }) {}; - - "transformers-base_0_4_6" = callPackage ({ mkDerivation, base, base-orphans, stm, transformers , transformers-compat }: @@ -269149,7 +268979,6 @@ self: { ]; description = "Lift computations from the bottom of a transformer stack"; license = lib.licenses.bsd3; - hydraPlatforms = lib.platforms.none; }) {}; "transformers-bifunctors" = callPackage @@ -270833,6 +270662,23 @@ self: { license = lib.licenses.mit; }) {}; + "ttc_1_1_0_2" = callPackage + ({ mkDerivation, base, bytestring, tasty, tasty-hunit + , template-haskell, text + }: + mkDerivation { + pname = "ttc"; + version = "1.1.0.2"; + sha256 = "0i1jnign6xb0i4y5rkwz2rp2lj7q3r50i4bkjghz8i2djw2sd1cw"; + libraryHaskellDepends = [ base bytestring template-haskell text ]; + testHaskellDepends = [ + base bytestring tasty tasty-hunit template-haskell text + ]; + description = "Textual Type Classes"; + license = lib.licenses.mit; + hydraPlatforms = lib.platforms.none; + }) {}; + "ttl-hashtables" = callPackage ({ mkDerivation, base, clock, containers, data-default, failable , hashable, hashtables, hspec, mtl, transformers @@ -272211,20 +272057,6 @@ self: { }) {}; "type-errors-pretty" = callPackage - ({ mkDerivation, base, doctest, Glob }: - mkDerivation { - pname = "type-errors-pretty"; - version = "0.0.1.1"; - sha256 = "1z6rqah3qnvnlckcw3xhsp4yyfd21harw6kzqbz20y6k7a22jlf0"; - revision = "1"; - editedCabalFile = "1qfm0018ids9s7kdwf6d3r1cwnb5aqn55in4vdwklas3ydi8mmrx"; - libraryHaskellDepends = [ base ]; - testHaskellDepends = [ base doctest Glob ]; - description = "Combinators for writing pretty type errors easily"; - license = lib.licenses.mpl20; - }) {}; - - "type-errors-pretty_0_0_1_2" = callPackage ({ mkDerivation, base, doctest, Glob }: mkDerivation { pname = "type-errors-pretty"; @@ -272234,7 +272066,6 @@ self: { testHaskellDepends = [ base doctest Glob ]; description = "Combinators for writing pretty type errors easily"; license = lib.licenses.mpl20; - hydraPlatforms = lib.platforms.none; }) {}; "type-fun" = callPackage @@ -272901,25 +272732,6 @@ self: { }) {}; "typed-process" = callPackage - ({ mkDerivation, async, base, base64-bytestring, bytestring, hspec - , process, stm, temporary, transformers, unliftio-core - }: - mkDerivation { - pname = "typed-process"; - version = "0.2.6.0"; - sha256 = "1cf2pfym8zdxvvy7xv72ixj7wy3rjrdss6f57k1ysgs66cgsi8ii"; - libraryHaskellDepends = [ - async base bytestring process stm transformers unliftio-core - ]; - testHaskellDepends = [ - async base base64-bytestring bytestring hspec process stm temporary - transformers unliftio-core - ]; - description = "Run external processes, with strong typing of streams"; - license = lib.licenses.mit; - }) {}; - - "typed-process_0_2_6_1" = callPackage ({ mkDerivation, async, base, base64-bytestring, bytestring, hspec , process, stm, temporary, transformers, unliftio-core }: @@ -272936,7 +272748,6 @@ self: { ]; description = "Run external processes, with strong typing of streams"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "typed-spreadsheet" = callPackage @@ -278219,6 +278030,22 @@ self: { broken = true; }) {}; + "valida" = callPackage + ({ mkDerivation, base, smallcheck, tasty, tasty-hunit + , tasty-quickcheck, tasty-smallcheck + }: + mkDerivation { + pname = "valida"; + version = "0.1.0"; + sha256 = "1spdf40jcm9b6ah18m5nw550x2mlq4bjmqvscf4cnjpc7izdmdng"; + libraryHaskellDepends = [ base ]; + testHaskellDepends = [ + base smallcheck tasty tasty-hunit tasty-quickcheck tasty-smallcheck + ]; + description = "Simple applicative validation for product types, batteries included!"; + license = lib.licenses.mit; + }) {}; + "validate" = callPackage ({ mkDerivation }: mkDerivation { @@ -279814,7 +279641,8 @@ self: { description = "An intermediate language for Hoare logic style verification"; license = lib.licenses.asl20; platforms = [ - "armv7l-linux" "i686-linux" "x86_64-darwin" "x86_64-linux" + "aarch64-darwin" "armv7l-linux" "i686-linux" "x86_64-darwin" + "x86_64-linux" ]; }) {}; @@ -281116,8 +280944,8 @@ self: { }: mkDerivation { pname = "vulkan"; - version = "3.12.1"; - sha256 = "0y9ykv0dx5hvh2683yyn8mdl3jxqk9zaf2a1rkyr5zgc43wsbm05"; + version = "3.12.2"; + sha256 = "1vypjnwvvvd0rw99qsb00jnwpq792s9x1wi62zdyzq9cwlf47ici"; libraryHaskellDepends = [ base bytestring transformers vector ]; libraryPkgconfigDepends = [ vulkan ]; testHaskellDepends = [ @@ -281979,43 +281807,6 @@ self: { }) {}; "wai-middleware-auth" = callPackage - ({ mkDerivation, aeson, base, base64-bytestring, binary - , blaze-builder, blaze-html, bytestring, case-insensitive, cereal - , clientsession, cookie, exceptions, hedgehog, hoauth2, http-client - , http-client-tls, http-conduit, http-reverse-proxy, http-types - , jose, microlens, mtl, optparse-applicative, optparse-simple - , regex-posix, safe-exceptions, shakespeare, tasty, tasty-hedgehog - , tasty-hunit, text, time, unix-compat, unordered-containers - , uri-bytestring, vault, wai, wai-app-static, wai-extra, warp, yaml - }: - mkDerivation { - pname = "wai-middleware-auth"; - version = "0.2.5.0"; - sha256 = "12yv8rcybd7saflfcyjy08p1m6il07nk831pkj0isxk8mwjq64l4"; - isLibrary = true; - isExecutable = true; - libraryHaskellDepends = [ - aeson base base64-bytestring binary blaze-builder blaze-html - bytestring case-insensitive cereal clientsession cookie exceptions - hoauth2 http-client http-client-tls http-conduit http-reverse-proxy - http-types jose microlens mtl regex-posix safe-exceptions - shakespeare text time unix-compat unordered-containers - uri-bytestring vault wai wai-app-static wai-extra yaml - ]; - executableHaskellDepends = [ - base bytestring cereal clientsession optparse-applicative - optparse-simple wai-extra warp - ]; - testHaskellDepends = [ - aeson base binary bytestring clientsession cookie hedgehog hoauth2 - http-types jose microlens mtl tasty tasty-hedgehog tasty-hunit text - time uri-bytestring wai wai-extra warp - ]; - description = "Authentication middleware that secures WAI application"; - license = lib.licenses.mit; - }) {}; - - "wai-middleware-auth_0_2_5_1" = callPackage ({ mkDerivation, aeson, base, base64-bytestring, binary , blaze-builder, blaze-html, bytestring, case-insensitive, cereal , clientsession, cookie, exceptions, hedgehog, hoauth2, http-client @@ -282050,7 +281841,6 @@ self: { ]; description = "Authentication middleware that secures WAI application"; license = lib.licenses.mit; - hydraPlatforms = lib.platforms.none; }) {}; "wai-middleware-brotli" = callPackage @@ -285217,16 +285007,35 @@ self: { hydraPlatforms = lib.platforms.none; }) {}; + "wgpu-hs" = callPackage + ({ mkDerivation, base, bytestring, data-default, GLFW-b, text + , transformers, vector, wgpu-raw-hs + }: + mkDerivation { + pname = "wgpu-hs"; + version = "0.2.0.0"; + sha256 = "1kc5xmknfhh9dmn90rbnplmx8n7f07xwvrvz7dcybjpiw8pr2dml"; + isLibrary = true; + isExecutable = true; + libraryHaskellDepends = [ + base bytestring data-default GLFW-b text transformers vector + wgpu-raw-hs + ]; + executableHaskellDepends = [ + base data-default GLFW-b text transformers + ]; + doHaddock = false; + description = "WGPU"; + license = lib.licenses.bsd3; + }) {}; + "wgpu-raw-hs" = callPackage ({ mkDerivation, base, GLFW-b, unix }: mkDerivation { pname = "wgpu-raw-hs"; - version = "0.1.0.2"; - sha256 = "1hagn99jdmwjcyz2afmmd9ws31dncas9fssv6lx75kshar6x4rah"; - isLibrary = true; - isExecutable = true; + version = "0.2.0.0"; + sha256 = "05dzz6q5laxw7wwhly7v5i4bppfqz4yahh8qq6qc0h2c8v0qmdzp"; libraryHaskellDepends = [ base GLFW-b unix ]; - executableHaskellDepends = [ base GLFW-b ]; description = "WGPU Raw"; license = lib.licenses.bsd3; }) {}; @@ -286365,6 +286174,22 @@ self: { license = lib.licenses.bsd3; }) {}; + "word16" = callPackage + ({ mkDerivation, base, bytestring, criterion, hspec, hspec-discover + , template-haskell, text + }: + mkDerivation { + pname = "word16"; + version = "0.1.0.0"; + sha256 = "0z2nabnh7b42bl7hqy2iw68a1gxay26pgsid7m4hs8s2d7cghndx"; + libraryHaskellDepends = [ base bytestring template-haskell text ]; + testHaskellDepends = [ base hspec ]; + testToolDepends = [ hspec-discover ]; + benchmarkHaskellDepends = [ base bytestring criterion ]; + description = "Word16 library"; + license = lib.licenses.mit; + }) {}; + "word24" = callPackage ({ mkDerivation, base, criterion, deepseq, QuickCheck , test-framework, test-framework-quickcheck2 @@ -288182,7 +288007,9 @@ self: { executableSystemDepends = [ xgboost ]; description = "XGBoost library for Haskell"; license = lib.licenses.mit; - platforms = [ "i686-linux" "x86_64-darwin" "x86_64-linux" ]; + platforms = [ + "aarch64-darwin" "i686-linux" "x86_64-darwin" "x86_64-linux" + ]; }) {inherit (pkgs) xgboost;}; "xhaskell-library" = callPackage @@ -291012,22 +290839,24 @@ self: { }) {}; "yapb" = callPackage - ({ mkDerivation, base, bytestring, directory, hashable, network - , process, regex-tdfa + ({ mkDerivation, base, bytestring, directory, hashable, hspec + , network, process, regex-tdfa }: mkDerivation { pname = "yapb"; - version = "0.1.1"; - sha256 = "1zbk2whfi09wzx9ql4dhkbg50s7v45y309avxljypg7z9i9pvx3x"; + version = "0.1.3"; + sha256 = "11p3ygnfpsh9dqlnpppi02baa5bk86pw6w6f1gawdd848qh7q9if"; isLibrary = true; isExecutable = true; libraryHaskellDepends = [ - base bytestring directory hashable network process regex-tdfa + base bytestring directory hashable hspec network process regex-tdfa ]; - executableHaskellDepends = [ base regex-tdfa ]; - testHaskellDepends = [ base ]; + executableHaskellDepends = [ base hspec regex-tdfa ]; + testHaskellDepends = [ base hspec process ]; description = "Yet Another Parser Builder (YAPB)"; license = lib.licenses.bsd3; + hydraPlatforms = lib.platforms.none; + broken = true; }) {}; "yarn-lock" = callPackage @@ -291857,7 +291686,6 @@ self: { ]; description = "A yesod-auth plugin for LTI 1.3"; license = lib.licenses.lgpl3Only; - hydraPlatforms = lib.platforms.none; }) {}; "yesod-auth-nopassword" = callPackage diff --git a/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix b/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix index 3b57693a28c1..3a356b36be9a 100644 --- a/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix +++ b/pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix @@ -1,4 +1,4 @@ -{ lib, supportedGhcVersions ? [ "884" "8106" ], stdenv, haskellPackages +{ lib, supportedGhcVersions ? [ "884" "8107" ], stdenv, haskellPackages , haskell }: # # The recommended way to override this package is diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index cba8a5eb974c..445409eb8cdf 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -1029,9 +1029,9 @@ with pkgs; }; termite-unwrapped = callPackage ../applications/terminal-emulators/termite { }; - termonad-with-packages = callPackage ../applications/terminal-emulators/termonad { - inherit (haskellPackages) ghcWithPackages; - }; + termonad-with-packages = callPackage ../applications/terminal-emulators/termonad { }; + + termonad = termonad-with-packages; termsyn = callPackage ../data/fonts/termsyn { }; @@ -11480,7 +11480,7 @@ with pkgs; # Please update doc/languages-frameworks/haskell.section.md, “Our # current default compiler is”, if you bump this: - haskellPackages = dontRecurseIntoAttrs haskell.packages.ghc8106; + haskellPackages = dontRecurseIntoAttrs haskell.packages.ghc8107; inherit (haskellPackages) ghc; diff --git a/pkgs/top-level/haskell-packages.nix b/pkgs/top-level/haskell-packages.nix index 10455405af42..1490aeda6558 100644 --- a/pkgs/top-level/haskell-packages.nix +++ b/pkgs/top-level/haskell-packages.nix @@ -6,8 +6,8 @@ let "ghc865Binary" "ghc8102Binary" "ghc8102BinaryMinimal" - "ghc8105Binary" - "ghc8105BinaryMinimal" + "ghc8107Binary" + "ghc8107BinaryMinimal" "integer-simple" "native-bignum" "ghcHEAD" @@ -59,11 +59,11 @@ in { minimal = true; }; - ghc8105Binary = callPackage ../development/compilers/ghc/8.10.5-binary.nix { + ghc8107Binary = callPackage ../development/compilers/ghc/8.10.7-binary.nix { llvmPackages = pkgs.llvmPackages_11; }; - ghc8105BinaryMinimal = callPackage ../development/compilers/ghc/8.10.5-binary.nix { + ghc8107BinaryMinimal = callPackage ../development/compilers/ghc/8.10.7-binary.nix { llvmPackages = pkgs.llvmPackages_11; minimal = true; }; @@ -71,7 +71,7 @@ in { ghc884 = callPackage ../development/compilers/ghc/8.8.4.nix { # the oldest ghc with aarch64-darwin support is 8.10.5 bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then - packages.ghc8105BinaryMinimal + packages.ghc8107BinaryMinimal # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them else if stdenv.isAarch64 || stdenv.targetPlatform.isMusl then @@ -82,10 +82,10 @@ in { buildLlvmPackages = buildPackages.llvmPackages_7; llvmPackages = pkgs.llvmPackages_7; }; - ghc8106 = callPackage ../development/compilers/ghc/8.10.6.nix { + ghc8107 = callPackage ../development/compilers/ghc/8.10.7.nix { # the oldest ghc with aarch64-darwin support is 8.10.5 bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then - packages.ghc8105BinaryMinimal + packages.ghc8107BinaryMinimal # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them else if stdenv.isAarch64 || stdenv.isAarch32 || stdenv.targetPlatform.isMusl then @@ -103,7 +103,7 @@ in { ghc901 = callPackage ../development/compilers/ghc/9.0.1.nix { # the oldest ghc with aarch64-darwin support is 8.10.5 bootPkgs = if stdenv.isDarwin && stdenv.isAarch64 then - packages.ghc8105BinaryMinimal + packages.ghc8107BinaryMinimal # aarch64 ghc8102Binary exceeds max output size on hydra else if stdenv.isAarch64 || stdenv.isAarch32 then packages.ghc8102BinaryMinimal @@ -113,9 +113,27 @@ in { buildLlvmPackages = buildPackages.llvmPackages_10; llvmPackages = pkgs.llvmPackages_10; }; + ghc921 = callPackage ../development/compilers/ghc/9.2.1.nix { + # aarch64 ghc8102Binary exceeds max output size on hydra + bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then + packages.ghc8102BinaryMinimal + else + packages.ghc8102Binary; + 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; + buildLlvmPackages = buildPackages.llvmPackages_10; + llvmPackages = pkgs.llvmPackages_10; + }; ghcHEAD = callPackage ../development/compilers/ghc/head.nix { bootPkgs = packages.ghc901; # no binary yet 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; buildLlvmPackages = buildPackages.llvmPackages_10; llvmPackages = pkgs.llvmPackages_10; libffi = pkgs.libffi; @@ -166,15 +184,15 @@ in { compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { }; packageSetConfig = bootstrapPackageSet; }; - ghc8105Binary = callPackage ../development/haskell-modules { - buildHaskellPackages = bh.packages.ghc8105Binary; - ghc = bh.compiler.ghc8105Binary; + 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; }; - ghc8105BinaryMinimal = callPackage ../development/haskell-modules { - buildHaskellPackages = bh.packages.ghc8105BinaryMinimal; - ghc = bh.compiler.ghc8105BinaryMinimal; + 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; }; @@ -183,9 +201,9 @@ in { ghc = bh.compiler.ghc884; compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.8.x.nix { }; }; - ghc8106 = callPackage ../development/haskell-modules { - buildHaskellPackages = bh.packages.ghc8106; - ghc = bh.compiler.ghc8106; + ghc8107 = callPackage ../development/haskell-modules { + buildHaskellPackages = bh.packages.ghc8107; + ghc = bh.compiler.ghc8107; compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { }; }; ghc901 = callPackage ../development/haskell-modules { @@ -193,6 +211,11 @@ in { ghc = bh.compiler.ghc901; compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.0.x.nix { }; }; + ghc921 = callPackage ../development/haskell-modules { + buildHaskellPackages = bh.packages.ghc921; + ghc = bh.compiler.ghc921; + compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-9.2.x.nix { }; + }; ghcHEAD = callPackage ../development/haskell-modules { buildHaskellPackages = bh.packages.ghcHEAD; ghc = bh.compiler.ghcHEAD; diff --git a/pkgs/top-level/release-haskell.nix b/pkgs/top-level/release-haskell.nix index a987dc579dcb..26f538ff3386 100644 --- a/pkgs/top-level/release-haskell.nix +++ b/pkgs/top-level/release-haskell.nix @@ -50,7 +50,7 @@ let # list of all compilers to test specific packages on all = with compilerNames; [ ghc884 - ghc8106 + ghc8107 ghc901 ]; @@ -278,14 +278,14 @@ let # Test some statically linked packages to catch regressions # and get some cache going for static compilation with GHC. # Use integer-simple to avoid GMP linking problems (LGPL) - pkgsStatic.haskell.packages.integer-simple.ghc8106 = + pkgsStatic.haskell.packages.integer-simple.ghc8107 = removePlatforms [ "aarch64-linux" # times out on Hydra "x86_64-darwin" # TODO: reenable when static libiconv works on darwin ] { - inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.integer-simple.ghc8106) + inherit (packagePlatforms pkgs.pkgsStatic.haskell.packages.integer-simple.ghc8107) hello lens random @@ -300,12 +300,12 @@ let # package sets (like Cabal, jailbreak-cabal) are # working as expected. cabal-install = all; - Cabal_3_6_0_0 = with compilerNames; [ ghc884 ghc8106 ]; + Cabal_3_6_0_0 = with compilerNames; [ ghc884 ghc8107 ]; cabal2nix-unstable = all; funcmp = all; # Doesn't currently work on ghc-9.0: # https://github.com/haskell/haskell-language-server/issues/297 - haskell-language-server = with compilerNames; [ ghc884 ghc8106 ]; + haskell-language-server = with compilerNames; [ ghc884 ghc8107 ]; hoogle = all; hsdns = all; jailbreak-cabal = all; @@ -379,7 +379,7 @@ let constituents = accumulateDerivations [ jobs.pkgsMusl.haskell.compiler.ghc8102Binary jobs.pkgsMusl.haskell.compiler.ghc884 - jobs.pkgsMusl.haskell.compiler.ghc8106 + jobs.pkgsMusl.haskell.compiler.ghc8107 jobs.pkgsMusl.haskell.compiler.ghc901 ]; }; @@ -394,9 +394,9 @@ let ]; }; constituents = accumulateDerivations [ - jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.hello - jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.lens - jobs.pkgsStatic.haskell.packages.integer-simple.ghc8106.random + jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.hello + jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.lens + jobs.pkgsStatic.haskell.packages.integer-simple.ghc8107.random ]; }; }