Merge master into staging-next

maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh

···
 EOF
 
 echo "Regenerating list of transitive broken packages ..."
-echo -e $(nix-instantiate --eval --strict maintainers/scripts/haskell/transitive-broken-packages.nix) | sed 's/\"//' | sort -i >> $config_file
+echo -e $(nix-instantiate --eval --strict maintainers/scripts/haskell/transitive-broken-packages.nix) | sed 's/\"//' | LC_ALL=C.UTF-8 sort -i >> $config_file

nixos/tests/agda.nix

···
 
 let
   hello-world = pkgs.writeText "hello-world" ''
+    {-# OPTIONS --guardedness #-}
     open import IO
     open import Level
 
···
     # Minimal script that typechecks
     machine.succeed("touch TestEmpty.agda")
     machine.succeed("agda TestEmpty.agda")
-
-    # Minimal script that actually uses the standard library
-    machine.succeed('echo "import IO" > TestIO.agda')
-    machine.succeed("agda -l standard-library -i . TestIO.agda")
 
     # Hello world
     machine.succeed(

pkgs/applications/editors/vscode/vscodium.nix

···
   archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz";
 
   sha256 = {
-    x86_64-linux = "16hzhmsh9nv2brpzx8wnz08sanf0v6f3ln5hqgzxck0pafbzqyl5";
-    x86_64-darwin = "1a44fm5fx0zqlfr344mvc0m9hbd0vxd6s489pmh8x7m7q3sadi7j";
-    aarch64-linux = "082gjmnlvk12vkcxbpsd4xfgs38qbxkfawq9kyl3p7i8y6anrd4i";
-    armv7l-linux = "0zs66qmlq65166s34qjr6gppxvl5hyz1mjwxc97mki2c6y61fp28";
+    x86_64-linux = "11h4c5ghgn3qrg66jh2par3cl3fqzn9xb7gdniww4badnyajnij8";
+    x86_64-darwin = "0hd3qdxg4cknk3fxv509jlblwmfx65bm2a4arsg255224dpg64n2";
+    aarch64-linux = "0waakj413kqf68sawajd3n24qdbx6b2svyb4lgbn0sy1apc96s3c";
+    armv7l-linux = "1ij2bmsk601f1vjljj6gvxsxrcjqf2m74s9kc006hmcz7czjgk8f";
   }.${system};
 
   sourceRoot = {
···
 
     # Please backport all compatible updates to the stable release.
     # This is important for the extension ecosystem.
-    version = "1.58.1";
+    version = "1.58.2";
     pname = "vscodium";
 
     executableName = "codium";

pkgs/applications/science/logic/cedille/default.nix

···
     license = licenses.mit;
     maintainers = with maintainers; [ marsam mpickering ];
     platforms = platforms.unix;
+
+    # Broken due to Agda update.  See
+    # https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881107449.
+    broken = true;
+    hydraPlatforms = platforms.none;
   };
 }

pkgs/build-support/writers/test.nix

···
     '';
 
 in runCommand "test-writers" {
-  passthru = { inherit writeTest bin simple; };
+  passthru = { inherit writeTest bin simple path; };
   meta.platforms = lib.platforms.all;
 } ''
   ${lib.concatMapStringsSep "\n" (test: writeTest "success" test.name "${test}/bin/${test.name}") (lib.attrValues bin)}

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "080786cc20b9223cc5c1dc04d3e47ce3ad0b0f36",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/080786cc20b9223cc5c1dc04d3e47ce3ad0b0f36.tar.gz",
-  "sha256": "0shv10s208nazb7q36vsx6a4sy7a14qikad4b984r9gz3j6g7l62",
-  "msg": "Update from Hackage at 2021-07-02T10:49:03Z"
+  "commit": "360e4a3b93ab9fc49673c9d91eebd963ddd7e132",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/360e4a3b93ab9fc49673c9d91eebd963ddd7e132.tar.gz",
+  "sha256": "0pzi0kjlma36s0z5wfcghn6h6lwx61vvq8f7322nz80fs4drpn64",
+  "msg": "Update from Hackage at 2021-07-07T20:16:30Z"
 }

pkgs/desktops/pantheon/apps/elementary-code/default.nix

···
 { lib, stdenv
 , fetchFromGitHub
-, fetchpatch
 , nix-update-script
 , pantheon
 , pkg-config
···
 , gtk3
 , granite
 , libgee
+, libhandy
 , elementary-icon-theme
 , appstream
 , libpeas
 , editorconfig-core-c
-, gtksourceview3
+, gtksourceview4
 , gtkspell3
 , libsoup
 , vte
···
 , ctags
 , libgit2-glib
 , wrapGAppsHook
+, polkit
 }:
 
 stdenv.mkDerivation rec {
   pname = "elementary-code";
-  version = "3.4.1";
+  version = "6.0.0";
 
   repoName = "code";
 
···
     owner = "elementary";
     repo = repoName;
     rev = version;
-    sha256 = "sha256-4AEayj+K/lOW6jEYmvmdan1kTqqqLL1YzwcU7/3PH5U=";
+    sha256 = "1w1m52mq3zr9alkxk1c0s4ncscka1km5ppd0r6zm86qan9cjwq0f";
   };
 
-  patches = [
-    # Fix build with latest Vala.
-    (fetchpatch {
-      url = "https://github.com/elementary/code/commit/c50580d3336296823da9a2c50b824f21fde50286.patch";
-      sha256 = "F+ZYlnZWYCU68G4oayLfbTnvSnTb4YA0zHVGD/Uf3KA=";
-    })
-  ];
-
   passthru = {
     updateScript = nix-update-script {
       attrPath = "pantheon.${pname}";
···
     meson
     ninja
     pkg-config
+
+    # polkit is needed for ITS rules
+    polkit
+
     python3
     vala
     wrapGAppsHook
···
     elementary-icon-theme
     granite
     gtk3
-    gtksourceview3
+    gtksourceview4
     gtkspell3
     libgee
     libgit2-glib
+    libhandy
     libpeas
     libsoup
     vte

pkgs/desktops/pantheon/apps/elementary-terminal/default.nix

···
 , gtk3
 , libxml2
 , granite
+, libhandy
 , libnotify
 , vte
 , libgee
···
 
 stdenv.mkDerivation rec {
   pname = "elementary-terminal";
-  version = "5.5.2";
+  version = "6.0.0";
 
   repoName = "terminal";
 
···
     owner = "elementary";
     repo = repoName;
     rev = version;
-    sha256 = "sha256-giVmL0zYEVYJ40ZBQ9dDb4hOx4HaYRt7tUTOu37lMYU=";
+    sha256 = "08akr4sv4jy9kd4s26kib6j7i8hc3vs0sp71fifv7ww4mi9cm6jc";
   };
 
   passthru = {
···
     granite
     gtk3
     libgee
+    libhandy
     libnotify
     pcre2
     vte

pkgs/development/compilers/ghc/8.10.2-binary.nix

···
 { lib, stdenv
 , fetchurl, perl, gcc
-, ncurses6, gmp, glibc, libiconv, numactl
+, ncurses5
+, ncurses6, gmp, libiconv, numactl
 , llvmPackages
 
   # minimal = true; will remove files that aren't strictly necessary for
···
 assert stdenv.targetPlatform == stdenv.hostPlatform;
 
 let
+  downloadsUrl = "https://downloads.haskell.org/ghc";
+
+  version = "8.10.2";
+
+  # Information about available bindists that we use in the build.
+  #
+  # # Bindist library checking
+  #
+  # The field `archSpecificLibraries` also provides a way for us get notified
+  # early when the upstream bindist changes its dependencies (e.g. because a
+  # newer Debian version is used that uses a new `ncurses` version).
+  #
+  # Usage:
+  #
+  # * You can find the `fileToCheckFor` of libraries by running `readelf -d`
+  #   on the compiler binary (`exePathForLibraryCheck`).
+  # * To skip library checking for an architecture,
+  #   set `exePathForLibraryCheck = null`.
+  # * To skip file checking for a specific arch specfic library,
+  #   set `fileToCheckFor = null`.
+  ghcBinDists = {
+    # Binary distributions for the default libc (e.g. glibc, or libSystem on Darwin)
+    # nixpkgs uses for the respective system.
+    defaultLibc = {
+      i686-linux = {
+        src = {
+          url = "${downloadsUrl}/${version}/ghc-${version}-i386-deb9-linux.tar.xz";
+          sha256 = "0bvwisl4w0z5z8z0da10m9sv0mhm9na2qm43qxr8zl23mn32mblx";
+        };
+        exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
+        archSpecificLibraries = [
+          # The i686-linux bindist provided by GHC HQ is currently built on Debian 9,
+          # which link it against `libtinfo.so.5` (ncurses 5).
+          # Other bindists are linked `libtinfo.so.6` (ncurses 6).
+          { nixPackage = ncurses5; fileToCheckFor = "libtinfo.so.5"; }
+        ];
+      };
+      x86_64-linux = {
+        src = {
+          url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-deb10-linux.tar.xz";
+          sha256 = "0chnzy9j23b2wa8clx5arwz8wnjfxyjmz9qkj548z14cqf13slcl";
+        };
+        exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
+        archSpecificLibraries = [
+          { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
+        ];
+      };
+      armv7l-linux = {
+        src = {
+          url = "${downloadsUrl}/${version}/ghc-${version}-armv7-deb10-linux.tar.xz";
+          sha256 = "1j41cq5d3rmlgz7hzw8f908fs79gc5mn3q5wz277lk8zdf19g75v";
+        };
+        exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
+        archSpecificLibraries = [
+          { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
+        ];
+      };
+      aarch64-linux = {
+        src = {
+          url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-deb10-linux.tar.xz";
+          sha256 = "14smwl3741ixnbgi0l51a7kh7xjkiannfqx15b72svky0y4l3wjw";
+        };
+        exePathForLibraryCheck = "ghc/stage2/build/tmp/ghc-stage2";
+        archSpecificLibraries = [
+          { nixPackage = ncurses6; fileToCheckFor = "libtinfo.so.6"; }
+          { nixPackage = numactl; fileToCheckFor = null; }
+        ];
+      };
+      x86_64-darwin = {
+        src = {
+          url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
+          sha256 = "1hngyq14l4f950hzhh2d204ca2gfc98pc9xdasxihzqd1jq75dzd";
+        };
+        exePathForLibraryCheck = null; # we don't have a library check for darwin yet
+        archSpecificLibraries = [
+          { nixPackage = ncurses6; fileToCheckFor = null; }
+          { nixPackage = libiconv; fileToCheckFor = null; }
+        ];
+      };
+    };
+    # Binary distributions for the musl libc for the respective system.
+    musl = {
+      x86_64-linux = {
+        src = {
+          url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-alpine3.10-linux-integer-simple.tar.xz";
+          sha256 = "0xpcbyaxqyhbl6f0i3s4rp2jm67nqpkfh2qlbj3i2fiaix89ml0l";
+        };
+        exePathForLibraryCheck = "bin/ghc";
+        archSpecificLibraries = [
+          # In contrast to glibc builds, the musl-bindist uses `libncursesw.so.*`
+          # instead of `libtinfo.so.*.`
+          { nixPackage = ncurses6; fileToCheckFor = "libncursesw.so.6"; }
+        ];
+      };
+    };
+  };
+
+  distSetName = if stdenv.hostPlatform.isMusl then "musl" else "defaultLibc";
+
+  binDistUsed = ghcBinDists.${distSetName}.${stdenv.hostPlatform.system}
+    or (throw "cannot bootstrap GHC on this platform ('${stdenv.hostPlatform.system}' with libc '${distSetName}')");
+
   useLLVM = !stdenv.targetPlatform.isx86;
 
-  libPath = lib.makeLibraryPath ([
-    ncurses6 gmp
-  ] ++ lib.optional (stdenv.hostPlatform.isDarwin) libiconv
-    ++ lib.optional (stdenv.hostPlatform.isAarch64) numactl);
+  libPath =
+    lib.makeLibraryPath (
+      [
+        gmp
+      ]
+      # Add arch-specific libraries.
+      ++ map ({ nixPackage, ... }: nixPackage) binDistUsed.archSpecificLibraries
+    );
 
   libEnvVar = lib.optionalString stdenv.hostPlatform.isDarwin "DY"
     + "LD_LIBRARY_PATH";
 
-  glibcDynLinker = assert stdenv.isLinux;
-    if stdenv.hostPlatform.libc == "glibc" then
-       # Could be stdenv.cc.bintools.dynamicLinker, keeping as-is to avoid rebuild.
-       ''"$(cat $NIX_CC/nix-support/dynamic-linker)"''
-    else
-      "${lib.getLib glibc}/lib/ld-linux*";
-
-  downloadsUrl = "https://downloads.haskell.org/ghc";
-
 in
 
 stdenv.mkDerivation rec {
-  version = "8.10.2";
+  inherit version;
 
   name = "ghc-${version}-binary";
 
-  # https://downloads.haskell.org/~ghc/8.10.2/
-  src = fetchurl ({
-    i686-linux = {
-      url = "${downloadsUrl}/${version}/ghc-${version}-i386-deb9-linux.tar.xz";
-      sha256 = "0bvwisl4w0z5z8z0da10m9sv0mhm9na2qm43qxr8zl23mn32mblx";
-    };
-    x86_64-linux = {
-      url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-deb10-linux.tar.xz";
-      sha256 = "0chnzy9j23b2wa8clx5arwz8wnjfxyjmz9qkj548z14cqf13slcl";
-    };
-    armv7l-linux = {
-      url = "${downloadsUrl}/${version}/ghc-${version}-armv7-deb10-linux.tar.xz";
-      sha256 = "1j41cq5d3rmlgz7hzw8f908fs79gc5mn3q5wz277lk8zdf19g75v";
-    };
-    aarch64-linux = {
-      url = "${downloadsUrl}/${version}/ghc-${version}-aarch64-deb10-linux.tar.xz";
-      sha256 = "14smwl3741ixnbgi0l51a7kh7xjkiannfqx15b72svky0y4l3wjw";
-    };
-    x86_64-darwin = {
-      url = "${downloadsUrl}/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
-      sha256 = "1hngyq14l4f950hzhh2d204ca2gfc98pc9xdasxihzqd1jq75dzd";
-    };
-  }.${stdenv.hostPlatform.system}
-    or (throw "cannot bootstrap GHC on this platform"));
+  src = fetchurl binDistUsed.src;
 
   nativeBuildInputs = [ perl ];
-  propagatedBuildInputs = lib.optionals useLLVM [ llvmPackages.llvm ];
+  propagatedBuildInputs =
+    lib.optionals useLLVM [ llvmPackages.llvm ]
+    # Because musl bindists currently provide no way to tell where
+    # libgmp is (see not [musl bindists have no .buildinfo]), we need
+    # to propagate `gmp`, otherwise programs built by this ghc will
+    # fail linking with `cannot find -lgmp` errors.
+    # Also, as of writing, the release pages of musl bindists claim
+    # that they use `integer-simple` and do not require `gmp`; however
+    # that is incorrect, so `gmp` is required until a release has been
+    # made that includes https://gitlab.haskell.org/ghc/ghc/-/issues/20059.
+    # (Note that for packaging the `-binary` compiler, nixpkgs does not care
+    # about whether or not `gmp` is used; this comment is just here to explain
+    # why the `gmp` dependency exists despite what the release page says.)
+    ++ lib.optionals stdenv.hostPlatform.isMusl [ gmp ]; # musl bindist needs this
 
+  # Set LD_LIBRARY_PATH or equivalent so that the programs running as part
+  # of the bindist installer can find the libraries they expect.
   # Cannot patchelf beforehand due to relative RPATHs that anticipate
-  # the final install location/
+  # the final install location.
   ${libEnvVar} = libPath;
 
   postUnpack =
+    # Verify our assumptions of which `libtinfo.so` (ncurses) version is used,
+    # so that we know when ghc bindists upgrade that and we need to update the
+    # version used in `libPath`.
+    lib.optionalString
+      (binDistUsed.exePathForLibraryCheck != null)
+      # Note the `*` glob because some GHCs have a suffix when unpacked, e.g.
+      # the musl bindist has dir `ghc-VERSION-x86_64-unknown-linux/`.
+      # As a result, don't shell-quote this glob when splicing the string.
+      (let buildExeGlob = ''ghc-${version}*/"${binDistUsed.exePathForLibraryCheck}"''; in
+        lib.concatStringsSep "\n" [
+          (''
+            echo "Checking that ghc binary exists in bindist at ${buildExeGlob}"
+            if ! test -e ${buildExeGlob}; then
+              echo >&2 "GHC binary ${binDistUsed.exePathForLibraryCheck} could not be found in the bindist build directory (at ${buildExeGlob}) for arch ${stdenv.hostPlatform.system}, please check that ghcBinDists correctly reflect the bindist dependencies!"; exit 1;
+            fi
+          '')
+          (lib.concatMapStringsSep
+            "\n"
+            ({ fileToCheckFor, nixPackage }:
+              lib.optionalString (fileToCheckFor != null) ''
+                echo "Checking bindist for ${fileToCheckFor} to ensure that is still used"
+                if ! readelf -d ${buildExeGlob} | grep "${fileToCheckFor}"; then
+                  echo >&2 "File ${fileToCheckFor} could not be found in ${binDistUsed.exePathForLibraryCheck} for arch ${stdenv.hostPlatform.system}, please check that ghcBinDists correctly reflect the bindist dependencies!"; exit 1;
+                fi
+
+                echo "Checking that the nix package ${nixPackage} contains ${fileToCheckFor}"
+                if ! test -e "${lib.getLib nixPackage}/lib/${fileToCheckFor}"; then
+                  echo >&2 "Nix package ${nixPackage} did not contain ${fileToCheckFor} for arch ${stdenv.hostPlatform.system}, please check that ghcBinDists correctly reflect the bindist dependencies!"; exit 1;
+                fi
+              ''
+            )
+            binDistUsed.archSpecificLibraries
+          )
+        ])
     # GHC has dtrace probes, which causes ld to try to open /usr/lib/libdtrace.dylib
     # during linking
-    lib.optionalString stdenv.isDarwin ''
+    + lib.optionalString stdenv.isDarwin ''
       export NIX_LDFLAGS+=" -no_dtrace_dof"
       # not enough room in the object files for the full path to libiconv :(
       for exe in $(find . -type f -executable); do
···
       patchShebangs ghc-${version}/configure
     '' +
     # We have to patch the GMP paths for the integer-gmp package.
+    # Note [musl bindists have no .buildinfo]
+    # Note that musl bindists do not contain them; unclear if that's intended;
+    # see: https://gitlab.haskell.org/ghc/ghc/-/issues/20073#note_363231
     ''
       find . -name integer-gmp.buildinfo \
           -exec sed -i "s@extra-lib-dirs: @extra-lib-dirs: ${gmp.out}/lib@" {} \;
···
     '' +
     # Rename needed libraries and binaries, fix interpreter
     lib.optionalString stdenv.isLinux ''
-      find . -type f -perm -0100 -exec patchelf \
-          --replace-needed libncurses${lib.optionalString stdenv.is64bit "w"}.so.6 libncurses.so \
-          --interpreter ${glibcDynLinker} {} \;
-
-      sed -i "s|/usr/bin/perl|perl\x00        |" ghc-${version}/ghc/stage2/build/tmp/ghc-stage2
-      sed -i "s|/usr/bin/gcc|gcc\x00        |" ghc-${version}/ghc/stage2/build/tmp/ghc-stage2
-    '' +
-    # We're kludging a glibc bindist into working with non-glibc...
-    # Here we patch up the use of `__strdup` (part of glibc binary ABI)
-    # to instead use `strdup` since musl doesn't provide __strdup
-    # (`__strdup` is defined to be an alias of `strdup` anyway[1]).
-    # [1] http://refspecs.linuxbase.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/baselib---strdup-1.html
-    # Use objcopy magic to make the change:
-    lib.optionalString stdenv.hostPlatform.isMusl ''
-      find ./ghc-${version}/rts -name "libHSrts*.a" -exec ''${OBJCOPY:-objcopy} --redefine-sym __strdup=strdup {} \;
+      find . -type f -executable -exec patchelf \
+          --interpreter ${stdenv.cc.bintools.dynamicLinker} {} \;
     '';
 
   # fix for `configure: error: Your linker is affected by binutils #16177`
···
 
   configurePlatforms = [ ];
   configureFlags = [
-    "--with-gmp-libraries=${lib.getLib gmp}/lib"
     "--with-gmp-includes=${lib.getDev gmp}/include"
+    # Note `--with-gmp-libraries` does nothing for GHC bindists:
+    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6124
   ] ++ lib.optional stdenv.isDarwin "--with-gcc=${./gcc-clang-wrapper.sh}"
+    # From: https://github.com/NixOS/nixpkgs/pull/43369/commits
     ++ lib.optional stdenv.hostPlatform.isMusl "--disable-ld-override";
 
   # No building is necessary, but calling make without flags ironically
   # calls install-strip ...
   dontBuild = true;
 
+  # Apparently necessary for the ghc Alpine (musl) bindist:
+  # When we strip, and then run the
+  #     patchelf --set-rpath "${libPath}:$(patchelf --print-rpath $p)" $p
+  # below, running ghc (e.g. during `installCheckPhase)` gives some apparently
+  # corrupted rpath or whatever makes the loader work on nonsensical strings:
+  #     running install tests
+  #     Error relocating /nix/store/...-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/ghc: : symbol not found
+  #     Error relocating /nix/store/...-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/ghc: ir6zf6c9f86pfx8sr30n2vjy-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/../lib/x86_64-linux-ghc-8.10.5/libHSexceptions-0.10.4-ghc8.10.5.so: symbol not found
+  #     Error relocating /nix/store/...-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/ghc: y/lib/ghc-8.10.5/bin/../lib/x86_64-linux-ghc-8.10.5/libHStemplate-haskell-2.16.0.0-ghc8.10.5.so: symbol not found
+  #     Error relocating /nix/store/...-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/ghc: 8.10.5/libHStemplate-haskell-2.16.0.0-ghc8.10.5.so: symbol not found
+  #     Error relocating /nix/store/...-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/ghc: �: symbol not found
+  #     Error relocating /nix/store/...-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/ghc: �?: symbol not found
+  #     Error relocating /nix/store/...-ghc-8.10.2-binary/lib/ghc-8.10.5/bin/ghc: 64-linux-ghc-8.10.5/libHSexceptions-0.10.4-ghc8.10.5.so: symbol not found
+  # This is extremely bogus and should be investigated.
+  dontStrip = if stdenv.hostPlatform.isMusl then true else false; # `if` for explicitness
+
   # On Linux, use patchelf to modify the executables so that they can
   # find editline/gmp.
   postFixup = lib.optionalString stdenv.isLinux
···
     find $out -type f -name '*.p_o' -delete
     find $out -type f -name '*.p_hi' -delete
     find $out -type f -name '*_p.a' -delete
-    rm $out/lib/ghc-*/bin/ghc-iserv-prof
+    # `-f` because e.g. musl bindist does not have this file.
+    rm -f $out/lib/ghc-*/bin/ghc-iserv-prof
     # Hydra will redistribute this derivation, so we have to keep the docs for
     # legal reasons (retaining the legal notices etc)
     # As a last resort we could unpack the docs separately and symlink them in.
     # They're in $out/share/{doc,man}.
   '';
 
+  # 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
+  hardeningDisable = lib.optional stdenv.targetPlatform.isMusl "pie";
+
   doInstallCheck = true;
   installCheckPhase = ''
     unset ${libEnvVar}
···
     homepage = "http://haskell.org/ghc";
     description = "The Glasgow Haskell Compiler";
     license = lib.licenses.bsd3;
-    platforms = ["x86_64-linux" "armv7l-linux" "aarch64-linux" "i686-linux" "x86_64-darwin"];
+    # HACK: since we can't encode the libc / abi in platforms, we need
+    # to make the platform list dependent on the evaluation platform
+    # in order to avoid eval errors with musl which supports less
+    # platforms than the default libcs (i. e. glibc / libSystem).
+    # This is done for the benefit of Hydra, so `packagePlatforms`
+    # won't return any platforms that would cause an evaluation
+    # failure for `pkgsMusl.haskell.compiler.ghc8102Binary`, as
+    # long as the evaluator runs on a platform that supports
+    # `pkgsMusl`.
+    platforms = builtins.attrNames ghcBinDists.${distSetName};
     hydraPlatforms = builtins.filter (p: minimal || p != "aarch64-linux") platforms;
     maintainers = with lib.maintainers; [ lostnet ];
   };

pkgs/development/compilers/ghc/8.10.4.nix

···
   ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
     (if useLLVM then "perf-cross" else "perf-cross-ncg")
 
+, #  Whether to build sphinx documentation.
+  enableDocs ? (
+    # Docs disabled for musl and cross because it's a large task to keep
+    # all `sphinx` dependencies building in those environments.
+    # `sphinx` pulls in among others:
+    # Ruby, Python, Perl, Rust, OpenGL, Xorg, gtk, LLVM.
+    (stdenv.targetPlatform == stdenv.hostPlatform)
+    && !stdenv.hostPlatform.isMusl
+  )
+
+, enableHaddockProgram ?
+    # Disabled for cross; see note [HADDOCK_DOCS].
+    (stdenv.targetPlatform == stdenv.hostPlatform)
+
 , # Whether to disable the large address space allocator
   # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
   disableLargeAddressSpace ? stdenv.targetPlatform.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;
···
     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}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
   '' + lib.optionalString (!enableProfiledLibs) ''
     GhcLibWays = "v dyn"
   '' + lib.optionalString enableRelocatedStaticLibs ''
···
   dontAddExtraLibs = true;
 
   nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
+    perl autoconf automake m4 python3
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
+  ] ++ lib.optionals enableDocs [
+    sphinx
   ];
 
   # For building runtime libs
···
 
   checkTarget = "test";
 
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+  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";
 
   postInstall = ''
     # Install the bash completion file.

pkgs/development/compilers/ghc/8.6.5-binary.nix

···
 
   configurePlatforms = [ ];
   configureFlags = [
-    "--with-gmp-libraries=${lib.getLib gmp}/lib"
     "--with-gmp-includes=${lib.getDev gmp}/include"
+    # Note `--with-gmp-libraries` does nothing for GHC bindists:
+    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/6124
   ] ++ lib.optional stdenv.isDarwin "--with-gcc=${./gcc-clang-wrapper.sh}"
     ++ lib.optional stdenv.hostPlatform.isMusl "--disable-ld-override";
 
···
     done
   '';
 
+  # 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
+  hardeningDisable = lib.optional stdenv.targetPlatform.isMusl "pie";
+
   doInstallCheck = true;
   installCheckPhase = ''
     unset ${libEnvVar}
···
     license = lib.licenses.bsd3;
     platforms = ["x86_64-linux" "aarch64-linux" "i686-linux" "x86_64-darwin"];
     hydraPlatforms = builtins.filter (p: p != "aarch64-linux") platforms;
+    # build segfaults, use ghc8102Binary which has proper musl support instead
+    broken = stdenv.hostPlatform.isMusl;
   };
 }

pkgs/development/compilers/ghc/8.8.4.nix

···
   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;
 
···
     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 && !targetPlatform.isiOS) then "NO" else "YES"}
     CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
   '' + lib.optionalString dontStrip ''
     STRIP_CMD = :
   '' + lib.optionalString (!enableProfiledLibs) ''
···
   postPatch = "patchShebangs .";
 
   # GHC is a bit confused on its cross terminology.
-  preConfigure = lib.optionalString stdenv.isAarch64 ''
+  preConfigure =
     # Aarch64 allow backward bootstrapping since earlier versions are unstable.
-    find . -name \*\.cabal\* -exec sed -i -e 's/\(base.*\)4.14/\14.16/' {} \; \
-      -exec sed -i -e 's/\(prim.*\)0.6/\10.8/' {} \;
-  '' + ''
+    # Same for musl, as earlier versions do not provide a musl bindist for bootstrapping.
+    lib.optionalString (stdenv.isAarch64 || stdenv.hostPlatform.isMusl) ''
+      find . -name \*\.cabal\* -exec sed -i -e 's/\(base.*\)4.14/\14.16/' {} \; \
+        -exec sed -i -e 's/\(prim.*\)0.6/\10.8/' {} \;
+    ''
+  + ''
     for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
       export "''${env#TARGET_}=''${!env}"
     done
···
   dontAddExtraLibs = true;
 
   nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
+    perl autoconf automake m4 python3
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
+  ] ++ lib.optionals enableDocs [
+    sphinx
   ];
 
   # For building runtime libs
···
 
   checkTarget = "test";
 
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+  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";
 
   postInstall = ''
     # Install the bash completion file.

pkgs/development/compilers/ghc/9.0.1.nix

···
   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;
 
···
     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}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
   '' + lib.optionalString (!enableProfiledLibs) ''
     GhcLibWays = "v dyn"
   '' + lib.optionalString enableRelocatedStaticLibs ''
···
 
     echo -n "${buildMK}" > mk/build.mk
     sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
-  '' + lib.optionalString (stdenv.isLinux) ''
+  '' + 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}"
···
   dontAddExtraLibs = true;
 
   nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
+    perl autoconf automake m4 python3
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
+  ] ++ lib.optionals enableDocs [
+    sphinx
   ];
 
   # For building runtime libs
···
 
   checkTarget = "test";
 
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+  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";
 
   postInstall = ''
     # Install the bash completion file.

pkgs/development/compilers/ghc/head.nix

···
   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 !enableNativeBignum -> gmp != null;
+
+# Cross cannot currently build the `haddock` program for silly reasons,
+# see note [HADDOCK_DOCS].
+assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram;
 
 let
   inherit (stdenv) buildPlatform hostPlatform targetPlatform;
···
     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"}
     BIGNUM_BACKEND = ${if enableNativeBignum then "native" else "gmp"}
   '' + lib.optionalString (targetPlatform != hostPlatform) ''
     Stage1Only = ${if (targetPlatform.system == hostPlatform.system && !targetPlatform.isiOS) then "NO" else "YES"}
     CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
   '' + lib.optionalString dontStrip ''
     STRIP_CMD = :
   '' + lib.optionalString (!enableProfiledLibs) ''
···
   dontAddExtraLibs = true;
 
   nativeBuildInputs = [
-    perl autoconf autoreconfHook automake m4 python3 sphinx
+    perl autoconf autoreconfHook automake m4 python3
     ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
+  ] ++ lib.optionals enableDocs [
+    sphinx
   ];
 
   # For building runtime libs
···
 
   checkTarget = "test";
 
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+  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";
 
   postInstall = ''
     # Install the bash completion file.

pkgs/development/haskell-modules/cabal2nix-unstable.nix

···
 }:
 mkDerivation {
   pname = "cabal2nix";
-  version = "unstable-2021-06-12";
+  version = "unstable-2021-07-08";
   src = fetchzip {
-    url = "https://github.com/NixOS/cabal2nix/archive/01feffa0aeee835504e0c0ccf4bca2e33a698252.tar.gz";
-    sha256 = "0clckh0qqvjcb8szy1d6qqlxj6sqp28jc2p3vhzhkf95cv491si9";
+    url = "https://github.com/NixOS/cabal2nix/archive/b28902718d89f6a14a836d95a7093bc46e4f8bb5.tar.gz";
+    sha256 = "1jdbz0krwzzsl3vb10xgman642v49bbgwyl6dw3p9aw6s7a8nfgk";
   };
   isLibrary = true;
   isExecutable = true;

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

···
 
   # 2021-05-09: compilation requires patches from master,
   # remove at next release (current is 0.1.0.4).
-  large-hashable = appendPatches super.large-hashable [
-    # Fix compilation of TH code for GHC >= 8.8
-    (pkgs.fetchpatch {
-      url = "https://github.com/factisresearch/large-hashable/commit/ee7afe4bd181cf15a324c7f4823f7a348e4a0e6b.patch";
-      sha256 = "1ha77v0bc6prxacxhpdfgcsgw8348gvhl9y81smigifgjbinphxv";
-      excludes = [
-        ".travis.yml"
-        "stack**"
-      ];
-    })
-    # Fix cpp invocation
-    (pkgs.fetchpatch {
-      url = "https://github.com/factisresearch/large-hashable/commit/7b7c2ed6ac6e096478e8ee00160fa9d220df853a.patch";
-      sha256 = "1sf9h3k8jbbgfshzrclaawlwx7k2frb09z2a64f93jhvk6ci6vgx";
-    })
-  ];
+  large-hashable = overrideCabal super.large-hashable (drv: {
+    # fix line endings which are an issue all of a sudden for an unknown reason
+    prePatch = ''
+      find . -type f -print0 | xargs -0 ${pkgs.buildPackages.dos2unix}/bin/dos2unix
+    '' + (drv.prePatch or "");
+    # allow newer template haskell
+    jailbreak = true;
+    patches = [
+      # Fix compilation of TH code for GHC >= 8.8
+      (pkgs.fetchpatch {
+        url = "https://github.com/factisresearch/large-hashable/commit/ee7afe4bd181cf15a324c7f4823f7a348e4a0e6b.patch";
+        sha256 = "1ha77v0bc6prxacxhpdfgcsgw8348gvhl9y81smigifgjbinphxv";
+        excludes = [
+          ".travis.yml"
+          "stack**"
+        ];
+      })
+      # Fix cpp invocation
+      (pkgs.fetchpatch {
+        url = "https://github.com/factisresearch/large-hashable/commit/7b7c2ed6ac6e096478e8ee00160fa9d220df853a.patch";
+        sha256 = "1sf9h3k8jbbgfshzrclaawlwx7k2frb09z2a64f93jhvk6ci6vgx";
+      })
+    ];
+  });
 
   # BSON defaults to requiring network instead of network-bsd which is
   # required nowadays: https://github.com/mongodb-haskell/bson/issues/26
···
 
   # Flakey tests
   # upstream https://github.com/circuithub/rel8/issues/86
-  rel8 = dontCheck super.rel8;
+  rel8 = dontCheck (super.rel8.override {
+    opaleye = dontCheck super.opaleye_0_7_2_0;
+  });
+
+  # Release 1.0.0.0 added version bounds (was unrestricted before),
+  # but with too strict lower bounds for our lts-18.
+  graphql = assert pkgs.lib.versionOlder self.parser-combinators.version "1.3.0";
+    assert pkgs.lib.versionOlder self.hspec.version "2.8.2";
+    doJailbreak super.graphql;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   retry = dontCheck super.retry;
 
   # hlint 3.3 needs a ghc-lib-parser newer than the one from stackage
-  hlint = super.hlint_3_3_0.overrideScope (self: super: {
+  hlint = super.hlint_3_3_1.overrideScope (self: super: {
     ghc-lib-parser = overrideCabal self.ghc-lib-parser_9_0_1_20210324 {
       doHaddock = false;
     };

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

···
   - Agata
   - agda-language-server
   - agda-snippets
+  - agda-unused
   - AGI
   - ag-pictgen
   - AhoCorasick
···
   - clock-extras
   - clogparse
   - clone-all
+  - closed-intervals
   - closure
   - cloudfront-signer
   - clr-inline
···
   - doctest-prop
   - docusign-example
   - docvim
+  - dominion
   - domplate
   - do-spaces
   - dotfs
···
   - hakismet
   - hakka
   - hako
+  - hakyll-agda
   - hakyll-blaze-templates
   - hakyll-contrib
   - hakyll-contrib-csv
···
   - Hricket
   - hs2bf
   - hs2ps
+  - hsakamai
   - hsaml2
   - hsay
   - hsbc
···
   - hw-json-simd
   - hw-mquery
   - hworker
+  - hw-prim-bits
   - hw-simd
   - hwsl2
   - hx
···
   - MuCheck
   - mud
   - muesli
+  - mu-graphql
   - mulang
   - multext-east-msd
   - multiaddr
···
   - np-extras
   - np-linear
   - nptools
+  - nri-kafka
+  - nri-postgresql
   - ntp-control
   - ntrip-client
   - n-tuple
···
   - streamdeck
   - streamed
   - stream-fusion
+  - streaming-benchmarks
   - streaming-conduit
   - streaming-events
   - streaming-lzma
···
   - stripe-http-streams
   - stripe-signature
   - stripe-tests
+  - strong-path
   - strongswan-sql
   - structural-traversal
   - structures
···
   - thrift
   - Thrift
   - throttled-io-loop
+  - throwable-exceptions
   - th-sccs
   - th-tc
   - th-to-exp
···
   - Titim
   - tkhs
   - tkyprof
+  - tmp-postgres
   - todo
   - tofromxml
   - to-haskell

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

···
   - crackNum < 3.0                      # 2021-05-21: 3.0 removed the lib which sbv 7.13 uses
   - ShellCheck == 0.7.1                 # 2021-05-09: haskell-ci 0.12.1 pins this version
   - hackage-db < 2.1.1                  # 2021-06-10: Need older hackage-db as long as Cabal < 3.4, see https://github.com/NixOS/cabal2nix/issues/501
+  - opaleye < 0.7.3.0                   # 2021-07-11: for rel8 <= 1.0.0.1, see https://github.com/circuithub/rel8/issues/95#issuecomment-877616118
 
 package-maintainers:
   abbradar:

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

···
-# Stackage LTS 18.0
+# Stackage LTS 18.1
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - aeson-with ==0.1.2.0
   - aeson-yak ==0.1.1.3
   - aeson-yaml ==1.1.0.0
-  - Agda ==2.6.1.3
+  - Agda ==2.6.2
   - agda2lagda ==0.2021.6.1
   - al ==0.1.4.2
   - alarmclock ==0.7.0.5
···
   - auto-update ==0.1.6
   - avro ==0.5.2.0
   - aws-cloudfront-signed-cookies ==0.2.0.8
-  - aws-xray-client ==0.1.0.0
-  - aws-xray-client-wai ==0.1.0.0
+  - aws-xray-client ==0.1.0.1
+  - aws-xray-client-wai ==0.1.0.1
   - backprop ==0.2.6.4
   - backtracking ==0.1.0
   - bank-holidays-england ==0.2.0.6
···
   - base16 ==0.3.0.1
   - base16-bytestring ==1.0.1.0
   - base16-lens ==0.1.3.2
-  - base32 ==0.2.0.0
+  - base32 ==0.2.1.0
   - base32-lens ==0.1.1.1
   - base32string ==0.9.1
   - base58-bytestring ==0.1.0
···
   - bcp47 ==0.2.0.4
   - bcp47-orphans ==0.1.0.4
   - bcrypt ==0.0.11
-  - bech32 ==1.1.0
+  - bech32 ==1.1.1
   - bech32-th ==1.0.2
   - bench ==1.0.12
   - benchpress ==0.2.2.17
···
   - buffer-pipe ==0.0
   - bugsnag-haskell ==0.0.4.1
   - bugsnag-hs ==0.2.0.4
-  - bugzilla-redhat ==0.3.1
+  - bugzilla-redhat ==0.3.2
   - burrito ==1.2.0.2
   - butcher ==1.3.3.2
   - buttplug-hs-core ==0.1.0.0
···
   - Color ==0.3.2
   - colorful-monoids ==0.2.1.3
   - colorize-haskell ==1.0.1
-  - colour ==2.3.5
+  - colour ==2.3.6
   - combinatorial ==0.1.0.1
   - comfort-array ==0.4.1
   - comfort-graph ==0.0.3.1
-  - commonmark ==0.2
+  - commonmark ==0.2.1
   - commonmark-extensions ==0.2.1.2
-  - commonmark-pandoc ==0.2.1
+  - commonmark-pandoc ==0.2.1.1
   - commutative ==0.0.2
   - comonad ==5.0.8
   - comonad-extras ==4.0.1
···
   - crc32c ==0.0.0
   - credential-store ==0.1.2
   - criterion ==1.5.9.0
-  - criterion-measurement ==0.1.2.0
+  - criterion-measurement ==0.1.3.0
   - cron ==0.7.0
   - crypto-api ==0.13.3
   - crypto-cipher-types ==0.0.9
···
   - data-hash ==0.2.0.1
   - data-interval ==2.1.0
   - data-inttrie ==0.1.4
-  - data-lens-light ==0.1.2.2
+  - data-lens-light ==0.1.2.3
   - data-memocombinators ==0.5.1
   - data-msgpack ==0.0.13
   - data-msgpack-types ==0.0.3
···
   - elynx-seq ==0.5.1.1
   - elynx-tools ==0.5.1.1
   - elynx-tree ==0.5.1.1
-  - email-validate ==2.3.2.13
+  - email-validate ==2.3.2.15
   - emd ==0.2.0.0
   - emojis ==0.1
   - enclosed-exceptions ==1.0.3
···
   - errors ==2.3.0
   - errors-ext ==0.4.2
   - ersatz ==0.4.9
-  - esqueleto ==3.5.0.0
+  - esqueleto ==3.5.2.0
   - essence-of-live-coding ==0.2.5
   - essence-of-live-coding-gloss ==0.2.5
   - essence-of-live-coding-pulse ==0.2.5
···
   - expiring-cache-map ==0.0.6.1
   - explicit-exception ==0.1.10
   - exp-pairs ==0.2.1.0
-  - express ==0.1.14
+  - express ==0.1.16
   - extended-reals ==0.2.4.0
   - extensible-effects ==5.0.0.1
   - extensible-exceptions ==0.1.1.4
···
   - forkable-monad ==0.2.0.3
   - forma ==1.1.3
   - format-numbers ==0.1.0.1
-  - formatting ==7.1.2
+  - formatting ==7.1.3
   - foundation ==0.0.26.1
   - fourmolu ==0.3.0.0
   - free ==5.1.7
···
   - generics-eot ==0.4.0.1
   - generics-sop ==0.5.1.1
   - generics-sop-lens ==0.2.0.1
-  - geniplate-mirror ==0.7.7
-  - genvalidity ==0.11.0.0
+  - geniplate-mirror ==0.7.8
+  - genvalidity ==0.11.0.2
   - genvalidity-aeson ==0.3.0.0
   - genvalidity-bytestring ==0.6.0.0
   - genvalidity-containers ==0.9.0.0
···
   - ghc-prof ==1.4.1.8
   - ghc-source-gen ==0.4.0.0
   - ghc-syntax-highlighter ==0.0.6.0
-  - ghc-tcplugins-extra ==0.4.1
-  - ghc-trace-events ==0.1.2.2
-  - ghc-typelits-extra ==0.4.2
-  - ghc-typelits-knownnat ==0.7.5
-  - ghc-typelits-natnormalise ==0.7.4
+  - ghc-tcplugins-extra ==0.4.2
+  - ghc-trace-events ==0.1.2.3
+  - ghc-typelits-extra ==0.4.3
+  - ghc-typelits-knownnat ==0.7.6
+  - ghc-typelits-natnormalise ==0.7.6
   - ghc-typelits-presburger ==0.6.0.0
   - ghost-buster ==0.1.1.0
   - gi-atk ==2.0.23
···
   - ginger ==0.10.1.0
   - gingersnap ==0.3.1.0
   - gi-pango ==1.0.24
-  - githash ==0.1.6.0
+  - githash ==0.1.6.1
   - github-release ==1.3.7
   - github-rest ==1.0.3
   - github-types ==0.2.1
···
   - hamtsolo ==1.0.3
   - HandsomeSoup ==0.4.2
   - hapistrano ==0.4.2.0
-  - happstack-server ==7.7.1
+  - happstack-server ==7.7.1.1
   - happy ==1.20.0
   - happy-meta ==0.2.0.11
   - HasBigDecimal ==0.1.1
···
   - hasql-optparse-applicative ==0.3.0.6
   - hasql-pool ==0.5.2
   - hasql-queue ==1.2.0.2
-  - hasql-transaction ==1.0.0.2
+  - hasql-transaction ==1.0.1
   - hasty-hamiltonian ==1.3.4
   - HaTeX ==3.22.3.0
   - HaXml ==1.25.5
···
   - hdaemonize ==0.5.6
   - HDBC ==2.4.0.3
   - HDBC-session ==0.1.2.0
-  - headroom ==0.4.1.0
+  - headroom ==0.4.2.0
   - heap ==1.0.4
   - heaps ==0.4
   - hebrew-time ==0.1.2
···
   - hedgehog-fn ==1.0
   - hedgehog-quickcheck ==0.1.1
   - hedis ==0.14.4
-  - hedn ==0.3.0.2
+  - hedn ==0.3.0.3
   - here ==1.2.13
   - heredoc ==0.2.0.0
   - heterocephalus ==1.0.5.4
···
   - http-media ==0.8.0.0
   - http-query ==0.1.0.1
   - http-reverse-proxy ==0.6.0
-  - http-streams ==0.8.7.2
+  - http-streams ==0.8.8.1
   - http-types ==0.12.3
   - human-readable-duration ==0.2.1.4
   - HUnit ==1.6.2.0
···
   - hybrid-vectors ==0.2.2
   - hyper ==0.2.1.1
   - hyperloglog ==0.4.4
-  - hyphenation ==0.8.1
+  - hyphenation ==0.8.2
   - iconv ==0.4.1.3
   - identicon ==0.2.2
   - ieee754 ==0.8.0
···
   - influxdb ==1.9.1.2
   - ini ==0.4.1
   - inj ==1.0
-  - inline-c ==0.9.1.4
+  - inline-c ==0.9.1.5
   - inline-c-cpp ==0.4.0.3
   - inline-r ==0.10.4
   - inliterate ==0.1.0
···
   - lift-generics ==0.2
   - lift-type ==0.1.0.1
   - line ==4.0.1
-  - linear ==1.21.5
+  - linear ==1.21.6
   - linear-circuit ==0.1.0.2
   - linenoise ==0.3.2
   - linux-file-extents ==0.2.0.0
···
   - netlib-comfort-array ==0.0.0.1
   - netlib-ffi ==0.1.1
   - net-mqtt ==0.7.1.1
-  - net-mqtt-lens ==0.1.0.0
+  - net-mqtt-lens ==0.1.1.0
   - netpbm ==1.0.4
   - nettle ==0.3.0
   - netwire ==5.0.3
···
   - nowdoc ==0.1.1.0
   - nqe ==0.6.3
   - nri-env-parser ==0.1.0.7
-  - nri-observability ==0.1.0.3
+  - nri-observability ==0.1.1.1
   - nri-prelude ==0.6.0.2
   - nsis ==0.3.3
   - numbers ==3000.2.0.2
···
   - OneTuple ==0.2.2.1
   - Only ==0.1
   - oo-prototypes ==0.1.0.0
-  - opaleye ==0.7.1.0
+  - opaleye ==0.7.3.0
   - OpenAL ==1.7.0.5
   - openapi3 ==3.1.0
   - open-browser ==0.2.1.0
···
   - options ==1.2.1.1
   - optparse-applicative ==0.16.1.0
   - optparse-generic ==1.4.4
-  - optparse-simple ==0.1.1.3
+  - optparse-simple ==0.1.1.4
   - optparse-text ==0.1.1.0
   - ordered-containers ==0.2.2
   - ormolu ==0.1.4.1
···
   - pager ==0.1.1.0
   - pagination ==0.2.2
   - pagure-cli ==0.2
-  - pandoc ==2.14.0.2
+  - pandoc ==2.14.0.3
   - pandoc-dhall-decoder ==0.1.0.1
   - pandoc-plot ==1.2.3
   - pandoc-throw ==0.1.0.0
   - pandoc-types ==1.22
-  - pantry ==0.5.2.2
+  - pantry ==0.5.2.3
   - parallel ==3.2.2.0
   - parameterized ==0.5.0.0
   - paripari ==0.7.0.0
···
   - persist ==0.1.1.5
   - persistable-record ==0.6.0.5
   - persistable-types-HDBC-pg ==0.0.3.5
-  - persistent ==2.13.0.2
+  - persistent ==2.13.1.1
   - persistent-mtl ==0.2.2.0
   - persistent-mysql ==2.13.0.1
   - persistent-pagination ==0.1.1.2
-  - persistent-postgresql ==2.13.0.2
+  - persistent-postgresql ==2.13.0.3
   - persistent-qq ==2.12.0.1
   - persistent-sqlite ==2.13.0.3
   - persistent-template ==2.12.0.0
···
   - persistent-typed-db ==0.1.0.4
   - pg-harness-client ==0.6.0
   - pgp-wordlist ==0.1.0.3
-  - pg-transact ==0.3.1.1
+  - pg-transact ==0.3.2.0
   - phantom-state ==0.2.1.2
   - pid1 ==0.1.2.0
   - pinboard ==0.10.2.0
···
   - sequenceTools ==1.5.0
   - serf ==0.1.1.0
   - serialise ==0.2.3.0
-  - servant ==0.18.2
+  - servant ==0.18.3
   - servant-auth ==0.4.0.0
   - servant-auth-client ==0.4.1.0
   - servant-auth-docs ==0.2.10.0
···
   - servant-auth-swagger ==0.2.10.1
   - servant-auth-wordpress ==1.0.0.2
   - servant-blaze ==0.9.1
-  - servant-client ==0.18.2
-  - servant-client-core ==0.18.2
+  - servant-client ==0.18.3
+  - servant-client-core ==0.18.3
   - servant-conduit ==0.15.1
-  - servant-docs ==0.11.8
+  - servant-docs ==0.11.9
   - servant-elm ==0.7.2
   - servant-errors ==0.1.6.0
   - servant-exceptions ==0.2.1
   - servant-exceptions-server ==0.2.1
-  - servant-foreign ==0.15.3
-  - servant-http-streams ==0.18.2
+  - servant-foreign ==0.15.4
+  - servant-http-streams ==0.18.3
   - servant-machines ==0.15.1
   - servant-multipart ==0.12.1
   - servant-multipart-api ==0.12.1
   - servant-openapi3 ==2.0.1.2
-  - servant-pipes ==0.15.2
+  - servant-pipes ==0.15.3
   - servant-rawm ==1.0.0.0
-  - servant-server ==0.18.2
+  - servant-server ==0.18.3
   - servant-swagger ==1.1.10
   - servant-swagger-ui ==0.3.5.3.47.1
   - servant-swagger-ui-core ==0.3.5
···
   - set-cover ==0.1.1
   - setenv ==0.1.1.3
   - setlocale ==1.0.0.10
-  - sexp-grammar ==2.3.0
+  - sexp-grammar ==2.3.1
   - SHA ==1.6.4.4
-  - shake ==0.19.4
+  - shake ==0.19.5
   - shake-language-c ==0.12.0
   - shake-plus ==0.3.3.1
   - shake-plus-extended ==0.4.1.0
···
   - simple-affine-space ==0.1.1
   - simple-cabal ==0.1.3
   - simple-cmd ==0.2.3
-  - simple-cmd-args ==0.1.6
+  - simple-cmd-args ==0.1.7
   - simple-log ==0.9.12
   - simple-reflect ==0.3.3
   - simple-sendfile ==0.2.30
···
   - skein ==1.0.9.4
   - skews ==0.1.0.3
   - skip-var ==0.1.1.0
-  - skylighting ==0.10.5.1
-  - skylighting-core ==0.10.5.1
+  - skylighting ==0.10.5.2
+  - skylighting-core ==0.10.5.2
   - slack-api ==0.12
   - slack-progressbar ==0.1.0.1
   - slick ==1.1.1.0
···
   - Stream ==0.4.7.2
   - streaming ==0.2.3.0
   - streaming-attoparsec ==1.0.0.1
-  - streaming-bytestring ==0.2.0
+  - streaming-bytestring ==0.2.1
   - streaming-commons ==0.2.2.1
   - streamly ==0.7.3
   - streams ==3.3
···
   - string-random ==0.1.4.1
   - stringsearch ==0.3.6.6
   - string-transform ==1.1.1
-  - stripe-concepts ==1.0.2.8
+  - stripe-concepts ==1.0.3
   - stripe-core ==2.6.2
   - stripe-haskell ==2.6.2
   - stripe-http-client ==2.6.2
···
   - tasty-program ==1.0.5
   - tasty-quickcheck ==0.10.1.2
   - tasty-rerun ==1.1.18
-  - tasty-silver ==3.2.1
+  - tasty-silver ==3.2.2
   - tasty-smallcheck ==0.8.2
   - tasty-test-reporter ==0.1.1.4
   - tasty-th ==0.1.7
···
   - TCache ==0.12.1
   - tce-conf ==1.3
   - tdigest ==0.2.1.1
-  - template-haskell-compat-v0208 ==0.1.5
+  - template-haskell-compat-v0208 ==0.1.6
   - temporary ==1.3
   - temporary-rc ==1.2.0.3
   - temporary-resourcet ==0.1.0.1
···
   - th-test-utils ==1.1.0
   - th-utilities ==0.2.4.3
   - thyme ==0.3.5.5
-  - tidal ==1.7.5
+  - tidal ==1.7.7
   - tile ==0.3.0.0
   - time-compat ==1.9.5
   - timeit ==2.0
···
   - transformers-bifunctors ==0.1
   - transformers-compat ==0.6.6
   - transformers-fix ==1.0
-  - traverse-with-class ==1.0.1.0
+  - traverse-with-class ==1.0.1.1
   - tree-diff ==0.2
   - tree-fun ==0.8.1.0
   - tree-view ==0.5.1
···
   - triplesec ==0.2.2.1
   - trivial-constraint ==0.7.0.0
   - tsv2csv ==0.1.0.2
-  - ttc ==1.1.0.0
+  - ttc ==1.1.0.1
   - ttl-hashtables ==1.4.1.0
   - ttrie ==0.1.2.1
   - tuple ==0.3.0.2
···
   - unipatterns ==0.0.0.0
   - uniplate ==1.6.13
   - uniprot-kb ==0.1.2.0
-  - uniq-deep ==1.2.0
+  - uniq-deep ==1.2.1
   - unique ==0.0.1
   - unique-logic ==0.4
   - unique-logic-tf ==0.5.1
···
   - unordered-containers ==0.2.14.0
   - unsafe ==0.0
   - urbit-hob ==0.3.3
-  - uri-bytestring ==0.3.3.0
+  - uri-bytestring ==0.3.3.1
   - uri-bytestring-aeson ==0.1.0.8
   - uri-encode ==1.5.0.7
   - url ==2.1.3
···
   - uuid-types ==1.0.5
   - validation ==1.1.1
   - validation-selective ==0.1.0.1
-  - validity ==0.11.0.0
+  - validity ==0.11.0.1
   - validity-aeson ==0.2.0.4
   - validity-bytestring ==0.4.1.1
   - validity-containers ==0.5.0.4
···
   - vector-instances ==3.4
   - vector-mmap ==0.0.3
   - vector-rotcev ==0.1.0.0
-  - vector-sized ==1.4.3.1
+  - vector-sized ==1.4.4
   - vector-space ==0.16
   - vector-split ==1.0.0.2
   - vector-th-unbox ==0.2.1.9
···
   - wai-slack-middleware ==0.2.0
   - wai-websockets ==3.0.1.2
   - wakame ==0.1.0.0
-  - warp ==3.3.16
+  - warp ==3.3.17
   - warp-tls ==3.3.1
   - warp-tls-uid ==0.2.0.6
   - wave ==0.2.0
···
   - xdg-basedir ==0.2.2
   - xdg-userdirs ==0.1.0.2
   - xeno ==0.4.2
-  - xlsx ==0.8.3
+  - xlsx ==0.8.4
   - xlsx-tabular ==0.2.2.1
   - xml ==1.3.14
   - xml-basic ==0.1.3.1
···
   - xxhash-ffi ==0.2.0.0
   - yaml ==0.11.5.0
   - yamlparse-applicative ==0.2.0.0
-  - yesod ==1.6.1.1
+  - yesod ==1.6.1.2
   - yesod-auth ==1.6.10.3
   - yesod-auth-hashdb ==1.7.1.7
   - yesod-auth-oauth2 ==0.6.3.4
   - yesod-bin ==1.6.1
-  - yesod-core ==1.6.20.1
+  - yesod-core ==1.6.20.2
   - yesod-fb ==0.6.1
   - yesod-form ==1.7.0
   - yesod-gitrev ==0.2.1

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

···
  - avers-api
  - avers-api-docs
  - avers-server
+ - aviation-navigation
  - avro-piper
  - awesomium
  - awesomium-glut
···
  - convertible-text
  - coordinate
  - copilot
- - copilot-c99
  - copilot-cbmc
  - copilot-language
  - copilot-libraries
···
  - hasql-cursor-query
  - hasql-postgres
  - hasql-postgres-options
+ - hasql-queue
  - hasql-th
  - hastache-aeson
  - haste-app
···
  - keera-hails-reactive-yampa
  - keera-hails-reactivelenses
  - keera-posture
+ - keid-core
+ - keid-geometry
+ - keid-render-basic
+ - keid-resource-gltf
+ - keid-ui-dearimgui
  - kevin
  - keysafe
  - keyvaluehash
···
  - polysemy-fs
  - polysemy-fskvstore
  - polysemy-http
+ - polysemy-keyed-state
  - polysemy-kvstore-jsonfile
  - polysemy-log
  - polysemy-log-co
···
  - swearjure
  - sweet-egison
  - switch
+ - sydtest-persistent-postgresql
  - sylvia
  - sym-plot
  - symantic-atom

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

···
 
   cachix = generateOptparseApplicativeCompletion "cachix" super.cachix;
 
+  # Enable extra optimisations which increase build time, but also
+  # later compiler performance, so we should do this for user's benefit.
+  # Flag added in Agda 2.6.2
+  Agda = appendConfigureFlag super.Agda "-foptimise-heavily";
+
 }

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

···
 
   "Agda" = callPackage
     ({ mkDerivation, aeson, alex, array, async, base, binary
-     , blaze-html, boxes, bytestring, Cabal, containers, data-hash
-     , deepseq, directory, edit-distance, emacs, equivalence, exceptions
-     , filepath, geniplate-mirror, ghc-compact, gitrev, happy, hashable
-     , hashtables, haskeline, ieee754, mtl, murmur-hash, pretty, process
-     , regex-tdfa, split, stm, strict, template-haskell, text, time
-     , transformers, unordered-containers, uri-encode, zlib
-     }:
-     mkDerivation {
-       pname = "Agda";
-       version = "2.6.1.3";
-       sha256 = "1rx1r21kpgz27g2qn6fqgdpkl5b07c2fl86j3clylpp9rr0ch6xv";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       setupHaskellDepends = [ base Cabal directory filepath process ];
-       libraryHaskellDepends = [
-         aeson array async base binary blaze-html boxes bytestring
-         containers data-hash deepseq directory edit-distance equivalence
-         exceptions filepath geniplate-mirror ghc-compact gitrev hashable
-         hashtables haskeline ieee754 mtl murmur-hash pretty process
-         regex-tdfa split stm strict template-haskell text time transformers
-         unordered-containers uri-encode zlib
-       ];
-       libraryToolDepends = [ alex happy ];
-       executableHaskellDepends = [ base directory filepath process ];
-       executableToolDepends = [ emacs ];
-       description = "A dependently typed functional programming language and proof assistant";
-       license = "unknown";
-       hydraPlatforms = lib.platforms.none;
-       maintainers = with lib.maintainers; [ abbradar turion ];
-     }) {inherit (pkgs) emacs;};
-
-  "Agda_2_6_2" = callPackage
-    ({ mkDerivation, aeson, alex, array, async, base, binary
      , blaze-html, boxes, bytestring, Cabal, case-insensitive
      , containers, data-hash, deepseq, directory, edit-distance, emacs
      , equivalence, exceptions, filepath, ghc-compact, gitrev, happy
···
     ({ mkDerivation, base, containers, mtl }:
      mkDerivation {
        pname = "Kawaii-Parser";
-       version = "0.0.0";
-       sha256 = "163rh1vciljl35wc5wrcr1ky2vb536pv6hhnl3r97mfjc9c9k2wm";
+       version = "1.0.1";
+       sha256 = "032kglqc4pfhig7wqqsps0g490ajp1yffl4h4lr3qs98vi7vl4x6";
        libraryHaskellDepends = [ base containers mtl ];
        description = "A simple parsing library";
        license = lib.licenses.bsd3;
···
        testHaskellDepends = [ base containers filepath hspec text ];
        description = "Check for unused code in an Agda project";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "agda2lagda" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "aviation-navigation" = callPackage
+    ({ mkDerivation, base, lens, mtl, optparse-applicative, radian }:
+     mkDerivation {
+       pname = "aviation-navigation";
+       version = "0.1.0.0";
+       sha256 = "17nb2ryrxdy3sv68cnbv7saw5k9wh9nyas74bpsyn0p8grw71sd5";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base lens mtl optparse-applicative radian
+       ];
+       executableHaskellDepends = [
+         base lens mtl optparse-applicative radian
+       ];
+       description = "Aviation Navigation functions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "aviation-units" = callPackage
     ({ mkDerivation, base, lens }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "aws-xray-client";
-       version = "0.1.0.0";
-       sha256 = "0rb46hz2y9mz0prgyb5m2v31j05cx18j6yl01pawhrb6v8pb7z00";
-       libraryHaskellDepends = [
-         aeson base bytestring deepseq http-types lens network random text
-         time
-       ];
-       testHaskellDepends = [
-         aeson aeson-qq base generic-arbitrary hspec lens QuickCheck random
-         text
-       ];
-       benchmarkHaskellDepends = [ async base criterion random time ];
-       description = "A client for AWS X-Ray";
-       license = lib.licenses.mit;
-     }) {};
-
-  "aws-xray-client_0_1_0_1" = callPackage
-    ({ mkDerivation, aeson, aeson-qq, async, base, bytestring
-     , criterion, deepseq, generic-arbitrary, hspec, http-types, lens
-     , network, QuickCheck, random, text, time
-     }:
-     mkDerivation {
-       pname = "aws-xray-client";
        version = "0.1.0.1";
        sha256 = "1b179i32aw3xi72vnxmgvgczq14ay159cji9mmk345shdiac6crj";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ async base criterion random time ];
        description = "A client for AWS X-Ray";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "aws-xray-client-persistent" = callPackage
···
      }:
      mkDerivation {
        pname = "aws-xray-client-wai";
-       version = "0.1.0.0";
-       sha256 = "1vrgx2l3f08bd73z0an15zh3fla0d5sxqvwbsk1jxkrjfy2c43rd";
-       libraryHaskellDepends = [
-         aws-xray-client base bytestring containers http-types lens random
-         text time unliftio unliftio-core vault wai
-       ];
-       description = "A client for AWS X-Ray integration with WAI";
-       license = lib.licenses.mit;
-     }) {};
-
-  "aws-xray-client-wai_0_1_0_1" = callPackage
-    ({ mkDerivation, aws-xray-client, base, bytestring, containers
-     , http-types, lens, random, text, time, unliftio, unliftio-core
-     , vault, wai
-     }:
-     mkDerivation {
-       pname = "aws-xray-client-wai";
        version = "0.1.0.1";
        sha256 = "0b2rnls3qk7qzn9swfqmslxrw466gs6lhh7zi677k5b0dzh237vp";
        libraryHaskellDepends = [
···
        ];
        description = "A client for AWS X-Ray integration with WAI";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "axel" = callPackage
···
      }:
      mkDerivation {
        pname = "base32";
-       version = "0.2.0.0";
-       sha256 = "0xvilxcdcvz07f3qpad35whjd35c9ykicip2cdsd54ysxg71mwzm";
-       revision = "2";
-       editedCabalFile = "0chbgkq65mh6nc48a3hywcv7idfqgb3acv4b7gmz8m6szqq4mx95";
-       libraryHaskellDepends = [
-         base bytestring deepseq ghc-byteorder text text-short
-       ];
-       testHaskellDepends = [
-         base bytestring memory QuickCheck random-bytestring tasty
-         tasty-hunit tasty-quickcheck text text-short
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq memory random-bytestring text
-       ];
-       description = "Fast RFC 4648-compliant Base32 encoding";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "base32_0_2_1_0" = callPackage
-    ({ mkDerivation, base, bytestring, criterion, deepseq
-     , ghc-byteorder, memory, QuickCheck, random-bytestring, tasty
-     , tasty-hunit, tasty-quickcheck, text, text-short
-     }:
-     mkDerivation {
-       pname = "base32";
        version = "0.2.1.0";
        sha256 = "1c1qzbri6m8b2m1cr68vrjbny6wlvfyrbfyzd61s83a3y3w39plp";
        revision = "1";
···
        ];
        description = "Fast RFC 4648-compliant Base32 encoding";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "base32-bytestring" = callPackage
···
      }:
      mkDerivation {
        pname = "beam-core";
-       version = "0.9.0.0";
-       sha256 = "0ixaxjmgg162ff7srvwmkv5lp1kfb0b6wmrpaz97rsmlpa5vf6ji";
+       version = "0.9.1.0";
+       sha256 = "1rw3db9qmf08wi5gcd0cbsz5cpndf8cwkbzkh74gbwwpcpa7lg39";
        libraryHaskellDepends = [
          aeson base bytestring containers dlist free ghc-prim hashable
          microlens mtl network-uri scientific tagged text time vector
···
      }:
      mkDerivation {
        pname = "beam-migrate";
-       version = "0.5.0.0";
-       sha256 = "0xrmb5nmn5ffzgcpsjilagz5ppm283kfjvvbnsvpvnh6p6i0xc99";
+       version = "0.5.1.0";
+       sha256 = "0wvbs7lda7pxsrymm2dv2km1w3snd8mjwijagn06ylrc2pjn6sjz";
        libraryHaskellDepends = [
          aeson base beam-core bytestring containers deepseq dependent-map
          dependent-sum free ghc-prim hashable haskell-src-exts microlens mtl
···
      , haskell-src-exts, hedgehog, lifted-base, monad-control, mtl
      , network-uri, postgresql-libpq, postgresql-simple, scientific
      , tagged, tasty, tasty-hunit, text, time, tmp-postgres
-     , unordered-containers, uuid, uuid-types, vector
+     , transformers-base, unordered-containers, uuid, uuid-types, vector
      }:
      mkDerivation {
        pname = "beam-postgres";
-       version = "0.5.0.0";
-       sha256 = "03dd9qzw3b2rqva2pn4iaq5lswn8gb7lrlsa6nmc0bfn1w9i4a7k";
+       version = "0.5.1.0";
+       sha256 = "17npmh5agnxy12n93hrpi83al80csmvigbm3mlsvx92l4mcif2ml";
        libraryHaskellDepends = [
          aeson attoparsec base beam-core beam-migrate bytestring
          case-insensitive conduit free hashable haskell-src-exts lifted-base
          monad-control mtl network-uri postgresql-libpq postgresql-simple
-         scientific tagged text time unordered-containers uuid-types vector
+         scientific tagged text time transformers-base unordered-containers
+         uuid-types vector
        ];
        testHaskellDepends = [
          aeson base beam-core beam-migrate bytestring hedgehog
···
 
   "beam-sqlite" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, beam-core, beam-migrate
-     , bytestring, dlist, free, hashable, mtl, network-uri, scientific
-     , sqlite-simple, tasty, tasty-expected-failure, tasty-hunit, text
-     , time, unix
+     , bytestring, dlist, free, hashable, monad-control, mtl
+     , network-uri, scientific, sqlite-simple, tasty
+     , tasty-expected-failure, tasty-hunit, text, time
+     , transformers-base, unix
      }:
      mkDerivation {
        pname = "beam-sqlite";
-       version = "0.5.0.0";
-       sha256 = "1ng67jspdwp4prfzp9lzhl1g26q9bfpmxpwv0q392y8wwrq6zxrj";
+       version = "0.5.1.0";
+       sha256 = "1vfrma27rchq3p4h0p21m3lhz46yxyagbrb39r9jb8w20whja2gr";
        libraryHaskellDepends = [
          aeson attoparsec base beam-core beam-migrate bytestring dlist free
-         hashable mtl network-uri scientific sqlite-simple text time unix
+         hashable monad-control mtl network-uri scientific sqlite-simple
+         text time transformers-base unix
        ];
        testHaskellDepends = [
          base beam-core beam-migrate sqlite-simple tasty
···
      }) {};
 
   "bech32" = callPackage
-    ({ mkDerivation, array, base, base58-bytestring, bytestring
-     , containers, deepseq, extra, hspec, hspec-discover, memory
-     , optparse-applicative, process, QuickCheck, text, vector
-     }:
-     mkDerivation {
-       pname = "bech32";
-       version = "1.1.0";
-       sha256 = "0s7kqy128k71rnpv22awf643djhsyd8ipihx38lvslsxk8klr8i0";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         array base bytestring containers extra text
-       ];
-       executableHaskellDepends = [
-         base base58-bytestring bytestring extra memory optparse-applicative
-         text
-       ];
-       testHaskellDepends = [
-         base base58-bytestring bytestring containers deepseq extra hspec
-         memory process QuickCheck text vector
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Implementation of the Bech32 cryptocurrency address format (BIP 0173)";
-       license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "bech32_1_1_1" = callPackage
     ({ mkDerivation, array, base, base58-bytestring, bytestring
      , containers, deepseq, extra, hspec, hspec-discover, memory
      , optparse-applicative, process, QuickCheck, text, vector
···
 
   "bugzilla-redhat" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, connection
-     , containers, http-conduit, http-types, iso8601-time, resourcet
-     , text, time, transformers, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "bugzilla-redhat";
-       version = "0.3.1";
-       sha256 = "088ya35lwxnvg0x996agy2ky8kp4r3j2i1ja15fy3afcqfpvbqiv";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base blaze-builder bytestring connection containers
-         http-conduit http-types iso8601-time resourcet text time
-         transformers unordered-containers vector
-       ];
-       description = "A Haskell interface to the Bugzilla native REST API";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "bugzilla-redhat_0_3_2" = callPackage
-    ({ mkDerivation, aeson, base, blaze-builder, bytestring, connection
      , containers, hspec, http-conduit, http-types, iso8601-time
      , resourcet, text, time, transformers, unordered-containers, vector
      }:
···
        testHaskellDepends = [ aeson base hspec time ];
        description = "A Haskell interface to the Bugzilla native REST API";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "build" = callPackage
···
      }:
      mkDerivation {
        pname = "camfort";
-       version = "1.0.1";
-       sha256 = "1jwlkrf4aja71sbxxlxsd7syh6sb4vgv2pb18mvj5ppm6al2ykp3";
+       version = "1.1.0";
+       sha256 = "0y6ds8lhhs0r4ns35y6zrph3bjkq9kdx4zp7kb8knsn0cpd3haz1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
   "chessIO" = callPackage
     ({ mkDerivation, attoparsec, base, binary, brick, bytestring
      , containers, deepseq, directory, extra, file-embed, filepath
-     , hashable, haskeline, lens, megaparsec, MonadRandom
+     , hashable, haskeline, HUnit, lens, megaparsec, MonadRandom
      , mono-traversable, mtl, o-clock, optparse-applicative, parallel
      , prettyprinter, process, random, rosezipper, stm, template-haskell
-     , text, th-lift-instances, time, unordered-containers, vector
-     , vector-binary-instances, vector-instances, vty
+     , text, th-compat, th-lift-instances, time, unordered-containers
+     , vector, vector-binary-instances, vector-instances, vty
      }:
      mkDerivation {
        pname = "chessIO";
-       version = "0.7.0.0";
-       sha256 = "1jb1c702c58g0pkk43g1mp7clm0wbkq993j880v3p7cxbyj5n9bh";
+       version = "0.8.0.0";
+       sha256 = "16xgq8xvfvk6rsjzaimd29b867ffml2h9nldsy5d5sninbmbq0k8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          attoparsec base binary bytestring containers deepseq extra
          file-embed hashable lens megaparsec MonadRandom mono-traversable
          o-clock prettyprinter process random stm template-haskell text
-         th-lift-instances unordered-containers vector
+         th-compat th-lift-instances unordered-containers vector
          vector-binary-instances vector-instances
        ];
        executableHaskellDepends = [
          attoparsec base binary brick bytestring containers deepseq extra
          file-embed filepath hashable haskeline lens megaparsec MonadRandom
          mono-traversable mtl o-clock optparse-applicative prettyprinter
-         process random rosezipper stm template-haskell text
+         process random rosezipper stm template-haskell text th-compat
          th-lift-instances time unordered-containers vector
          vector-binary-instances vector-instances vty
        ];
        testHaskellDepends = [
          attoparsec base binary bytestring containers deepseq directory
-         extra file-embed hashable lens megaparsec MonadRandom
+         extra file-embed hashable HUnit lens megaparsec MonadRandom
          mono-traversable o-clock parallel prettyprinter process random stm
-         template-haskell text th-lift-instances time unordered-containers
-         vector vector-binary-instances vector-instances
+         template-haskell text th-compat th-lift-instances time
+         unordered-containers vector vector-binary-instances
+         vector-instances
        ];
        description = "Basic chess library";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "closed-intervals";
-       version = "0.1.0.1";
-       sha256 = "19vmiwwzv9g4nl1mzkqc7r9bw67n9y7kk3v0jc2vc8yjzrmqgy7v";
+       version = "0.1.1.0";
+       sha256 = "0wmxacb9msr7bip5pz9qwgvg9kgvpyylps6xhsg85blhd2bplmbi";
        libraryHaskellDepends = [ base containers time ];
        testHaskellDepends = [
          base containers doctest-exitcode-stdio doctest-lib QuickCheck time
···
        ];
        description = "Closed intervals of totally ordered types";
        license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "closure" = callPackage
···
      }:
      mkDerivation {
        pname = "colour";
-       version = "2.3.5";
-       sha256 = "1rq4l46jx4lpdppy71wf7m1n7pw2jwy788rm35ycwzb1g4clg39v";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [
-         base QuickCheck random test-framework test-framework-quickcheck2
-       ];
-       description = "A model for human colour/color perception";
-       license = lib.licenses.mit;
-     }) {};
-
-  "colour_2_3_6" = callPackage
-    ({ mkDerivation, base, QuickCheck, random, test-framework
-     , test-framework-quickcheck2
-     }:
-     mkDerivation {
-       pname = "colour";
        version = "2.3.6";
        sha256 = "0wgqj64mh2y2zk77kv59k3xb3dk4wmgfp988y74sp9a4d76mvlrc";
        enableSeparateDataOutput = true;
···
        ];
        description = "A model for human colour/color perception";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "colour-accelerate" = callPackage
···
      }:
      mkDerivation {
        pname = "commonmark";
-       version = "0.2";
-       sha256 = "083xrmyxsgn6ivrxqgmjbqvv4k64n7a330pbf1n7xbsjqh78cg28";
-       libraryHaskellDepends = [
-         base bytestring containers parsec text transformers
-         unicode-transforms
-       ];
-       testHaskellDepends = [
-         base parsec tasty tasty-hunit tasty-quickcheck text
-         unicode-transforms
-       ];
-       benchmarkHaskellDepends = [ base tasty-bench text ];
-       description = "Pure Haskell commonmark parser";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "commonmark_0_2_1" = callPackage
-    ({ mkDerivation, base, bytestring, containers, parsec, tasty
-     , tasty-bench, tasty-hunit, tasty-quickcheck, text, transformers
-     , unicode-transforms
-     }:
-     mkDerivation {
-       pname = "commonmark";
        version = "0.2.1";
        sha256 = "1vba7v1zaqh811v3j4x42g7mhwvxwgzm997kq1kzd0njby14fq5b";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base tasty-bench text ];
        description = "Pure Haskell commonmark parser";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "commonmark-cli" = callPackage
···
      }:
      mkDerivation {
        pname = "commonmark-pandoc";
-       version = "0.2.1";
-       sha256 = "0i5qavci8j63d15i2c6cbm0b53kcjh7s4vxadfgf4vkp2sy1ybvw";
-       libraryHaskellDepends = [
-         base commonmark commonmark-extensions pandoc-types text
-       ];
-       description = "Bridge between commonmark and pandoc AST";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "commonmark-pandoc_0_2_1_1" = callPackage
-    ({ mkDerivation, base, commonmark, commonmark-extensions
-     , pandoc-types, text
-     }:
-     mkDerivation {
-       pname = "commonmark-pandoc";
        version = "0.2.1.1";
        sha256 = "15rfaz49msswb7gh5wyxpm9vckbf3wzyd2m5m2f3hggb82ydk5cp";
        libraryHaskellDepends = [
···
        ];
        description = "Bridge between commonmark and pandoc AST";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "commsec" = callPackage
···
      }:
      mkDerivation {
        pname = "copilot";
-       version = "3.3";
-       sha256 = "166nin0861i2ak06gdhj6sv6zv7cc60wmqgv4mly9hjf0qp3w6j1";
+       version = "3.4";
+       sha256 = "1cl7w9z08rnzsig09q65i6j4644zj469isd1mjjiwp23yiqs5gfh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "copilot-c99" = callPackage
-    ({ mkDerivation, base, containers, copilot-core, copilot-language
-     , csv, directory, filepath, hspec, language-c99
-     , language-c99-simple, language-c99-util, mtl, pretty, process
-     , QuickCheck
+    ({ mkDerivation, base, containers, copilot-core, directory
+     , filepath, language-c99, language-c99-simple, language-c99-util
+     , mtl, pretty
      }:
      mkDerivation {
        pname = "copilot-c99";
-       version = "3.3";
-       sha256 = "09qjfhf0dkccbi4kycwqavv7bxdpfj2j50vkljmzrxh59xq00jnz";
+       version = "3.4";
+       sha256 = "14ajk29p4da777r9klfqhcyi5qkrz16qn5f6h22kgw1vqj9vm4ja";
        libraryHaskellDepends = [
          base containers copilot-core directory filepath language-c99
          language-c99-simple language-c99-util mtl pretty
        ];
-       testHaskellDepends = [
-         base copilot-core copilot-language csv hspec language-c99
-         language-c99-simple pretty process QuickCheck
-       ];
        description = "A compiler for Copilot targeting C99";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "copilot-cbmc" = callPackage
···
     ({ mkDerivation, base, dlist, mtl, pretty }:
      mkDerivation {
        pname = "copilot-core";
-       version = "3.3";
-       sha256 = "19k206hsqd3lw2k40cjpjhnwfjsfraagw622bxn97rk4195jqhy6";
+       version = "3.4";
+       sha256 = "01bxajyxd9na6msjnh6klnhc71xryc7nxz96pylyqn39978by7p0";
        libraryHaskellDepends = [ base dlist mtl pretty ];
        description = "An intermediate representation for Copilot";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "copilot-language";
-       version = "3.3";
-       sha256 = "1x39jyn82j9mydsbi8n24a2nx8j00gcxw2rsxqagjpwqx10igyr2";
+       version = "3.4";
+       sha256 = "0i3ha9mpjizqalhnv2vvcgzs75r3ld7c4qhaknip3jw1d0j76fx6";
        libraryHaskellDepends = [
          array base containers copilot-core copilot-theorem data-reify
          ghc-prim mtl
···
      }:
      mkDerivation {
        pname = "copilot-libraries";
-       version = "3.3";
-       sha256 = "0f8g67j26g1k5xph6zg5crypj0ys8mf0i5pazn04sy02lslsdmd9";
+       version = "3.4";
+       sha256 = "13ypvpqr0g3xrvdria35c83yxpk3727wm6n8jdsihq7ilkhl00mf";
        libraryHaskellDepends = [
          array base containers copilot-language data-reify mtl parsec
        ];
···
      }:
      mkDerivation {
        pname = "copilot-theorem";
-       version = "3.3";
-       sha256 = "1js4j9alfnlxi6zsvcdj8zf2r04lm9rp22r6zq6qkhams6pmmxly";
+       version = "3.4";
+       sha256 = "1mrw6i4dwg8cx56821vcy0bnzyhxcch0k9byrkazg3jgplvalfbr";
        libraryHaskellDepends = [
          ansi-terminal base bimap bv-sized containers copilot-core
          data-default directory filepath libBF mtl panic parameterized-utils
···
      }:
      mkDerivation {
        pname = "criterion-measurement";
-       version = "0.1.2.0";
-       sha256 = "03p71mfnnfjx9dnf0yhrhdcr30zc2nwn5f8lql48cabccpd3793l";
+       version = "0.1.3.0";
+       sha256 = "1ffmjcpmdx2sx0sr3g5n2s8dhrbmh7606zfnymv2v9h1rf36xf3x";
        libraryHaskellDepends = [
          aeson base base-compat binary containers deepseq vector
        ];
···
     ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
      , conduit, conduit-extra, containers, data-default, directory
      , exceptions, ghc-prim, HUnit, mmorph, monad-control, mtl
-     , primitive, resourcet, semigroups, test-framework
-     , test-framework-hunit, text, transformers, unordered-containers
-     , vector
+     , ordered-containers, primitive, resourcet, semigroups
+     , test-framework, test-framework-hunit, text, transformers
+     , unordered-containers, vector
      }:
      mkDerivation {
        pname = "csv-conduit";
-       version = "0.7.2.0";
-       sha256 = "1bclavsan00mv0n0dy0ap6byk4w5fwnhpvxhdhx94r7bxfqi2r0q";
+       version = "0.7.3.0";
+       sha256 = "1xh11h4qibjcv8b0rk5mwdzww183kpjqzl3x22rbfryjvrp0n07w";
        libraryHaskellDepends = [
          array attoparsec base blaze-builder bytestring conduit
          conduit-extra containers data-default exceptions ghc-prim mmorph
-         monad-control mtl primitive resourcet semigroups text transformers
-         unordered-containers vector
+         monad-control mtl ordered-containers primitive resourcet semigroups
+         text transformers unordered-containers vector
        ];
        testHaskellDepends = [
-         base bytestring containers directory HUnit mtl primitive
-         test-framework test-framework-hunit text transformers vector
+         base bytestring conduit containers directory HUnit mtl
+         ordered-containers primitive test-framework test-framework-hunit
+         text transformers vector
        ];
        description = "A flexible, fast, conduit-based CSV parser library for Haskell";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "cuda";
-       version = "0.10.2.0";
-       sha256 = "0fkjibnnxradhsbasx1mw0c088cfwypnk6a5002rxpzxid5qrp9l";
+       version = "0.11.0.0";
+       sha256 = "0j35p4i611jkxa3i59gvc7vgbkzx7ckri1fd1n0ryv8akn4gl9m8";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal directory filepath ];
···
        testHaskellDepends = [ base doctest ];
        description = "Digits 0-9";
        license = lib.licenses.mit;
+     }) {};
+
+  "d10_0_3_0_1" = callPackage
+    ({ mkDerivation, base, hedgehog, template-haskell }:
+     mkDerivation {
+       pname = "d10";
+       version = "0.3.0.1";
+       sha256 = "0fw6hl0ikfxgqhns18f0h3hs2ihi2d09jpjvmgrzddf3d8lrrlnh";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base hedgehog template-haskell ];
+       description = "Digits 0-9";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "d3d11binding" = callPackage
···
     ({ mkDerivation, base, mtl, template-haskell }:
      mkDerivation {
        pname = "data-lens-light";
-       version = "0.1.2.2";
-       sha256 = "0vmkvhl7zcsaxnx7d7b59cnrdnlnr9cfn910rpn34jny7fkydlvj";
-       libraryHaskellDepends = [ base mtl template-haskell ];
-       description = "Simple lenses, minimum dependencies";
-       license = lib.licenses.mit;
-     }) {};
-
-  "data-lens-light_0_1_2_3" = callPackage
-    ({ mkDerivation, base, mtl, template-haskell }:
-     mkDerivation {
-       pname = "data-lens-light";
        version = "0.1.2.3";
        sha256 = "1xczbmgin315qh9wpl6v2vvnp6hv1irfbfqs7pk034qcpx61fwdl";
        libraryHaskellDepends = [ base mtl template-haskell ];
        description = "Simple lenses, minimum dependencies";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "data-lens-template" = callPackage
···
        testHaskellDepends = [ base containers hspec lens mtl random ];
        description = "A simulator for the board game Dominion";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "domplate" = callPackage
···
      }:
      mkDerivation {
        pname = "email-validate";
-       version = "2.3.2.13";
-       sha256 = "0wh955b9wwqwl8jbkzyxxaf8q9y80dbh0f6vaxxzh2cc7zqc31im";
+       version = "2.3.2.15";
+       sha256 = "0n67wss6k8lhwfkybkhsa04bbdfdv541sacbxlylkx2hqpj5r5gh";
        libraryHaskellDepends = [
          attoparsec base bytestring template-haskell
        ];
        testHaskellDepends = [ base bytestring doctest hspec QuickCheck ];
        description = "Email address validation";
        license = lib.licenses.bsd3;
-     }) {};
-
-  "email-validate_2_3_2_14" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, doctest, hspec
-     , QuickCheck, template-haskell
-     }:
-     mkDerivation {
-       pname = "email-validate";
-       version = "2.3.2.14";
-       sha256 = "1jl93c5xm20gpngqxgzbcaqhkjl9nxsph17qgzyd2whmkz5yxhk7";
-       libraryHaskellDepends = [
-         attoparsec base bytestring template-haskell
-       ];
-       testHaskellDepends = [ base bytestring doctest hspec QuickCheck ];
-       description = "Email address validation";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "email-validate-json" = callPackage
···
 
   "esqueleto" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
-     , conduit, containers, exceptions, hspec, monad-logger, mtl, mysql
-     , mysql-simple, persistent, persistent-mysql, persistent-postgresql
-     , persistent-sqlite, postgresql-libpq, postgresql-simple, resourcet
-     , tagged, text, time, transformers, unliftio, unordered-containers
-     , vector
-     }:
-     mkDerivation {
-       pname = "esqueleto";
-       version = "3.5.0.0";
-       sha256 = "00mamdsm4yc8gdvb5zfnhnp7iqkg7h9fd5jgzrbdh9q7isyc6kiy";
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-html bytestring conduit containers
-         monad-logger persistent resourcet tagged text time transformers
-         unliftio unordered-containers
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base blaze-html bytestring conduit containers
-         exceptions hspec monad-logger mtl mysql mysql-simple persistent
-         persistent-mysql persistent-postgresql persistent-sqlite
-         postgresql-libpq postgresql-simple resourcet tagged text time
-         transformers unliftio unordered-containers vector
-       ];
-       description = "Type-safe EDSL for SQL queries on persistent backends";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "esqueleto_3_5_2_0" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
      , conduit, containers, exceptions, hspec, hspec-core, monad-logger
      , mtl, mysql, mysql-simple, persistent, persistent-mysql
      , persistent-postgresql, persistent-sqlite, postgresql-simple
···
        ];
        description = "Type-safe EDSL for SQL queries on persistent backends";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ess" = callPackage
···
     ({ mkDerivation, base, leancheck, template-haskell }:
      mkDerivation {
        pname = "express";
-       version = "0.1.14";
-       sha256 = "19sjh12sjpxhk7wg2b3abga7bpk6ckry19zi58imqmy8xbh6ds39";
+       version = "0.1.16";
+       sha256 = "04a1iv3dzyni7b0yvzqf1s8l0wg07hk9sg6d59hdbsl4f3kw8ki4";
        libraryHaskellDepends = [ base template-haskell ];
        testHaskellDepends = [ base leancheck ];
        benchmarkHaskellDepends = [ base leancheck ];
-       description = "Dynamically-typed expressions involving applications and variables";
+       description = "Dynamically-typed expressions involving function application and variables";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "express_1_0_0" = callPackage
+    ({ mkDerivation, base, leancheck, template-haskell }:
+     mkDerivation {
+       pname = "express";
+       version = "1.0.0";
+       sha256 = "1aymnlq1nkw7qvrydmy0447ls5lnnjkhvpgicr56p2v65xrd37qx";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base leancheck ];
+       benchmarkHaskellDepends = [ base leancheck ];
+       description = "Dynamically-typed expressions involving function application and variables";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "expression-parser" = callPackage
···
        maintainers = with lib.maintainers; [ Gabriel439 ];
      }) {};
 
+  "foldl_1_4_12" = callPackage
+    ({ mkDerivation, base, bytestring, comonad, containers
+     , contravariant, criterion, doctest, hashable, primitive
+     , profunctors, random, semigroupoids, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "foldl";
+       version = "1.4.12";
+       sha256 = "0zf4yljh3s2ddxa7dhzdglmylj14kfldhkclc44g37zvjq6kcnag";
+       libraryHaskellDepends = [
+         base bytestring comonad containers contravariant hashable primitive
+         profunctors random semigroupoids text transformers
+         unordered-containers vector
+       ];
+       testHaskellDepends = [ base doctest ];
+       benchmarkHaskellDepends = [ base criterion ];
+       description = "Composable, streaming, and efficient left folds";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ Gabriel439 ];
+     }) {};
+
   "foldl-exceptions" = callPackage
     ({ mkDerivation, base, doctest, foldl, safe-exceptions }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "formatting";
-       version = "7.1.2";
-       sha256 = "13sdc3wc8ahf18g5yld9bqi5yhbbg1w1r69rims93c5bxhiw3f9f";
-       libraryHaskellDepends = [
-         base clock double-conversion ghc-prim old-locale scientific text
-         time transformers
-       ];
-       testHaskellDepends = [ base ghc-prim hspec scientific text ];
-       benchmarkHaskellDepends = [
-         base criterion ghc-prim QuickCheck text
-       ];
-       description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "formatting_7_1_3" = callPackage
-    ({ mkDerivation, base, clock, criterion, double-conversion
-     , ghc-prim, hspec, old-locale, QuickCheck, scientific, text, time
-     , transformers
-     }:
-     mkDerivation {
-       pname = "formatting";
        version = "7.1.3";
        sha256 = "1vrc2i1b6lxx2aq5hysfl3gl6miq2wbhxc384axvgrkqjbibnqc0";
        libraryHaskellDepends = [
···
        ];
        description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "forml" = callPackage
···
     ({ mkDerivation, aeson, alex, ansi-terminal, array, base, binary
      , blaze-html, bmp, bytestring, bytestring-to-vector, cmark-gfm
      , containers, directory, directory-tree, dlist, file-embed
-     , filepath, free, gitrev, happy, hashable, haskeline
-     , language-c-quote, mainland-pretty, megaparsec, mtl
-     , neat-interpolation, parallel, parser-combinators, pcg-random
-     , process, process-extras, QuickCheck, regex-tdfa, srcloc, tasty
-     , tasty-hunit, tasty-quickcheck, template-haskell, temporary
-     , terminal-size, text, time, transformers, unordered-containers
-     , utf8-string, vector, vector-binary-instances, versions
-     , zip-archive, zlib
+     , filepath, free, futhark-data, futhark-server, gitrev, happy
+     , hashable, haskeline, language-c-quote, mainland-pretty
+     , megaparsec, mtl, neat-interpolation, parallel, parser-combinators
+     , pcg-random, process, process-extras, QuickCheck, regex-tdfa
+     , srcloc, tasty, tasty-hunit, tasty-quickcheck, template-haskell
+     , temporary, terminal-size, text, time, transformers
+     , unordered-containers, utf8-string, vector
+     , vector-binary-instances, versions, zip-archive, zlib
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.19.6";
-       sha256 = "1wpg2ad2xv60xsdvnq3246nps3ldc00n58k7jxmh8lrx5bjzg263";
+       version = "0.19.7";
+       sha256 = "1c3la98gsw3xxvakg4zsknwn3z3whn75r5vr9rf6w6f48jl0829k";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal array base binary blaze-html bmp bytestring
          bytestring-to-vector cmark-gfm containers directory directory-tree
-         dlist file-embed filepath free gitrev hashable haskeline
-         language-c-quote mainland-pretty megaparsec mtl neat-interpolation
-         parallel pcg-random process process-extras regex-tdfa srcloc
-         template-haskell temporary terminal-size text time transformers
-         unordered-containers utf8-string vector vector-binary-instances
-         versions zip-archive zlib
+         dlist file-embed filepath free futhark-data futhark-server gitrev
+         hashable haskeline language-c-quote mainland-pretty megaparsec mtl
+         neat-interpolation parallel pcg-random process process-extras
+         regex-tdfa srcloc template-haskell temporary terminal-size text
+         time transformers unordered-containers utf8-string vector
+         vector-binary-instances versions zip-archive zlib
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [ base text ];
···
        pname = "generic-aeson";
        version = "0.2.0.12";
        sha256 = "17br2dl9gd2hyflgp0fzqs5ghp4my4l234pjfvvnhk9n4szxzcr3";
+       revision = "1";
+       editedCabalFile = "0nd40p8iqr6bk7py9rblpis2s8i4p5wgg6kfp607mpp4y17xq1dr";
        libraryHaskellDepends = [
          aeson attoparsec base generic-deriving mtl tagged text
          unordered-containers vector
···
        libraryHaskellDepends = [ base QuickCheck ];
        description = "Generic implementation for QuickCheck's Arbitrary";
        license = lib.licenses.mit;
+     }) {};
+
+  "generic-arbitrary_0_2_0" = callPackage
+    ({ mkDerivation, base, QuickCheck }:
+     mkDerivation {
+       pname = "generic-arbitrary";
+       version = "0.2.0";
+       sha256 = "1wlrsj9l57vqdkaablb8ypq2g1i4mishjag00fyf2imr2cvzkamg";
+       libraryHaskellDepends = [ base QuickCheck ];
+       description = "Generic implementation for QuickCheck's Arbitrary";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "generic-binary" = callPackage
···
     ({ mkDerivation, base, mtl, template-haskell }:
      mkDerivation {
        pname = "geniplate-mirror";
-       version = "0.7.7";
-       sha256 = "08w4rslxzv6z85qzam1yazjb6vrzcr55vsjjyjgsi86pb1a8hr3b";
-       libraryHaskellDepends = [ base mtl template-haskell ];
-       description = "Use Template Haskell to generate Uniplate-like functions";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "geniplate-mirror_0_7_8" = callPackage
-    ({ mkDerivation, base, mtl, template-haskell }:
-     mkDerivation {
-       pname = "geniplate-mirror";
        version = "0.7.8";
        sha256 = "1kw4q7l556sfd82r2p0z3cv4sg8kcr45wb4s2sy996bs3ymn8fjb";
        libraryHaskellDepends = [ base mtl template-haskell ];
        description = "Use Template Haskell to generate Uniplate-like functions";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "geniserver" = callPackage
···
      }:
      mkDerivation {
        pname = "genvalidity";
-       version = "0.11.0.0";
-       sha256 = "0kqhmgq7p94980br47jd6k9m2vjb62idx8x5hrcmybf0dakyscbl";
-       libraryHaskellDepends = [ base QuickCheck random validity ];
-       testHaskellDepends = [ base hspec hspec-core QuickCheck ];
-       description = "Testing utilities for the validity library";
-       license = lib.licenses.mit;
-     }) {};
-
-  "genvalidity_0_11_0_2" = callPackage
-    ({ mkDerivation, base, hspec, hspec-core, QuickCheck, random
-     , validity
-     }:
-     mkDerivation {
-       pname = "genvalidity";
        version = "0.11.0.2";
        sha256 = "16bd5dx0ngc8z7mij23i2l3a8v3c112x8ksd623alik18zx7pi8j";
        libraryHaskellDepends = [ base QuickCheck random validity ];
        testHaskellDepends = [ base hspec hspec-core QuickCheck ];
        description = "Testing utilities for the validity library";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "genvalidity-aeson" = callPackage
···
     ({ mkDerivation, base, ghc }:
      mkDerivation {
        pname = "ghc-tcplugins-extra";
-       version = "0.4.1";
-       sha256 = "0v9y444gydfyk56y7adpabd633yv1d8jmddvgg272n8jpdpagw67";
-       libraryHaskellDepends = [ base ghc ];
-       description = "Utilities for writing GHC type-checker plugins";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "ghc-tcplugins-extra_0_4_2" = callPackage
-    ({ mkDerivation, base, ghc }:
-     mkDerivation {
-       pname = "ghc-tcplugins-extra";
        version = "0.4.2";
        sha256 = "1gddqcczb8ixmrlfbfb06dc470jsjhvsxx3q2nsd4mcx2x6jdk08";
        libraryHaskellDepends = [ base ghc ];
        description = "Utilities for writing GHC type-checker plugins";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-time-alloc-prof" = callPackage
···
     ({ mkDerivation, base, bytestring, tasty-bench, text }:
      mkDerivation {
        pname = "ghc-trace-events";
-       version = "0.1.2.2";
-       sha256 = "18vhv99lrfjx6bxww77qxg7gwqmvpylvlrq1bji0hd6mcxxdjn69";
-       libraryHaskellDepends = [ base bytestring text ];
-       benchmarkHaskellDepends = [ base bytestring tasty-bench ];
-       description = "Faster traceEvent and traceMarker, and binary object logging for eventlog";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ghc-trace-events_0_1_2_3" = callPackage
-    ({ mkDerivation, base, bytestring, tasty-bench, text }:
-     mkDerivation {
-       pname = "ghc-trace-events";
        version = "0.1.2.3";
        sha256 = "11m2ihzlncvxp8x2zgbnzbyybz2lbpdl5flk4gzmq0qz0957j7qd";
        libraryHaskellDepends = [ base bytestring text ];
        benchmarkHaskellDepends = [ base bytestring tasty-bench ];
        description = "Faster traceEvent and traceMarker, and binary object logging for eventlog";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-extra" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-typelits-extra";
-       version = "0.4.2";
-       sha256 = "0xpy52rib25iz5h89nqlj27isjk57pjbhlvlfam5q0g3x92572h4";
-       libraryHaskellDepends = [
-         base containers ghc ghc-prim ghc-tcplugins-extra
-         ghc-typelits-knownnat ghc-typelits-natnormalise integer-gmp
-         transformers
-       ];
-       testHaskellDepends = [
-         base ghc-typelits-knownnat ghc-typelits-natnormalise tasty
-         tasty-hunit
-       ];
-       description = "Additional type-level operations on GHC.TypeLits.Nat";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "ghc-typelits-extra_0_4_3" = callPackage
-    ({ mkDerivation, base, containers, ghc, ghc-prim
-     , ghc-tcplugins-extra, ghc-typelits-knownnat
-     , ghc-typelits-natnormalise, integer-gmp, tasty, tasty-hunit
-     , transformers
-     }:
-     mkDerivation {
-       pname = "ghc-typelits-extra";
        version = "0.4.3";
        sha256 = "06g40q0n2d10c2zksx5rrjkvm5ywi3rh41hbiwy4zs28x9idsv18";
        libraryHaskellDepends = [
···
        ];
        description = "Additional type-level operations on GHC.TypeLits.Nat";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-knownnat" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-typelits-knownnat";
-       version = "0.7.5";
-       sha256 = "1xraiil3nq02jdb4blkmsrdp36qhykv2xvwg3kaiyw5bgfl15gl3";
-       libraryHaskellDepends = [
-         base ghc ghc-prim ghc-tcplugins-extra ghc-typelits-natnormalise
-         template-haskell transformers
-       ];
-       testHaskellDepends = [
-         base ghc-typelits-natnormalise tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Derive KnownNat constraints from other KnownNat constraints";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "ghc-typelits-knownnat_0_7_6" = callPackage
-    ({ mkDerivation, base, ghc, ghc-prim, ghc-tcplugins-extra
-     , ghc-typelits-natnormalise, tasty, tasty-hunit, tasty-quickcheck
-     , template-haskell, transformers
-     }:
-     mkDerivation {
-       pname = "ghc-typelits-knownnat";
        version = "0.7.6";
        sha256 = "10m4y0hf25w2i40464pz85lqs5dr8cznl191icnibc5fjynyzd9v";
        libraryHaskellDepends = [
···
        ];
        description = "Derive KnownNat constraints from other KnownNat constraints";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-natnormalise" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-typelits-natnormalise";
-       version = "0.7.4";
-       sha256 = "0d8wwb1i6jj11cylf2n42r08hfygv9gwy89xyxp4kdclyw9mfwrp";
-       libraryHaskellDepends = [
-         base containers ghc ghc-tcplugins-extra integer-gmp transformers
-       ];
-       testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
-       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "ghc-typelits-natnormalise_0_7_6" = callPackage
-    ({ mkDerivation, base, containers, ghc, ghc-tcplugins-extra
-     , integer-gmp, tasty, tasty-hunit, template-haskell, transformers
-     }:
-     mkDerivation {
-       pname = "ghc-typelits-natnormalise";
        version = "0.7.6";
        sha256 = "09d70iw58m5g6yi8k2b52f1g0pfdqm5fzhs8rd7fgrgmi70np9bx";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base tasty tasty-hunit template-haskell ];
        description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-typelits-presburger" = callPackage
···
        pname = "ghcup";
        version = "0.1.14.2";
        sha256 = "1k18ira2i2ja4hd65fdxk3ab21xzh4fvd982q2rfjshzkds1a3hv";
+       revision = "1";
+       editedCabalFile = "1vy71ly44jibq8bil0ns80m2zn9gcpnz8f9w2mn4j404gajpqagk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
 
   "githash" = callPackage
     ({ mkDerivation, base, bytestring, directory, filepath, hspec
-     , process, template-haskell, temporary, unliftio
-     }:
-     mkDerivation {
-       pname = "githash";
-       version = "0.1.6.0";
-       sha256 = "1mcfzgvqiirlz8vc02wlvvfyf6742f3901ks8rphhabl4b4v1djl";
-       libraryHaskellDepends = [
-         base bytestring directory filepath process template-haskell
-       ];
-       testHaskellDepends = [
-         base bytestring directory filepath hspec process template-haskell
-         temporary unliftio
-       ];
-       description = "Compile git revision info into Haskell projects";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "githash_0_1_6_1" = callPackage
-    ({ mkDerivation, base, bytestring, directory, filepath, hspec
      , process, template-haskell, temporary, th-compat, unliftio
      }:
      mkDerivation {
···
        ];
        description = "Compile git revision info into Haskell projects";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "github" = callPackage
···
        pname = "glirc";
        version = "2.38";
        sha256 = "1azykkb9rc4q97v9xiqfjv0iys0wswa3nsy10smdkpp7yvv4mca7";
-       revision = "1";
-       editedCabalFile = "04f35w57jq6gpi6d3d83c9bswwl724rbd0dbl835ilhl18kpfscj";
+       revision = "2";
+       editedCabalFile = "082ndcgp9z1w5pa3s5ss7kqhg66y01lbj57k14zq6zs6c54s4b5i";
        isLibrary = true;
        isExecutable = true;
        setupHaskellDepends = [ base Cabal filepath ];
···
     ({ mkDerivation, aeson, base, conduit, containers, exceptions
      , hspec, hspec-expectations, hspec-megaparsec, megaparsec
      , parser-combinators, QuickCheck, raw-strings-qq, scientific, text
-     , transformers, unordered-containers
+     , transformers, unordered-containers, vector
      }:
      mkDerivation {
        pname = "graphql";
-       version = "0.11.1.0";
-       sha256 = "093gk2w2qrvarcv7xn0d0saa1j35cy0isw5vz04h08gy37s2nspc";
+       version = "1.0.0.0";
+       sha256 = "09r2a444l18pzy0952hkpl98vkmldi8j94hr6qf16xg5y9nic3nd";
        libraryHaskellDepends = [
          aeson base conduit containers exceptions hspec-expectations
          megaparsec parser-combinators scientific text transformers
-         unordered-containers
+         unordered-containers vector
        ];
        testHaskellDepends = [
-         aeson base conduit containers exceptions hspec hspec-expectations
-         hspec-megaparsec megaparsec parser-combinators QuickCheck
-         raw-strings-qq scientific text transformers unordered-containers
+         aeson base conduit exceptions hspec hspec-megaparsec megaparsec
+         QuickCheck raw-strings-qq scientific text unordered-containers
        ];
        description = "Haskell GraphQL implementation";
        license = "MPL-2.0 AND BSD-3-Clause";
···
        ];
        description = "Wrapper to integrate literate Agda files with Hakyll";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hakyll-alectryon" = callPackage
···
     ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
      , containers, directory, exceptions, extensible-exceptions
      , filepath, hslogger, html, HUnit, monad-control, mtl, network
-     , network-bsd, network-uri, old-locale, parsec, process, semigroups
-     , sendfile, syb, system-filepath, text, threads, time, transformers
-     , transformers-base, transformers-compat, unix, utf8-string, xhtml
-     , zlib
-     }:
-     mkDerivation {
-       pname = "happstack-server";
-       version = "7.7.1";
-       sha256 = "1zxdv7nihw3kjq2fvw5cl3s27pwm5gkli3sl15iqxfm7mdxz8rm0";
-       libraryHaskellDepends = [
-         base base64-bytestring blaze-html bytestring containers directory
-         exceptions extensible-exceptions filepath hslogger html
-         monad-control mtl network network-bsd network-uri old-locale parsec
-         process semigroups sendfile syb system-filepath text threads time
-         transformers transformers-base transformers-compat unix utf8-string
-         xhtml zlib
-       ];
-       testHaskellDepends = [
-         base bytestring containers HUnit parsec zlib
-       ];
-       description = "Web related tools and services";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "happstack-server_7_7_1_1" = callPackage
-    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
-     , containers, directory, exceptions, extensible-exceptions
-     , filepath, hslogger, html, HUnit, monad-control, mtl, network
      , network-uri, old-locale, parsec, process, semigroups, sendfile
      , syb, system-filepath, text, threads, time, transformers
      , transformers-base, transformers-compat, unix, utf8-string, xhtml
···
        ];
        description = "Web related tools and services";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "happstack-server-tls" = callPackage
···
        ];
        description = "Haskell driver for Neo4j 3+ (BOLT protocol)";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "hasbolt_0_1_6_1" = callPackage
+    ({ mkDerivation, base, base64-bytestring, binary, bytestring
+     , connection, containers, criterion, data-binary-ieee754
+     , data-default, deepseq, deepseq-generics, hspec, mtl, network
+     , QuickCheck, text
+     }:
+     mkDerivation {
+       pname = "hasbolt";
+       version = "0.1.6.1";
+       sha256 = "1skniw27z4p3103anh2jc546h0jkvsacsnwnf32zz7a4paw6z280";
+       libraryHaskellDepends = [
+         base binary bytestring connection containers data-binary-ieee754
+         data-default deepseq deepseq-generics mtl network text
+       ];
+       testHaskellDepends = [
+         base binary bytestring containers hspec QuickCheck text
+       ];
+       benchmarkHaskellDepends = [
+         base base64-bytestring binary bytestring criterion data-default
+         hspec
+       ];
+       description = "Haskell driver for Neo4j 3+ (BOLT protocol)";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hasbolt-extras" = callPackage
···
        ];
        description = "A PostgreSQL backed queue";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hasql-simple" = callPackage
···
      }:
      mkDerivation {
        pname = "hasql-th";
-       version = "0.4.0.8";
-       sha256 = "14h71s7dha1g0zfi3vsg5y6lsn09x8c9nqv1nqiqmw2m19adx7gi";
+       version = "0.4.0.9";
+       sha256 = "0z3falhkyyqpzqh116xwzvjj0xb391bwahh64sasnw4vf2i0drb9";
        libraryHaskellDepends = [
          base bytestring containers contravariant foldl hasql
          postgresql-syntax template-haskell template-haskell-compat-v0208
···
      }:
      mkDerivation {
        pname = "hasql-transaction";
-       version = "1.0.0.2";
-       sha256 = "1ig6fny9c90cmfsh6kcdhj9ps2arn1y80ic2w7ps6mn8wgl0cr82";
+       version = "1.0.1";
+       sha256 = "1a83x2jrv9bhjrxfgvqfwrqv5cx1f401rmvz0k44yww5p816jk9s";
        libraryHaskellDepends = [
          base bytestring bytestring-tree-builder contravariant
          contravariant-extras hasql mtl transformers
···
      }:
      mkDerivation {
        pname = "headed-megaparsec";
-       version = "0.2";
-       sha256 = "1s2alhwmkk5czilm1m2dp72xpbdjhn7yhghrs1aca2js71x5j7qj";
+       version = "0.2.0.1";
+       sha256 = "1bkjk5bzlzsigqdcb3vyqmjxddf4hm7b5a4ppb0iwh5n78whxpjc";
        libraryHaskellDepends = [
          base case-insensitive megaparsec parser-combinators selective
        ];
···
      }) {};
 
   "headroom" = callPackage
-    ({ mkDerivation, aeson, base, doctest, either, file-embed
-     , generic-data, hspec, hspec-discover, microlens, microlens-th, mtl
-     , mustache, optparse-applicative, pcre-heavy, pcre-light
-     , QuickCheck, rio, string-interpolate, template-haskell, time, yaml
-     }:
-     mkDerivation {
-       pname = "headroom";
-       version = "0.4.1.0";
-       sha256 = "1f98x1qm567wsa58nyavj7lfi2fmm6zrmjc0cwg0dyhvi63n9qp0";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson base either file-embed generic-data microlens microlens-th
-         mtl mustache optparse-applicative pcre-heavy pcre-light rio
-         string-interpolate template-haskell time yaml
-       ];
-       executableHaskellDepends = [ base optparse-applicative rio ];
-       testHaskellDepends = [
-         aeson base doctest hspec mtl optparse-applicative pcre-light
-         QuickCheck rio string-interpolate time
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "License Header Manager";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "headroom_0_4_2_0" = callPackage
     ({ mkDerivation, aeson, base, doctest, either, extra, file-embed
      , generic-data, hspec, hspec-discover, http-client, http-types
      , microlens, microlens-th, modern-uri, mtl, mustache
···
        testToolDepends = [ hspec-discover ];
        description = "License Header Manager";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "heap" = callPackage
···
      }:
      mkDerivation {
        pname = "hedn";
-       version = "0.3.0.2";
-       sha256 = "1w9p9h06rgz80153b2q59bblpn124nicn1sscyyjc1cfwda2h0b4";
-       libraryHaskellDepends = [
-         base containers deepseq deriving-compat megaparsec
-         parser-combinators prettyprinter scientific template-haskell text
-         time uuid-types vector
-       ];
-       testHaskellDepends = [
-         base containers hedgehog megaparsec text time uuid-types vector
-       ];
-       description = "EDN parsing and encoding";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hedn_0_3_0_3" = callPackage
-    ({ mkDerivation, base, containers, deepseq, deriving-compat
-     , hedgehog, megaparsec, parser-combinators, prettyprinter
-     , scientific, template-haskell, text, time, uuid-types, vector
-     }:
-     mkDerivation {
-       pname = "hedn";
        version = "0.3.0.3";
        sha256 = "0amfsmnly9yxzv1j34ya8kq9fqd067kgklx7rswy5g7aflj3bpwl";
        libraryHaskellDepends = [
···
        ];
        description = "EDN parsing and encoding";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hedn-functor" = callPackage
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
+  "hledger_1_22" = callPackage
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+     , directory, extra, filepath, githash, hashable, haskeline
+     , hledger-lib, lucid, math-functions, megaparsec, mtl, old-time
+     , process, regex-tdfa, safe, shakespeare, split, tabular, tasty
+     , temporary, terminfo, text, time, timeit, transformers
+     , unordered-containers, utf8-string, utility-ht, wizards
+     }:
+     mkDerivation {
+       pname = "javascript-bridge";
+       version = "1.22";
+       sha256 = "1w7akdl9pn77s3fnb5wq3f7k2xpxnf91ann8qy5gpq66nszm6pqc";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+         githash hashable haskeline hledger-lib lucid math-functions
+         megaparsec mtl old-time process regex-tdfa safe shakespeare split
+         tabular tasty temporary terminfo text time timeit transformers
+       pname = "javascript-bridge";
+       ];
+       executableHaskellDepends = [
+       pname = "javascript-bridge";
+         containers data-default Decimal directory extra filepath githash
+         haskeline hledger-lib math-functions megaparsec mtl old-time
+         process regex-tdfa safe shakespeare split tabular tasty temporary
+         terminfo text time timeit transformers unordered-containers
+         utf8-string utility-ht wizards
+       ];
+       testHaskellDepends = [
+       pname = "javascript-bridge";
+         containers data-default Decimal directory extra filepath githash
+         haskeline hledger-lib math-functions megaparsec mtl old-time
+         process regex-tdfa safe shakespeare split tabular tasty temporary
+         terminfo text time timeit transformers unordered-containers
+         utf8-string utility-ht wizards
+       ];
+       pname = "javascript-bridge";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
        pname = "javascript-bridge";
     ({ mkDerivation, aeson, base, bytestring, containers, data-default
        pname = "javascript-bridge";
···
        license = lib.licenses.gpl3Only;
      }) {};
 
+  "hledger-lib_1_22" = callPackage
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+     , unordered-containers, utf8-string
+     }:
+     mkDerivation {
+       pname = "javascript-bridge";
+       version = "1.22";
+       sha256 = "06qddk2nhjq3g02in3hcxz4hfwq9fcb3356shzbljx7ssmzjakzm";
+       libraryHaskellDepends = [
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+         unordered-containers utf8-string
+       ];
+       testHaskellDepends = [
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+         unordered-containers utf8-string
+       ];
+       pname = "javascript-bridge";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
        pname = "javascript-bridge";
        pname = "javascript-bridge";
        pname = "javascript-bridge";
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
+  "hledger-ui_1_22" = callPackage
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+     }:
+     mkDerivation {
+       pname = "javascript-bridge";
+       version = "1.22";
+       sha256 = "1izidpxwygghq0c3z7pygf9c9qlsydw89gs6475hsd4qiqc06gjr";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       ];
+       pname = "javascript-bridge";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
        pname = "javascript-bridge";
        pname = "javascript-bridge";
        pname = "javascript-bridge";
···
        ];
        pname = "javascript-bridge";
        license = lib.licenses.gpl3Only;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
+  "hledger-web_1_22" = callPackage
+    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+     }:
+     mkDerivation {
+       pname = "javascript-bridge";
+       version = "1.22";
+       sha256 = "0miy111zz8yqw0i87sn91aiplznc7fbirznpar8y5mch8z4wn4bs";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       pname = "javascript-bridge";
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+       pname = "javascript-bridge";
+       ];
+       pname = "javascript-bridge";
+       license = lib.licenses.gpl3Only;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) ruby;};
 
+  "hs" = callPackage
+    ({ mkDerivation, base, containers, data-default, directory
+     , enum-text, filepath, fmt, optparse-applicative, possibly, text
+     , typed-process
+     }:
+     mkDerivation {
+       pname = "hs";
+       version = "0.1.0.2";
+       sha256 = "03hfjw777v2dkj1qcswb9ylqypiqhx5xcsnmksq99si3bi1xyrgm";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base containers data-default directory enum-text filepath fmt
+         optparse-applicative possibly text typed-process
+       ];
+       executableHaskellDepends = [
+         base containers data-default directory enum-text filepath fmt
+         optparse-applicative possibly text typed-process
+       ];
+       description = "GHC-toolchain installer broker";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "hs-GeoIP" = callPackage
     ({ mkDerivation, base, bytestring, deepseq, GeoIP }:
      mkDerivation {
···
        ];
        description = "Akamai API(Edgegrid and Netstorage)";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hsaml2" = callPackage
···
      }:
      mkDerivation {
        pname = "http-streams";
-       version = "0.8.7.2";
-       sha256 = "1q0lp8hkzfc0srci9y794q5cqkih50r3iw2c32wbx8h502jcvv1q";
+       version = "0.8.8.1";
+       sha256 = "0jh7ps2hi72pjzrjwkmq8sq0djwjv9nf9cbxhjb121grg0gzzrbh";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-builder bytestring
          case-insensitive directory HsOpenSSL http-common io-streams mtl
···
        benchmarkHaskellDepends = [ base criterion vector ];
        description = "Primitive support for bit manipulation";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hw-rankselect" = callPackage
···
      }) {};
 
   "hyphenation" = callPackage
-    ({ mkDerivation, base, bytestring, containers, text
-     , unordered-containers, zlib
-     }:
-     mkDerivation {
-       pname = "hyphenation";
-       version = "0.8.1";
-       sha256 = "0pzm9sfn1bw7yvwhby9a6d9z2ghcn91rcbj08x380gff31kn8lbx";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bytestring containers text unordered-containers zlib
-       ];
-       description = "Configurable Knuth-Liang hyphenation";
-       license = lib.licenses.bsd2;
-     }) {};
-
-  "hyphenation_0_8_2" = callPackage
     ({ mkDerivation, base, bytestring, containers, file-embed, text
      , unordered-containers, zlib
      }:
···
        ];
        description = "Configurable Knuth-Liang hyphenation";
        license = lib.licenses.bsd2;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hypher" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "ihaskell_0_10_2_1" = callPackage
+    ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal
+     , cmdargs, containers, directory, exceptions, filepath, ghc
+     , ghc-boot, ghc-parser, ghc-paths, haskeline, here, hlint, hspec
+     , hspec-contrib, http-client, http-client-tls, HUnit
+     , ipython-kernel, mtl, parsec, process, random, raw-strings-qq
+     , setenv, shelly, split, stm, strict, text, time, transformers
+     , unix, unordered-containers, utf8-string, vector
+     }:
+     mkDerivation {
+       pname = "ihaskell";
+       version = "0.10.2.1";
+       sha256 = "1bpxm51c8f0cl7cvg7d2f39fnar7a811s3fgxvxmvsb7yw3v92vc";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base base64-bytestring bytestring cereal cmdargs containers
+         directory exceptions filepath ghc ghc-boot ghc-parser ghc-paths
+         haskeline hlint http-client http-client-tls ipython-kernel mtl
+         parsec process random shelly split stm strict text time
+         transformers unix unordered-containers utf8-string vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers directory ghc ipython-kernel
+         process strict text transformers unix unordered-containers
+       ];
+       testHaskellDepends = [
+         base directory ghc ghc-paths here hspec hspec-contrib HUnit
+         raw-strings-qq setenv shelly text transformers
+       ];
+       description = "A Haskell backend kernel for the IPython project";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ihaskell-aeson" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, here
      , ihaskell, text
···
      }:
      mkDerivation {
        pname = "inline-c";
-       version = "0.9.1.4";
-       sha256 = "021r3ghn3cv1nykkkgyd50gq5cmczam8j37xqfi7vmyx5iwdv0a2";
+       version = "0.9.1.5";
+       sha256 = "0a0m3bhh910c5g46cwkxgflsgw5ab7lzymwll9hijyvwgnsw3h7i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, binary, bytestring, iproute }:
      mkDerivation {
        pname = "ip2proxy";
-       version = "3.0.0";
-       sha256 = "1hi1q0kiqqp96w29y9699s66rmyr7k0fp6s7z86ll9n3bmf0a4g4";
+       version = "3.1.0";
+       sha256 = "03naiwlxzfmym6ms03z0a9ap2x9f40aqlssyjbb37krhlmmnf0l8";
        libraryHaskellDepends = [ base binary bytestring iproute ];
        description = "IP2Proxy Haskell package for proxy detection";
        license = lib.licenses.mit;
···
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) SDL_mixer;};
 
+  "keid-core" = callPackage
+    ({ mkDerivation, adjunctions, base, binary, bytestring
+     , cryptohash-md5, derive-storable, derive-storable-plugin
+     , distributive, foldl, geomancy, GLFW-b, ktx-codec
+     , neat-interpolation, optparse-applicative, optparse-simple
+     , resourcet, rio, rio-app, StateVar, tagged, template-haskell, text
+     , transformers, unagi-chan, unliftio, vector, vulkan, vulkan-utils
+     , VulkanMemoryAllocator, zstd
+     }:
+     mkDerivation {
+       pname = "keid-core";
+       version = "0.1.0.0";
+       sha256 = "05h4dp27sp23ihmr8hvflqr1bqyf590s607sxl9vc1k46k9hc179";
+       libraryHaskellDepends = [
+         adjunctions base binary bytestring cryptohash-md5 derive-storable
+         derive-storable-plugin distributive foldl geomancy GLFW-b ktx-codec
+         neat-interpolation optparse-applicative optparse-simple resourcet
+         rio rio-app StateVar tagged template-haskell text transformers
+         unagi-chan unliftio vector vulkan vulkan-utils
+         VulkanMemoryAllocator zstd
+       ];
+       description = "Core parts of Keid engine";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "keid-geometry" = callPackage
+    ({ mkDerivation, base, geomancy, keid-core, rio, rio-app, vulkan }:
+     mkDerivation {
+       pname = "keid-geometry";
+       version = "0.1.0.0";
+       sha256 = "1bhmxgbza1l9qr25g8ad31j70z1dmvsa5gd05fgpwha9liixahsc";
+       libraryHaskellDepends = [
+         base geomancy keid-core rio rio-app vulkan
+       ];
+       description = "Geometry primitives for Keid engine";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "keid-render-basic" = callPackage
+    ({ mkDerivation, aeson, base, binary, bytestring, cryptohash-md5
+     , derive-storable, derive-storable-plugin, foldl, geomancy, GLFW-b
+     , keid-core, neat-interpolation, resourcet, rio, rio-app, tagged
+     , text, unliftio, vector, vulkan, vulkan-utils
+     , VulkanMemoryAllocator, zstd
+     }:
+     mkDerivation {
+       pname = "keid-render-basic";
+       version = "0.1.0.0";
+       sha256 = "1rjvf5bxh3llfq1pd9hwy8laida9rhw4f49ca5hn69cnpchpngmy";
+       libraryHaskellDepends = [
+         aeson base binary bytestring cryptohash-md5 derive-storable
+         derive-storable-plugin foldl geomancy GLFW-b keid-core
+         neat-interpolation resourcet rio rio-app tagged text unliftio
+         vector vulkan vulkan-utils VulkanMemoryAllocator zstd
+       ];
+       description = "Basic rendering programs for Keid engine";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "keid-resource-gltf" = callPackage
+    ({ mkDerivation, base, bytestring, containers, derive-storable
+     , derive-storable-plugin, geomancy, gltf-codec, keid-core, rio
+     , rio-app, vulkan
+     }:
+     mkDerivation {
+       pname = "keid-resource-gltf";
+       version = "0.1.0.0";
+       sha256 = "1b5dbrlhb44xmgsv4l5mfwficlkjy3k36b01sha0j6yq1bv6mvhj";
+       libraryHaskellDepends = [
+         base bytestring containers derive-storable derive-storable-plugin
+         geomancy gltf-codec keid-core rio rio-app vulkan
+       ];
+       description = "GLTF loader for Keid engine";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "keid-ui-dearimgui" = callPackage
+    ({ mkDerivation, base, binary, bytestring, cryptohash-md5
+     , dear-imgui, derive-storable, derive-storable-plugin, foldl
+     , geomancy, GLFW-b, keid-core, neat-interpolation, resourcet, rio
+     , rio-app, tagged, unliftio, vector, vulkan, vulkan-utils
+     , VulkanMemoryAllocator, zstd
+     }:
+     mkDerivation {
+       pname = "keid-ui-dearimgui";
+       version = "0.1.0.0";
+       sha256 = "1650h7mbzmkpzs2wjvjh3zwmjkvbcg1h36yk6frlvvf80fhhihjc";
+       libraryHaskellDepends = [
+         base binary bytestring cryptohash-md5 dear-imgui derive-storable
+         derive-storable-plugin foldl geomancy GLFW-b keid-core
+         neat-interpolation resourcet rio rio-app tagged unliftio vector
+         vulkan vulkan-utils VulkanMemoryAllocator zstd
+       ];
+       description = "DearImGui elements for Keid engine";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "keiretsu" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, async, base, bytestring
      , conduit, conduit-extra, directory, filepath, hslogger, network
···
        pname = "large-hashable";
        version = "0.1.0.4";
        sha256 = "13k2k8rqbk40whzn4hpa92ypws2c1gh5fb4zh0diy5m0kxfk9hz9";
+       revision = "1";
+       editedCabalFile = "1xfl265ryvrjra2nsjvlcmwgilbnxhp8pwxy54wi1ada645nwgbr";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytes bytestring containers scientific
          strict template-haskell text time transformers unordered-containers
···
      }) {inherit (pkgs) leveldb;};
 
   "levenshtein" = callPackage
-    ({ mkDerivation, base, binary, deepseq, hashable, hspec
-     , hspec-discover, QuickCheck
+    ({ mkDerivation, base, binary, data-default, deepseq, hashable
+     , hspec, hspec-discover, QuickCheck
      }:
      mkDerivation {
        pname = "levenshtein";
-       version = "0.1.1.0";
-       sha256 = "1a4pz175skaw8s02pa6l2jm7m21sfghivzpd2vm2p08lmmwykx5p";
+       version = "0.1.3.0";
+       sha256 = "1h9xygy65npn2a5pgngqzm39k9ms3krzn1in9h0adln6aq2kcgdx";
        libraryHaskellDepends = [
-         base binary deepseq hashable QuickCheck
+         base binary data-default deepseq hashable QuickCheck
        ];
        testHaskellDepends = [ base hspec QuickCheck ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "linear";
-       version = "1.21.5";
-       sha256 = "19pvz467wd8gss95qfi90xnd5fwm6dpdppr21g5n30x4m7niymn3";
+       version = "1.21.6";
+       sha256 = "0ax6prmc7b53w0lz5ddc40wrjj9bm7wldpp57283gx9hdf8qrb35";
        libraryHaskellDepends = [
          adjunctions base base-orphans binary bytes cereal containers
          deepseq distributive ghc-prim hashable indexed-traversable lens
···
     ({ mkDerivation, ansi-terminal, array, ascii-progress, async
      , attoparsec, base, binary, boxes, cereal, cmdargs, containers
      , deepseq, directory, fgl, filepath, git, hashable, intern, mtl
-     , nettools, ocaml, parallel, parsec, pretty, process, stm, syb
-     , tasty, tasty-ant-xml, tasty-hunit, tasty-rerun, text, text-format
+     , nettools, parallel, parsec, pretty, process, stm, syb, tasty
+     , tasty-ant-xml, tasty-hunit, tasty-rerun, text, text-format
      , transformers, unordered-containers, z3
      }:
      mkDerivation {
···
          text-format transformers unordered-containers
        ];
        executableHaskellDepends = [ base ];
-       executableSystemDepends = [ ocaml ];
        testHaskellDepends = [
          base containers directory filepath mtl process stm tasty
          tasty-ant-xml tasty-hunit tasty-rerun transformers
···
        description = "Predicate Abstraction-based Horn-Clause/Implication Constraint Solver";
        license = lib.licenses.bsd3;
      }) {inherit (pkgs) git; inherit (pkgs) nettools; 
-         inherit (pkgs) ocaml; inherit (pkgs) z3;};
+         inherit (pkgs) z3;};
 
   "liquid-ghc-prim" = callPackage
     ({ mkDerivation, base, Cabal, ghc-prim, liquidhaskell }:
···
        ];
        description = "GraphQL support for Mu";
        license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "mu-grpc-client" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "net-mqtt_0_8_0_0" = callPackage
+  "net-mqtt_0_8_0_2" = callPackage
     ({ mkDerivation, async, attoparsec, attoparsec-binary, base, binary
      , bytestring, checkers, conduit, conduit-extra, connection
      , containers, deepseq, HUnit, network-conduit-tls, network-uri
···
      }:
      mkDerivation {
        pname = "net-mqtt";
-       version = "0.8.0.0";
-       sha256 = "1635kk5619syjj80ynpnd61qdiaxm349qyzhbaa8nc8nm8kkw2gh";
+       version = "0.8.0.2";
+       sha256 = "0rvsyb9msp1dkba941094d07apdinlda0hg4pb32jxs17wwnj0a7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "net-mqtt-lens";
-       version = "0.1.0.0";
-       sha256 = "1g0vvay4fdvr2n0hxi4w4av39wd70jgi3yixfx98xxydilw1v110";
-       libraryHaskellDepends = [ base lens net-mqtt ];
-       testHaskellDepends = [
-         base HUnit lens net-mqtt tasty tasty-hunit tasty-quickcheck
-       ];
-       description = "Optics for net-mqtt";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "net-mqtt-lens_0_1_1_0" = callPackage
-    ({ mkDerivation, base, HUnit, lens, net-mqtt, tasty, tasty-hunit
-     , tasty-quickcheck
-     }:
-     mkDerivation {
-       pname = "net-mqtt-lens";
        version = "0.1.1.0";
        sha256 = "0rlib45yqlcij12pij8y690n3ajma35fyj8292b1vggk07dscycq";
        libraryHaskellDepends = [ base lens net-mqtt ];
···
        ];
        description = "Optics for net-mqtt";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "net-mqtt-rpc" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "nri-observability" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
-     , bytestring, directory, hostname, http-client, http-client-tls
-     , nri-env-parser, nri-prelude, random, safe-exceptions, stm, text
-     , time, unordered-containers
+  "nri-kafka" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, conduit
+     , containers, hw-kafka-client, nri-env-parser, nri-observability
+     , nri-prelude, safe-exceptions, stm, text, time, unix, uuid
      }:
      mkDerivation {
-       pname = "nri-observability";
-       version = "0.1.0.3";
-       sha256 = "0njpgc873rh09hkg7pnagkmmrd8nibdq4q1p44wa3n71xzwzy771";
+       pname = "nri-kafka";
+       version = "0.1.0.0";
+       sha256 = "0ifdmli7arrlpmh1l4q974rv0bw3xirfk96xrahfab3zp36r4x3y";
        libraryHaskellDepends = [
-         aeson aeson-pretty async base bugsnag-hs bytestring directory
-         hostname http-client http-client-tls nri-env-parser nri-prelude
-         random safe-exceptions stm text time unordered-containers
+         aeson async base bytestring conduit containers hw-kafka-client
+         nri-env-parser nri-observability nri-prelude safe-exceptions stm
+         text time unix uuid
        ];
        testHaskellDepends = [
-         aeson aeson-pretty async base bugsnag-hs bytestring directory
-         hostname http-client http-client-tls nri-env-parser nri-prelude
-         random safe-exceptions stm text time unordered-containers
+         aeson async base bytestring conduit containers hw-kafka-client
+         nri-env-parser nri-observability nri-prelude safe-exceptions stm
+         text time unix uuid
        ];
-       description = "Report log spans collected by nri-prelude";
+       description = "Functions for working with Kafka";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
-  "nri-observability_0_1_1_1" = callPackage
+  "nri-observability" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, async, base, bugsnag-hs
      , bytestring, conduit, directory, hostname, http-client
      , http-client-tls, nri-env-parser, nri-prelude, random
···
        ];
        description = "Report log spans collected by nri-prelude";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "nri-postgresql" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, bytestring, filepath
+     , network, nri-env-parser, nri-observability, nri-prelude
+     , postgresql-typed, resource-pool, resourcet, safe-exceptions
+     , template-haskell, text, time
+     }:
+     mkDerivation {
+       pname = "nri-postgresql";
+       version = "0.1.0.1";
+       sha256 = "1kl5wriqdshhc2fjaicj60hrwrw2c6y8vrq2pv4fagn0gxa78fvc";
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring filepath network nri-env-parser
+         nri-observability nri-prelude postgresql-typed resource-pool
+         resourcet safe-exceptions template-haskell text time
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base bytestring filepath network nri-env-parser
+         nri-observability nri-prelude postgresql-typed resource-pool
+         resourcet safe-exceptions template-haskell text time
+       ];
+       description = "Make queries against Postgresql";
+       license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "nri-prelude" = callPackage
···
        broken = true;
      }) {};
 
-  "opaleye" = callPackage
+  "opaleye_0_7_2_0" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, bytestring
      , case-insensitive, containers, contravariant, dotenv, hspec
      , hspec-discover, multiset, postgresql-simple, pretty
···
      }:
      mkDerivation {
        pname = "opaleye";
-       version = "0.7.1.0";
-       sha256 = "0i4ndy9dd6jb4dzx8a5fv8jsmnmp7p1kx2qr012xj1qjq36sqpy6";
-       revision = "3";
-       editedCabalFile = "14y8nnng9307wb1mafzdr2fmn37cwyfpw9sby8lf9sj467rvghrq";
+       version = "0.7.2.0";
+       sha256 = "1qz34isgb5hl2ab5vij3zw1h3xwvl3a0d1k02n156xszibnkcgf1";
        libraryHaskellDepends = [
          aeson base base16-bytestring bytestring case-insensitive
          contravariant postgresql-simple pretty product-profunctors
···
        testToolDepends = [ hspec-discover ];
        description = "An SQL-generating DSL targeting PostgreSQL";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "opaleye_0_7_3_0" = callPackage
+  "opaleye" = callPackage
     ({ mkDerivation, aeson, base, base16-bytestring, bytestring
      , case-insensitive, containers, contravariant, dotenv, hspec
      , hspec-discover, multiset, postgresql-simple, pretty
···
        testToolDepends = [ hspec-discover ];
        description = "An SQL-generating DSL targeting PostgreSQL";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "opaleye-classy" = callPackage
···
        pname = "optparse-generic";
        version = "1.4.4";
        sha256 = "0xy0kc8qximsiqpnc1fmh5zlsh6n26s7scrixin5bwnylg056j74";
-       revision = "1";
-       editedCabalFile = "14vbfbl2va3s2pa4qjyyny1i15s2iw9993ld5b0qsqdv1z6nfjz1";
+       revision = "2";
+       editedCabalFile = "172x8990wx4jhyb7yp9k18nd6q4sis8km09x2afr238siqviclrc";
        libraryHaskellDepends = [
          base bytestring Only optparse-applicative system-filepath text time
          transformers void
···
 
   "optparse-simple" = callPackage
     ({ mkDerivation, base, bytestring, directory, githash
-     , optparse-applicative, template-haskell, transformers
-     }:
-     mkDerivation {
-       pname = "optparse-simple";
-       version = "0.1.1.3";
-       sha256 = "1wymqhac2sngkka8w880gq6y1kk3xs0flbv4mrhfgzrplhax8r9k";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base githash optparse-applicative template-haskell transformers
-       ];
-       testHaskellDepends = [ base bytestring directory ];
-       description = "Simple interface to optparse-applicative";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "optparse-simple_0_1_1_4" = callPackage
-    ({ mkDerivation, base, bytestring, directory, githash
      , optparse-applicative, template-haskell, th-compat, transformers
      }:
      mkDerivation {
···
        testHaskellDepends = [ base bytestring directory ];
        description = "Simple interface to optparse-applicative";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "optparse-text" = callPackage
···
      }:
      mkDerivation {
        pname = "pandoc";
-       version = "2.14.0.2";
-       sha256 = "1jnckx29l6plg1zbkjdfj530djjl8zszwr54zsg0k0is4pcswa9f";
-       configureFlags = [ "-fhttps" "-f-trypandoc" ];
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson aeson-pretty array attoparsec base base64-bytestring binary
-         blaze-html blaze-markup bytestring case-insensitive citeproc
-         commonmark commonmark-extensions commonmark-pandoc connection
-         containers data-default deepseq directory doclayout doctemplates
-         emojis exceptions file-embed filepath Glob 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
-         random safe scientific SHA skylighting skylighting-core split syb
-         tagsoup temporary texmath text text-conversions time
-         unicode-collation unicode-transforms unix unordered-containers xml
-         xml-conduit zip-archive zlib
-       ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [
-         base bytestring containers Diff directory doctemplates exceptions
-         filepath Glob hslua mtl pandoc-types process QuickCheck tasty
-         tasty-golden tasty-hunit tasty-lua tasty-quickcheck text time xml
-         zip-archive
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring containers deepseq mtl tasty-bench text time
-       ];
-       postInstall = ''
-         mkdir -p $out/share/man/man1
-         mv "man/"*.1 $out/share/man/man1/
-       '';
-       description = "Conversion between markup formats";
-       license = lib.licenses.gpl2Plus;
-       maintainers = with lib.maintainers; [ peti ];
-     }) {};
-
-  "pandoc_2_14_0_3" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
-     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
-     , case-insensitive, citeproc, commonmark, commonmark-extensions
-     , commonmark-pandoc, connection, containers, data-default, deepseq
-     , Diff, directory, doclayout, doctemplates, emojis, exceptions
-     , file-embed, filepath, Glob, 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
-     }:
-     mkDerivation {
-       pname = "pandoc";
        version = "2.14.0.3";
        sha256 = "1pgd6125mrvzj2faxbsfmackb7kchzcr6bjkrwqbyn9hzxdzbqw2";
        configureFlags = [ "-fhttps" "-f-trypandoc" ];
···
        '';
        description = "Conversion between markup formats";
        license = lib.licenses.gpl2Plus;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "pantry";
-       version = "0.5.2.2";
-       sha256 = "05ykb6jn19jiakrn6mdcz3gyc6v6hkg3r8drwxncf04syz0l60mm";
-       libraryHaskellDepends = [
-         aeson ansi-terminal base bytestring Cabal casa-client casa-types
-         conduit conduit-extra containers cryptonite cryptonite-conduit
-         digest filelock generic-deriving hackage-security hpack http-client
-         http-client-tls http-conduit http-download http-types memory mtl
-         network-uri path path-io persistent persistent-sqlite
-         persistent-template primitive resourcet rio rio-orphans
-         rio-prettyprint tar-conduit text text-metrics time transformers
-         unix-compat unliftio unordered-containers vector yaml zip-archive
-       ];
-       testHaskellDepends = [
-         aeson ansi-terminal base bytestring Cabal casa-client casa-types
-         conduit conduit-extra containers cryptonite cryptonite-conduit
-         digest exceptions filelock generic-deriving hackage-security
-         hedgehog hpack hspec http-client http-client-tls http-conduit
-         http-download http-types memory mtl network-uri path path-io
-         persistent persistent-sqlite persistent-template primitive
-         QuickCheck raw-strings-qq resourcet rio rio-orphans rio-prettyprint
-         tar-conduit text text-metrics time transformers unix-compat
-         unliftio unordered-containers vector yaml zip-archive
-       ];
-       description = "Content addressable Haskell package management";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "pantry_0_5_2_3" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
-     , casa-client, casa-types, conduit, conduit-extra, containers
-     , cryptonite, cryptonite-conduit, digest, exceptions, filelock
-     , generic-deriving, hackage-security, hedgehog, hpack, hspec
-     , http-client, http-client-tls, http-conduit, http-download
-     , http-types, memory, mtl, network-uri, path, path-io, persistent
-     , persistent-sqlite, persistent-template, primitive, QuickCheck
-     , raw-strings-qq, resourcet, rio, rio-orphans, rio-prettyprint
-     , tar-conduit, text, text-metrics, time, transformers, unix-compat
-     , unliftio, unordered-containers, vector, yaml, zip-archive
-     }:
-     mkDerivation {
-       pname = "pantry";
        version = "0.5.2.3";
        sha256 = "17r9fgs83dp0s9wq14q5hvf5vnl8d7cg9p9dnbixgsysq6g6d29g";
        libraryHaskellDepends = [
···
        ];
        description = "Content addressable Haskell package management";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "pantry-tmp" = callPackage
···
      }:
      mkDerivation {
        pname = "parsley-core";
-       version = "1.2.0.0";
-       sha256 = "0q3kj5ima8i06rmm5659jhhzfm6shgb3k4sbf34dq1jbwgqrkja1";
+       version = "1.3.0.0";
+       sha256 = "0qx5q7a9hkj9swpwlxh24c19pf9i6yvlmp44xiwshflz4cf1n8dq";
        libraryHaskellDepends = [
          array base bytestring containers dependent-map dependent-sum
          ghc-prim hashable mtl pretty-terminal template-haskell text
···
      }) {};
 
   "persistent" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
-     , blaze-html, bytestring, conduit, containers, criterion, deepseq
-     , fast-logger, file-embed, hspec, http-api-data, lift-type
-     , monad-logger, mtl, path-pieces, QuickCheck, quickcheck-instances
-     , resource-pool, resourcet, scientific, shakespeare, silently
-     , template-haskell, text, th-lift-instances, time, transformers
-     , unliftio, unliftio-core, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "persistent";
-       version = "2.13.0.2";
-       sha256 = "1fn3hjn3pxxnawvdif691vmxahnmal5ivr5rll0f26ia7rjqrnn2";
-       libraryHaskellDepends = [
-         aeson attoparsec base base64-bytestring blaze-html bytestring
-         conduit containers fast-logger http-api-data lift-type monad-logger
-         mtl path-pieces resource-pool resourcet scientific silently
-         template-haskell text th-lift-instances time transformers unliftio
-         unliftio-core unordered-containers vector
-       ];
-       testHaskellDepends = [
-         aeson attoparsec base base64-bytestring blaze-html bytestring
-         conduit containers fast-logger hspec http-api-data monad-logger mtl
-         path-pieces QuickCheck quickcheck-instances resource-pool resourcet
-         scientific shakespeare silently template-haskell text
-         th-lift-instances time transformers unliftio unliftio-core
-         unordered-containers vector
-       ];
-       benchmarkHaskellDepends = [
-         base criterion deepseq file-embed template-haskell text
-       ];
-       description = "Type-safe, multi-backend data serialization";
-       license = lib.licenses.mit;
-       maintainers = with lib.maintainers; [ psibi ];
-     }) {};
-
-  "persistent_2_13_1_1" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , blaze-html, bytestring, conduit, containers, criterion, deepseq
      , fast-logger, file-embed, hspec, http-api-data, lift-type
···
        ];
        description = "Type-safe, multi-backend data serialization";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "persistent-postgresql";
-       version = "2.13.0.2";
-       sha256 = "1cbrwzk2s3xrdxpas64slk1habn38xspdg09xj2yazszkmr31hrh";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson attoparsec base blaze-builder bytestring conduit containers
-         monad-logger mtl persistent postgresql-libpq postgresql-simple
-         resource-pool resourcet string-conversions text time transformers
-         unliftio-core
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers fast-logger hspec
-         hspec-expectations hspec-expectations-lifted http-api-data HUnit
-         monad-logger path-pieces persistent persistent-qq persistent-test
-         QuickCheck quickcheck-instances resourcet text time transformers
-         unliftio unliftio-core unordered-containers vector
-       ];
-       description = "Backend for the persistent library using postgresql";
-       license = lib.licenses.mit;
-     }) {};
-
-  "persistent-postgresql_2_13_0_3" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
-     , conduit, containers, fast-logger, hspec, hspec-expectations
-     , hspec-expectations-lifted, http-api-data, HUnit, monad-logger
-     , mtl, path-pieces, persistent, persistent-qq, persistent-test
-     , postgresql-libpq, postgresql-simple, QuickCheck
-     , quickcheck-instances, resource-pool, resourcet
-     , string-conversions, text, time, transformers, unliftio
-     , unliftio-core, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "persistent-postgresql";
        version = "2.13.0.3";
        sha256 = "06f5yyv8bj3m4zpjwr1k66hkmh1gfy624rnq2g12sjrpz8nrax6j";
        isLibrary = true;
···
        ];
        description = "Backend for the persistent library using postgresql";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "persistent-protobuf" = callPackage
···
      }) {};
 
   "pg-transact" = callPackage
-    ({ mkDerivation, async, base, bytestring, exceptions, hspec
-     , hspec-expectations-lifted, monad-control, postgresql-libpq
-     , postgresql-simple, tmp-postgres, transformers
-     }:
-     mkDerivation {
-       pname = "pg-transact";
-       version = "0.3.1.1";
-       sha256 = "1z101hbfan8aidq7lcnzzni4b7ji8sbbqx1yar6ykf6wmzmn2pcd";
-       libraryHaskellDepends = [
-         base bytestring exceptions monad-control postgresql-simple
-         transformers
-       ];
-       testHaskellDepends = [
-         async base bytestring exceptions hspec hspec-expectations-lifted
-         postgresql-libpq postgresql-simple tmp-postgres
-       ];
-       description = "A postgresql-simple transaction monad";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "pg-transact_0_3_2_0" = callPackage
     ({ mkDerivation, async, base, bytestring, criterion, deepseq
      , exceptions, hspec, hspec-expectations-lifted, monad-control
      , postgresql-libpq, postgresql-simple, tmp-postgres, transformers
···
      }) {};
 
   "phonetic-languages-simplified-generalized-examples-array" = callPackage
-    ({ mkDerivation, base, heaps, mmsyn2-array, parallel
+    ({ mkDerivation, base, heaps, mmsyn2-array, mmsyn3, parallel
      , phonetic-languages-constraints-array
      , phonetic-languages-filters-array
      , phonetic-languages-permutations-array
      , phonetic-languages-phonetics-basics, phonetic-languages-plus
      , phonetic-languages-simplified-base
      , phonetic-languages-simplified-generalized-examples-common
-     , phonetic-languages-simplified-generalized-properties-array, subG
+     , phonetic-languages-simplified-generalized-properties-array
+     , process, subG
      }:
      mkDerivation {
        pname = "phonetic-languages-simplified-generalized-examples-array";
-       version = "0.3.0.0";
-       sha256 = "15k2nij8rpf1yvm5kjgkrvx1y4zlfskxfdxjbjirmaidamr2ha6d";
+       version = "0.4.1.1";
+       sha256 = "1xk4vj7bj93s8r9l09z2w9h0sbkd73qcv441jisa04m0s6hlhgby";
        libraryHaskellDepends = [
-         base heaps mmsyn2-array parallel
+         base heaps mmsyn2-array mmsyn3 parallel
          phonetic-languages-constraints-array
          phonetic-languages-filters-array
          phonetic-languages-permutations-array
          phonetic-languages-phonetics-basics phonetic-languages-plus
          phonetic-languages-simplified-base
          phonetic-languages-simplified-generalized-examples-common
-         phonetic-languages-simplified-generalized-properties-array subG
+         phonetic-languages-simplified-generalized-properties-array process
+         subG
        ];
        description = "Helps to create texts with the given phonetic properties (e. g. poetic).";
        license = lib.licenses.mit;
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "polysemy-keyed-state" = callPackage
+    ({ mkDerivation, base, constraints, constraints-extras, hspec
+     , polysemy, QuickCheck, some, StateVar, trivial-constraint
+     }:
+     mkDerivation {
+       pname = "polysemy-keyed-state";
+       version = "0.1";
+       sha256 = "00jcb0rd7s8yvflqx6xjas10lgh0dmg4ywb18cbkm8xd0pdn0d2j";
+       libraryHaskellDepends = [
+         base constraints constraints-extras polysemy some StateVar
+         trivial-constraint
+       ];
+       testHaskellDepends = [
+         base constraints constraints-extras hspec polysemy QuickCheck some
+         StateVar trivial-constraint
+       ];
+       description = "Effect for a set of stateful values indexed by a type of keys";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "polysemy-kvstore-jsonfile" = callPackage
     ({ mkDerivation, aeson, base, containers, exceptions, extra, path
      , polysemy, polysemy-zoo, unliftio-path
···
      }) {inherit (pkgs) acl;};
 
   "posix-api" = callPackage
-    ({ mkDerivation, base, byteslice, primitive, primitive-addr
-     , primitive-offset, primitive-unlifted, systemd, tasty, tasty-hunit
+    ({ mkDerivation, base, byte-order, byteslice, primitive
+     , primitive-addr, primitive-offset, primitive-unlifted, run-st
+     , systemd, tasty, tasty-hunit
      }:
      mkDerivation {
        pname = "posix-api";
-       version = "0.3.4.0";
-       sha256 = "163bblw200jr2vghc7i9g9xls6vhihayxvb4am4lr3j047ifqbmb";
+       version = "0.3.5.0";
+       sha256 = "0ygww5fcikalyqzliqdrcd4n4g8plhr01gz5p6zd0c5f1y9jgw7x";
        libraryHaskellDepends = [
-         base byteslice primitive primitive-addr primitive-offset
-         primitive-unlifted
+         base byte-order byteslice primitive primitive-addr primitive-offset
+         primitive-unlifted run-st
        ];
        pname = "javascript-bridge";
        testHaskellDepends = [
···
      }) {};
 
   "postgresql-syntax" = callPackage
-    ({ mkDerivation, base, bytestring, case-insensitive, fast-builder
-     , hashable, headed-megaparsec, hedgehog, megaparsec
-     , parser-combinators, QuickCheck, quickcheck-instances, rerebase
-     , tasty, tasty-hunit, tasty-quickcheck, text, text-builder
-     , unordered-containers
+    ({ mkDerivation, base, bytestring, case-insensitive, hashable
+     , headed-megaparsec, hedgehog, megaparsec, parser-combinators
+     , QuickCheck, quickcheck-instances, rerebase, tasty, tasty-hunit
+     , tasty-quickcheck, text, text-builder, unordered-containers
      }:
      mkDerivation {
        pname = "postgresql-syntax";
-       version = "0.3.0.3";
-       sha256 = "0zylrzd8dfks1jdx1yq1i2n2a7sxa8b04h6km9lx3bdpbpv84y7i";
+       version = "0.4";
+       sha256 = "133p9w35q7ynb15i97k9ci4w14vp5117v3hmgm4ys3jj07apjyxd";
        libraryHaskellDepends = [
-         base bytestring case-insensitive fast-builder hashable
-         headed-megaparsec megaparsec parser-combinators text text-builder
+         base bytestring case-insensitive hashable headed-megaparsec
+         megaparsec parser-combinators text text-builder
          unordered-containers
        ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "proteaaudio";
-       version = "0.9.0";
-       sha256 = "0y1vvcy0rdiraphi6c9i1xsw5zwdqsw0id40xhgvk37va36ryl3p";
+       version = "0.9.1";
+       sha256 = "1l2rxhs5v8mi77qw98849m0w2swwxvg5wm6d4j123sa29riyb70a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
···
     ({ mkDerivation, base, bytestring, c2hs, SDL2 }:
      mkDerivation {
        pname = "proteaaudio-sdl";
-       version = "0.9.0";
-       sha256 = "0ksdb89phsdjjq5q043wvqi3swibfd1840180jg3m8wj3zcy5g3k";
+       version = "0.9.1";
+       sha256 = "1qgb7zj7sj8sc3b7fwfq51s5m997dqgx74dmmkfam2s4v46fhqr4";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring ];
···
      }:
      mkDerivation {
        pname = "purescript";
-       version = "0.14.2";
-       sha256 = "12gk4c311v39gh0kp5s97gia2xrglzzkpnhisbpxc4h7nd9dqf5m";
+       version = "0.14.3";
+       sha256 = "0g0zly5wh75w8p09zq6sy25phbb432vb0allmcbx34vd84nm70ia";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "purescript-cst";
-       version = "0.2.0.0";
-       sha256 = "0spsl9aq7hg2pkqawwjirgdr8ypzpb9amf2pznxmn6wm9ppaq73s";
+       version = "0.3.0.0";
+       sha256 = "15gf3fxpqngnx75w7g8nyvmj452y3x9p8ymwwk4mkzql0zps2fy2";
        libraryHaskellDepends = [
          aeson array base base-compat bytestring containers deepseq dlist
          filepath microlens mtl protolude scientific semigroups serialise
···
     ({ mkDerivation, base, composition-prelude }:
      mkDerivation {
        pname = "recursion";
-       version = "2.2.4.3";
-       sha256 = "0k5as7i7xyas6qhpr7wpnnf0rc93nsh4s9gsxdsk72xkwd86chkj";
+       version = "2.2.4.4";
+       sha256 = "09zssx2yqz22hm678ik5zz2zkanzfazcyfqmwlxc9mk6gxxdy6ia";
        libraryHaskellDepends = [ base composition-prelude ];
        description = "A recursion schemes library for Haskell";
        license = lib.licenses.bsd3;
···
        pname = "req";
        version = "3.9.1";
        sha256 = "0468ah4142jrqp5l3pw4izrw6f6kznisan888b30jhif4c6xncr0";
+       revision = "1";
+       editedCabalFile = "0g2g8l1nhmqxgk2ylvavv7rw6bq73d3awd21l438mzzljqj4kvh8";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson authenticate-oauth base blaze-builder bytestring
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "retry_0_9_0_0" = callPackage
+    ({ mkDerivation, base, exceptions, ghc-prim, hedgehog, HUnit, mtl
+     , random, stm, tasty, tasty-hedgehog, tasty-hunit, time
+     , transformers
+     }:
+     mkDerivation {
+       pname = "retry";
+       version = "0.9.0.0";
+       sha256 = "0n304r6vyx238558z62kz7nii8y58h2z4iyx54gbkxmz9dsck4ff";
+       libraryHaskellDepends = [
+         base exceptions ghc-prim random transformers
+       ];
+       testHaskellDepends = [
+         base exceptions ghc-prim hedgehog HUnit mtl random stm tasty
+         tasty-hedgehog tasty-hunit time transformers
+       ];
+       description = "Retry combinators for monadic actions that may fail";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "retryer" = callPackage
     ({ mkDerivation, base, optparse-applicative, process }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "servant";
-       version = "0.18.2";
-       sha256 = "18mfjj9za8g9rgj7a6j0ly6lf1ykfwrlpy3cf53lv1gxvb19gmk5";
-       revision = "1";
-       editedCabalFile = "0f783bj89vb7j5cj5hk6hdmplhk3ay1z6swsinlr7a7f9h59x6vh";
-       libraryHaskellDepends = [
-         aeson attoparsec base base-compat bifunctors bytestring
-         case-insensitive deepseq http-api-data http-media http-types mmorph
-         mtl network-uri QuickCheck singleton-bool sop-core
-         string-conversions tagged text transformers vault
-       ];
-       testHaskellDepends = [
-         aeson base base-compat bytestring hspec http-media mtl QuickCheck
-         quickcheck-instances string-conversions text transformers
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "A family of combinators for defining webservices APIs";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant_0_18_3" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base-compat, bifunctors
-     , bytestring, case-insensitive, deepseq, hspec, hspec-discover
-     , http-api-data, http-media, http-types, mmorph, mtl, network-uri
-     , QuickCheck, quickcheck-instances, singleton-bool, sop-core
-     , string-conversions, tagged, text, transformers, vault
-     }:
-     mkDerivation {
-       pname = "servant";
        version = "0.18.3";
        sha256 = "033ykm8l7a9bjcwb3v9d0ljglq1sxpjm1iss7nqakpyxljcg2sxp";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "A family of combinators for defining webservices APIs";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-JuicyPixels" = callPackage
···
      }) {};
 
   "servant-client" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, bytestring, containers
-     , deepseq, entropy, exceptions, hspec, hspec-discover
-     , http-api-data, http-client, http-media, http-types, HUnit
-     , kan-extensions, markdown-unlit, monad-control, mtl, network
-     , QuickCheck, semigroupoids, servant, servant-client-core
-     , servant-server, sop-core, stm, tdigest, text, time, transformers
-     , transformers-base, transformers-compat, wai, warp
-     }:
-     mkDerivation {
-       pname = "servant-client";
-       version = "0.18.2";
-       sha256 = "0acwpjmi5r62jgmpw508jq942kq5dhdy5602w9v7g318inxzwwi1";
-       revision = "1";
-       editedCabalFile = "1phjfsqzmwc5m45f9zbpp76f7f9z96v0in7ngxz6pj8r90bcv8ga";
-       libraryHaskellDepends = [
-         base base-compat bytestring containers deepseq exceptions
-         http-client http-media http-types kan-extensions monad-control mtl
-         semigroupoids servant servant-client-core stm text time
-         transformers transformers-base transformers-compat
-       ];
-       testHaskellDepends = [
-         aeson base base-compat bytestring entropy hspec http-api-data
-         http-client http-types HUnit kan-extensions markdown-unlit mtl
-         network QuickCheck servant servant-client-core servant-server
-         sop-core stm tdigest text transformers transformers-compat wai warp
-       ];
-       testToolDepends = [ hspec-discover markdown-unlit ];
-       description = "Automatic derivation of querying functions for servant";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-client_0_18_3" = callPackage
     ({ mkDerivation, aeson, base, base-compat, bytestring, containers
      , deepseq, entropy, exceptions, hspec, hspec-discover
      , http-api-data, http-client, http-media, http-types, HUnit
···
        testToolDepends = [ hspec-discover markdown-unlit ];
        description = "Automatic derivation of querying functions for servant";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-client-core" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-client-core";
-       version = "0.18.2";
-       sha256 = "0b449c28z20sx98pc2d4p65jr3m9glsa47jjc2w4gf90jisl173r";
-       revision = "2";
-       editedCabalFile = "0clbchlla9r0scz0giqmy3pwsnlfcf19hwkqj3yl1y77qx7kv4lr";
-       libraryHaskellDepends = [
-         aeson base base-compat base64-bytestring bytestring containers
-         deepseq exceptions free http-media http-types network-uri safe
-         servant sop-core template-haskell text transformers
-       ];
-       testHaskellDepends = [ base base-compat deepseq hspec QuickCheck ];
-       testToolDepends = [ hspec-discover ];
-       description = "Core functionality and class for client function generation for servant APIs";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-client-core_0_18_3" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
-     , bytestring, containers, deepseq, exceptions, free, hspec
-     , hspec-discover, http-media, http-types, network-uri, QuickCheck
-     , safe, servant, sop-core, template-haskell, text, transformers
-     }:
-     mkDerivation {
-       pname = "servant-client-core";
        version = "0.18.3";
        sha256 = "1iln4axymmmk3ib0wxmpzjgq16lip8nz7xich3ysgzx6g2n15xsd";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Core functionality and class for client function generation for servant APIs";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-client-js" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-docs";
-       version = "0.11.8";
-       sha256 = "0zbsv75zyfg44l4822qnmvw2naxcxwgnpzc55jnvz766l2dydjrb";
-       revision = "1";
-       editedCabalFile = "0bfhypzm02aqwckjrvjmhvf602di0pmp4r0rjbfcraxzvkrzm6qv";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson aeson-pretty base base-compat bytestring case-insensitive
-         hashable http-media http-types lens servant string-conversions text
-         universe-base unordered-containers
-       ];
-       executableHaskellDepends = [
-         aeson base lens servant string-conversions text
-       ];
-       testHaskellDepends = [
-         aeson base base-compat lens servant string-conversions tasty
-         tasty-golden tasty-hunit transformers
-       ];
-       description = "generate API docs for your servant webservice";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-docs_0_11_9" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring
-     , case-insensitive, hashable, http-media, http-types, lens, servant
-     , string-conversions, tasty, tasty-golden, tasty-hunit, text
-     , transformers, universe-base, unordered-containers
-     }:
-     mkDerivation {
-       pname = "servant-docs";
        version = "0.11.9";
        sha256 = "0ynjyyxlzb2j5d92rryqqa97rp16582mbmvnv7syczha5ziq24nk";
        isLibrary = true;
···
        ];
        description = "generate API docs for your servant webservice";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-docs-simple" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-foreign";
-       version = "0.15.3";
-       sha256 = "1bz2ry5pd8cx5pmsvg7q29r9gd5kqjjv9nd97f7abwjqi8as2413";
-       revision = "2";
-       editedCabalFile = "1fdbxyyp2h5gcighjrww2mbg8z6givmhx2in8293kw58w7y2im0i";
-       libraryHaskellDepends = [
-         base base-compat http-types lens servant text
-       ];
-       testHaskellDepends = [ base hspec servant ];
-       testToolDepends = [ hspec-discover ];
-       description = "Helpers for generating clients for servant APIs in any programming language";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-foreign_0_15_4" = callPackage
-    ({ mkDerivation, base, base-compat, hspec, hspec-discover
-     , http-types, lens, servant, text
-     }:
-     mkDerivation {
-       pname = "servant-foreign";
        version = "0.15.4";
        sha256 = "0bznb73rbgfgkg7n4pxghkqsfca0yw9vak73c6w8sqvc2mjnc7mz";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Helpers for generating clients for servant APIs in any programming language";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-gdp" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-http-streams";
-       version = "0.18.2";
-       sha256 = "1kyiv8qamw9dxv2ax7hx9n7w9507vjvwn89x4nvlsc87nq91hvg0";
-       revision = "1";
-       editedCabalFile = "0hkcyz93px5x6l5nyh9ymswhwpfidbji2kmlhrw7ksg4zsxkl2p9";
-       libraryHaskellDepends = [
-         base base-compat bytestring case-insensitive containers deepseq
-         exceptions http-common http-media http-streams http-types
-         io-streams kan-extensions monad-control mtl semigroupoids servant
-         servant-client-core text time transformers transformers-base
-         transformers-compat
-       ];
-       testHaskellDepends = [
-         aeson base base-compat bytestring deepseq entropy hspec
-         http-api-data http-streams http-types HUnit kan-extensions
-         markdown-unlit mtl network QuickCheck servant servant-client-core
-         servant-server stm tdigest text transformers transformers-compat
-         wai warp
-       ];
-       testToolDepends = [ hspec-discover markdown-unlit ];
-       description = "Automatic derivation of querying functions for servant";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "servant-http-streams_0_18_3" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, bytestring
-     , case-insensitive, containers, deepseq, entropy, exceptions, hspec
-     , hspec-discover, http-api-data, http-common, http-media
-     , http-streams, http-types, HUnit, io-streams, kan-extensions
-     , markdown-unlit, monad-control, mtl, network, QuickCheck
-     , semigroupoids, servant, servant-client-core, servant-server, stm
-     , tdigest, text, time, transformers, transformers-base
-     , transformers-compat, wai, warp
-     }:
-     mkDerivation {
-       pname = "servant-http-streams";
        version = "0.18.3";
        sha256 = "0cc4qmbzq4n1yp5yfg76w1skkksh13qlbza9i2pgsxa9sc39s5fa";
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "servant-pipes";
-       version = "0.15.2";
-       sha256 = "1r5irq09j64iapi5n9mzsph984r5f7cyr6zz4sw3xqh648dmf75h";
-       libraryHaskellDepends = [
-         base bytestring monad-control mtl pipes pipes-safe servant
-       ];
-       testHaskellDepends = [
-         base base-compat bytestring http-client http-media pipes
-         pipes-bytestring pipes-safe servant servant-client servant-server
-         wai warp
-       ];
-       description = "Servant Stream support for pipes";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-pipes_0_15_3" = callPackage
-    ({ mkDerivation, base, base-compat, bytestring, http-client
-     , http-media, monad-control, mtl, pipes, pipes-bytestring
-     , pipes-safe, servant, servant-client, servant-server, wai, warp
-     }:
-     mkDerivation {
-       pname = "servant-pipes";
        version = "0.15.3";
        sha256 = "1sd01f95rkraa0zdqqg2vwx91zsih0i0hqqkz55nnw9bsbsqhq1n";
        libraryHaskellDepends = [
···
        ];
        description = "Servant Stream support for pipes";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-polysemy" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-server";
-       version = "0.18.2";
-       sha256 = "05ricb3w1app6c094zwaq2jnqv53jpf4n89ffynm31dvf6h9qdih";
-       revision = "1";
-       editedCabalFile = "0xhq2rpc4ry1xgwz835bcm8qdnsifpc8wck9wa5r510ff21dqw4d";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base base-compat base64-bytestring bytestring containers exceptions
-         filepath http-api-data http-media http-types monad-control mtl
-         network network-uri resourcet servant sop-core string-conversions
-         tagged text transformers transformers-base wai wai-app-static word8
-       ];
-       executableHaskellDepends = [
-         aeson base base-compat servant text wai warp
-       ];
-       testHaskellDepends = [
-         aeson base base-compat base64-bytestring bytestring directory hspec
-         hspec-wai http-types mtl QuickCheck resourcet safe servant
-         should-not-typecheck string-conversions temporary text transformers
-         transformers-compat wai wai-extra
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "A family of combinators for defining webservices APIs and serving them";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "servant-server_0_18_3" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
-     , bytestring, containers, directory, exceptions, filepath, hspec
-     , hspec-discover, hspec-wai, http-api-data, http-media, http-types
-     , monad-control, mtl, network, network-uri, QuickCheck, resourcet
-     , safe, servant, should-not-typecheck, sop-core, string-conversions
-     , tagged, temporary, text, transformers, transformers-base
-     , transformers-compat, wai, wai-app-static, wai-extra, warp, word8
-     }:
-     mkDerivation {
-       pname = "servant-server";
        version = "0.18.3";
        sha256 = "1gng0in85as45aprwy19xaqlgmwfx0pkly150d2v96knhbcwsshk";
        isLibrary = true;
···
        testToolDepends = [ hspec-discover ];
        description = "A family of combinators for defining webservices APIs and serving them";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-server-namedargs" = callPackage
···
      }:
      mkDerivation {
        pname = "sexp-grammar";
-       version = "2.3.0";
-       sha256 = "1ky0jj47xp6g8shk5znrhncj71sg0p653csj1ds2yl36s7fiwgdk";
-       libraryHaskellDepends = [
-         array base bytestring containers data-fix deepseq
-         invertible-grammar prettyprinter recursion-schemes scientific
-         semigroups text utf8-string
-       ];
-       libraryToolDepends = [ alex happy ];
-       testHaskellDepends = [
-         base containers invertible-grammar prettyprinter QuickCheck
-         scientific semigroups tasty tasty-hunit tasty-quickcheck text
-         utf8-string
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring criterion deepseq text
-       ];
-       description = "Invertible grammar combinators for S-expressions";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "sexp-grammar_2_3_1" = callPackage
-    ({ mkDerivation, alex, array, base, bytestring, containers
-     , criterion, data-fix, deepseq, happy, invertible-grammar
-     , prettyprinter, QuickCheck, recursion-schemes, scientific
-     , semigroups, tasty, tasty-hunit, tasty-quickcheck, text
-     , utf8-string
-     }:
-     mkDerivation {
-       pname = "sexp-grammar";
        version = "2.3.1";
        sha256 = "05vj998wzj1wja4848kd04c89jb8pmvdyl40aw6qvc9fq0qzw6m4";
        libraryHaskellDepends = [
···
        ];
        description = "Invertible grammar combinators for S-expressions";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "sexp-show" = callPackage
···
      }:
      mkDerivation {
        pname = "shake";
-       version = "0.19.4";
-       sha256 = "1vkkgncar07na4kn3i02b2zdyjdjxl10hrcz2l23c498yrrqibjv";
+       version = "0.19.5";
+       sha256 = "105agfvn75czyq3jbmppybv776njlsqc7k4m1xnx0n78qjmcnpb9";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
     ({ mkDerivation, base, optparse-applicative }:
      mkDerivation {
        pname = "simple-cmd-args";
-       version = "0.1.6";
-       sha256 = "18dikz7hy61wgrbpgnxmgfp1i485hkhgrdnqbkzl2mrmmjn8p1zd";
-       libraryHaskellDepends = [ base optparse-applicative ];
-       description = "Simple command args parsing and execution";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "simple-cmd-args_0_1_7" = callPackage
-    ({ mkDerivation, base, optparse-applicative }:
-     mkDerivation {
-       pname = "simple-cmd-args";
        version = "0.1.7";
        sha256 = "0lf0pyiv02sg2yh9avj92fm75sni61qnaq3rmjw5vlczy03ksxpc";
        libraryHaskellDepends = [ base optparse-applicative ];
        description = "Simple command args parsing and execution";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "simple-conduit" = callPackage
···
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.10.5.1";
-       sha256 = "11y2j9c4gw0x5h974jrp0yppy5dys9i0nxdbzm374nwx8mjwdl4w";
-       configureFlags = [ "-fexecutable" ];
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base binary containers skylighting-core
-       ];
-       executableHaskellDepends = [
-         base blaze-html bytestring containers pretty-show text
-       ];
-       description = "syntax highlighting library";
-       license = lib.licenses.gpl2Only;
-     }) {};
-
-  "skylighting_0_10_5_2" = callPackage
-    ({ mkDerivation, base, binary, blaze-html, bytestring, containers
-     , pretty-show, skylighting-core, text
-     }:
-     mkDerivation {
-       pname = "skylighting";
        version = "0.10.5.2";
        sha256 = "152ywiy7h04xjy0fdl571jwahl6c9350isqbm4p0na4cjd9cczzh";
        configureFlags = [ "-fexecutable" ];
···
        ];
        description = "syntax highlighting library";
        license = lib.licenses.gpl2Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "skylighting-core" = callPackage
···
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.10.5.1";
-       sha256 = "14mz7krfkidgplhp49w84ryz74jrsdqll44wqd0my0m28v2vg9ka";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         aeson ansi-terminal attoparsec base base64-bytestring binary
-         blaze-html bytestring case-insensitive colour containers directory
-         filepath mtl safe text transformers utf8-string xml-conduit
-       ];
-       testHaskellDepends = [
-         aeson base bytestring containers Diff directory filepath
-         pretty-show QuickCheck tasty tasty-golden tasty-hunit
-         tasty-quickcheck text
-       ];
-       benchmarkHaskellDepends = [
-         base containers criterion directory filepath text
-       ];
-       description = "syntax highlighting library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "skylighting-core_0_10_5_2" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
-     , base64-bytestring, binary, blaze-html, bytestring
-     , case-insensitive, colour, containers, criterion, Diff, directory
-     , filepath, mtl, pretty-show, QuickCheck, safe, tasty, tasty-golden
-     , tasty-hunit, tasty-quickcheck, text, transformers, utf8-string
-     , xml-conduit
-     }:
-     mkDerivation {
-       pname = "skylighting-core";
        version = "0.10.5.2";
        sha256 = "0bskci0gng6nf324wna9ss4xbr1mwjkgk3mlfkr96r1m3wza5g3d";
        isLibrary = true;
···
        ];
        description = "syntax highlighting library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "skylighting-extensions" = callPackage
···
      }:
      mkDerivation {
        pname = "sr-extra";
-       version = "1.85.1";
-       sha256 = "15x8d413m8ldl81b5yx13nprr4k0aszx33mjm880za0k90s8r65x";
-       revision = "1";
-       editedCabalFile = "0pmf6vlxv8kd6imq9xwnfc8j3mk6yswvcirdmb2hi8ql41cqwnay";
+       version = "1.88";
+       sha256 = "1cpigfdpgcy3bpp51snza0wwd88ky04hwqlzbmvmwkwznd7wqxrb";
        libraryHaskellDepends = [
          base base64-bytestring bytestring bzlib Cabal cereal containers
          Diff directory exceptions fgl filemanip filepath generic-data
···
      }) {};
 
   "streaming-benchmarks" = callPackage
-    ({ mkDerivation, base, bench-graph, bytestring, Chart
-     , Chart-diagrams, conduit, csv, deepseq, directory, drinkery, gauge
-     , getopt-generics, machines, mtl, pipes, random, split, streaming
-     , streamly, template-haskell, text, transformers, typed-process
-     , vector
+    ({ mkDerivation, base, bytestring, conduit, containers, deepseq
+     , dlist, drinkery, gauge, machines, mtl, pipes, random, streaming
+     , streamly, template-haskell, text, transformers, vector
      }:
      mkDerivation {
        pname = "streaming-benchmarks";
-       version = "0.2.0";
-       sha256 = "1vpflmvz2vrll9bangl61rdjnngdxbrmpzg3xha8h85ij3458c0x";
+       version = "0.3.0";
+       sha256 = "0cy65d1aph2wk3yc7kj8ywq40f8jgpx72isywnnw2sg9jz9jnd85";
        isLibrary = false;
        isExecutable = true;
-       executableHaskellDepends = [
-         base bench-graph bytestring Chart Chart-diagrams csv directory
-         getopt-generics split text transformers typed-process
-       ];
        benchmarkHaskellDepends = [
-         base conduit deepseq drinkery gauge machines mtl pipes random
-         streaming streamly template-haskell transformers vector
+         base bytestring conduit containers deepseq dlist drinkery gauge
+         machines mtl pipes random streaming streamly template-haskell text
+         transformers vector
        ];
-       description = "Benchmarks to compare streaming packages";
+       description = "Measures and compares the performance of streaming libraries";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "streaming-binary" = callPackage
···
      }:
      mkDerivation {
        pname = "streaming-bytestring";
-       version = "0.2.0";
-       sha256 = "1vmbg84xc7ix7ihs96ia13gdpi7z3grrkq9qai6j8s1klnzpljhi";
-       libraryHaskellDepends = [
-         base bytestring deepseq exceptions ghc-prim mmorph mtl resourcet
-         streaming transformers transformers-base
-       ];
-       testHaskellDepends = [
-         base bytestring resourcet smallcheck streaming tasty tasty-hunit
-         tasty-smallcheck transformers
-       ];
-       description = "Fast, effectful byte streams";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "streaming-bytestring_0_2_1" = callPackage
-    ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim
-     , mmorph, mtl, resourcet, smallcheck, streaming, tasty, tasty-hunit
-     , tasty-smallcheck, transformers, transformers-base
-     }:
-     mkDerivation {
-       pname = "streaming-bytestring";
        version = "0.2.1";
        sha256 = "1yri2g0wx2fila25ang04nsv4i12b4yhwqwcfkkpx1sz8fhzibxy";
        libraryHaskellDepends = [
···
        ];
        description = "Fast, effectful byte streams";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "streaming-cassava" = callPackage
···
     ({ mkDerivation, base, bytestring, text }:
      mkDerivation {
        pname = "stripe-concepts";
-       version = "1.0.2.8";
-       sha256 = "03sqgmbbjqi18wjb96sc3lvc6p3bqk5sgsgbcf9z8k9rbdspribm";
-       libraryHaskellDepends = [ base bytestring text ];
-       description = "Types for the Stripe API";
-       license = lib.licenses.mit;
-     }) {};
-
-  "stripe-concepts_1_0_3" = callPackage
-    ({ mkDerivation, base, bytestring, text }:
-     mkDerivation {
-       pname = "stripe-concepts";
        version = "1.0.3";
        sha256 = "1wykg9flg0qliqlz3ywkmnqhh55aa61r4mvbhsly6ib8r6knr382";
        libraryHaskellDepends = [ base bytestring text ];
        description = "Types for the Stripe API";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "stripe-core" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "strong-path" = callPackage
+    ({ mkDerivation, base, exceptions, filepath, path, tasty
+     , tasty-discover, tasty-hspec, tasty-quickcheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "strong-path";
+       version = "1.0.0.0";
+       sha256 = "0xpflbqzdbf7pk2v5c5acd5j4ijldklx0vvypw36zvy50ld4ffpz";
+       libraryHaskellDepends = [
+         base exceptions filepath path template-haskell
+       ];
+       testHaskellDepends = [
+         base filepath path tasty tasty-discover tasty-hspec
+         tasty-quickcheck
+       ];
+       testToolDepends = [ tasty-discover ];
+       description = "Strongly typed paths in Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "strongswan-sql" = callPackage
     ({ mkDerivation, asn1-encoding, asn1-types, attoparsec, base
      , bytestring, data-default, failable, haskeline, io-streams
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "sydtest_0_3_0_1" = callPackage
+  "sydtest_0_3_0_2" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, Diff, dlist
      , envparse, filepath, MonadRandom, mtl, optparse-applicative, path
      , path-io, pretty-show, QuickCheck, quickcheck-io, random-shuffle
···
      }:
      mkDerivation {
        pname = "sydtest";
-       version = "0.3.0.1";
-       sha256 = "0ddbjs2p2vzmzadggyvdpknmcw935jmj2m9nxki2apc9ciq6skig";
+       version = "0.3.0.2";
+       sha256 = "1823g9czwgf0p0jyxlddqwnpwhs3622892c9ah6cacvl9xfl3sg9";
        libraryHaskellDepends = [
          async base bytestring containers Diff dlist envparse filepath
          MonadRandom mtl optparse-applicative path path-io pretty-show
···
        maintainers = with lib.maintainers; [ sternenseemann ];
      }) {};
 
+  "systemd-socket-activation" = callPackage
+    ({ mkDerivation, base, containers, network, text, transformers
+     , unix
+     }:
+     mkDerivation {
+       pname = "systemd-socket-activation";
+       version = "1";
+       sha256 = "10y7g2y62v48n6zkpgpjqyf2a7fqm8d9mx24vcwk6bcxkq1bciz2";
+       revision = "1";
+       editedCabalFile = "084phqk9wb0slsmb7pj68nivhjx3w6hs0djq589j771v579vck0r";
+       libraryHaskellDepends = [
+         base containers network text transformers unix
+       ];
+       description = "Let systemd bind the server's socket for you";
+       license = lib.licenses.mit;
+     }) {};
+
   "systemstats" = callPackage
     ({ mkDerivation, base, micrologger, optparse-applicative, statgrab
      , text, text-format, transformers
···
        broken = true;
      }) {};
 
+  "tasty-prelude" = callPackage
+    ({ mkDerivation, base, tasty, tasty-expected-failure, tasty-focus
+     }:
+     mkDerivation {
+       pname = "tasty-prelude";
+       version = "0.1.0.0";
+       sha256 = "0kccgw0g45cll69hc9f5sifzpsmvcjskcyfvfqnd5zmdh4vcnj70";
+       libraryHaskellDepends = [
+         base tasty tasty-expected-failure tasty-focus
+       ];
+       description = "Unopinionated top-level entry point to tasty ecosystem";
+       license = lib.licenses.mpl20;
+     }) {};
+
   "tasty-program" = callPackage
     ({ mkDerivation, base, deepseq, directory, filepath, process, tasty
      }:
···
      }:
      mkDerivation {
        pname = "tasty-silver";
-       version = "3.2.1";
-       sha256 = "1i39xks5rjpnid2y1n16fyb01wj7hpdw0n5ci1rnsps5f16nkcxr";
-       libraryHaskellDepends = [
-         ansi-terminal async base bytestring containers deepseq directory
-         filepath mtl optparse-applicative process process-extras regex-tdfa
-         stm tagged tasty temporary text
-       ];
-       testHaskellDepends = [
-         base directory filepath process tasty tasty-hunit temporary
-         transformers
-       ];
-       description = "A fancy test runner, including support for golden tests";
-       license = lib.licenses.mit;
-     }) {};
-
-  "tasty-silver_3_2_2" = callPackage
-    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
-     , deepseq, directory, filepath, mtl, optparse-applicative, process
-     , process-extras, regex-tdfa, stm, tagged, tasty, tasty-hunit
-     , temporary, text, transformers
-     }:
-     mkDerivation {
-       pname = "tasty-silver";
        version = "3.2.2";
        sha256 = "0zsl6nna8ir215qyxhyh2czx4i16hzw1n1m8jw8ym02j6sp6iz13";
        libraryHaskellDepends = [
···
        ];
        description = "A fancy test runner, including support for golden tests";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-smallcheck" = callPackage
···
     ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cron
      , filepath, hashable, http-api-data, http-client, http-client-tls
      , monad-control, mtl, pretty-show, profunctors, servant
-     , servant-client, servant-multipart, split, stm, template-haskell
-     , text, time, transformers, unordered-containers
+     , servant-client, servant-multipart, servant-multipart-api
+     , servant-multipart-client, split, stm, template-haskell, text
+     , time, transformers, unordered-containers
      }:
      mkDerivation {
        pname = "telegram-bot-simple";
-       version = "0.3.5";
-       sha256 = "08b650z513lbmmb46xinwgdb3csgpx9rjk5vn345xb9b0ki94chq";
+       version = "0.3.7";
+       sha256 = "09bi2rbajiv3p2anky9zjnbvxxd79d70p3im94zrp14db0zjhnp7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring cron filepath hashable
          http-api-data http-client http-client-tls monad-control mtl
          pretty-show profunctors servant servant-client servant-multipart
-         split stm template-haskell text time transformers
-         unordered-containers
+         servant-multipart-api servant-multipart-client split stm
+         template-haskell text time transformers unordered-containers
        ];
        executableHaskellDepends = [
          aeson aeson-pretty base bytestring cron filepath hashable
          http-api-data http-client http-client-tls monad-control mtl
          pretty-show profunctors servant servant-client servant-multipart
-         split stm template-haskell text time transformers
-         unordered-containers
+         servant-multipart-api servant-multipart-client split stm
+         template-haskell text time transformers unordered-containers
        ];
        description = "Easy to use library for building Telegram bots";
        license = lib.licenses.bsd3;
···
     ({ mkDerivation, base, template-haskell }:
      mkDerivation {
        pname = "template-haskell-compat-v0208";
-       version = "0.1.5";
-       sha256 = "1s1ynp568i7y5v062kliia46c3cmaijslf2hlmdkkqfdvf8fmzp1";
-       libraryHaskellDepends = [ base template-haskell ];
-       description = "A backwards compatibility layer for Template Haskell newer than 2.8";
-       license = lib.licenses.mit;
-     }) {};
-
-  "template-haskell-compat-v0208_0_1_6" = callPackage
-    ({ mkDerivation, base, template-haskell }:
-     mkDerivation {
-       pname = "template-haskell-compat-v0208";
        version = "0.1.6";
        sha256 = "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8";
        libraryHaskellDepends = [ base template-haskell ];
        description = "A backwards compatibility layer for Template Haskell newer than 2.8";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "template-haskell-optics" = callPackage
···
      }) {};
 
   "text1" = callPackage
-    ({ mkDerivation, base, binary, HUnit, lens, QuickCheck, semigroups
-     , text
+    ({ mkDerivation, base, binary, HUnit, lens, QuickCheck
+     , semigroupoids, semigroups, text
      }:
      mkDerivation {
        pname = "text1";
-       version = "0.0.6.1";
-       sha256 = "10kzl1gwi08pxzs8flr5bhfcwqgcl0jz9cadw3hqmbmynpij95ij";
-       libraryHaskellDepends = [ base binary lens semigroups text ];
+       version = "0.0.7.0";
+       sha256 = "0ph9vyx88mwh4d6n0wxbhicjc1x3d645kglw82nr5ggapgsab2a1";
+       libraryHaskellDepends = [
+         base binary lens semigroupoids semigroups text
+       ];
        testHaskellDepends = [
          base HUnit lens QuickCheck semigroups text
        ];
···
        testToolDepends = [ tasty-discover ];
        description = "throwable-exceptions gives the easy way to throw exceptions";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "thumbnail" = callPackage
···
      }:
      mkDerivation {
        pname = "tidal";
-       version = "1.7.5";
-       sha256 = "0mcq1sll148qfwkyad6y9k64zrlbkflzba9wqcgqydgfm0jyr7z7";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bifunctors bytestring clock colour containers deepseq hosc
-         network parsec primitive random text transformers
-       ];
-       testHaskellDepends = [
-         base containers deepseq hosc microspec parsec
-       ];
-       benchmarkHaskellDepends = [ base criterion weigh ];
-       description = "Pattern language for improvised music";
-       license = lib.licenses.gpl3Only;
-     }) {};
-
-  "tidal_1_7_7" = callPackage
-    ({ mkDerivation, base, bifunctors, bytestring, clock, colour
-     , containers, criterion, deepseq, hosc, microspec, network, parsec
-     , primitive, random, text, transformers, weigh
-     }:
-     mkDerivation {
-       pname = "tidal";
        version = "1.7.7";
        sha256 = "19r9h45yd2xwmah81xqmwx5bi5gi0x2hqhq2nqa47jgb0nd12a25";
        enableSeparateDataOutput = true;
···
        benchmarkHaskellDepends = [ base criterion weigh ];
        description = "Pattern language for improvised music";
        license = lib.licenses.gpl3Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tidal-midi" = callPackage
···
        ];
        description = "Start and stop a temporary postgres";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "tmpl" = callPackage
···
      }:
      mkDerivation {
        pname = "traverse-with-class";
-       version = "1.0.1.0";
-       sha256 = "1yni197sxfpsjvjablhn8mjqpp1mz0v30r73f9ncs3pjcl93g6yn";
-       libraryHaskellDepends = [ base template-haskell transformers ];
-       testHaskellDepends = [ base tasty tasty-hunit ];
-       description = "Generic applicative traversals";
-       license = lib.licenses.mit;
-     }) {};
-
-  "traverse-with-class_1_0_1_1" = callPackage
-    ({ mkDerivation, base, tasty, tasty-hunit, template-haskell
-     , transformers
-     }:
-     mkDerivation {
-       pname = "traverse-with-class";
        version = "1.0.1.1";
        sha256 = "0c0h902hr3gnlmlvqjhz3k5abyg0ays2g2c1kwrhbz0nhgfwk656";
        libraryHaskellDepends = [ base template-haskell transformers ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Generic applicative traversals";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "travis" = callPackage
···
      }:
      mkDerivation {
        pname = "ttc";
-       version = "1.1.0.0";
-       sha256 = "02b55f0dwgxvpr8x2727ryb6zhvz73l6l001szm4i821q0p4h00g";
-       libraryHaskellDepends = [ base bytestring template-haskell text ];
-       testHaskellDepends = [
-         base bytestring tasty tasty-hunit template-haskell text
-       ];
-       description = "Textual Type Classes";
-       license = lib.licenses.mit;
-     }) {};
-
-  "ttc_1_1_0_1" = callPackage
-    ({ mkDerivation, base, bytestring, tasty, tasty-hunit
-     , template-haskell, text
-     }:
-     mkDerivation {
-       pname = "ttc";
        version = "1.1.0.1";
        sha256 = "0vngp6md5viz4r57q0qn3pf09ph6kpkzvdigsxmgqcic2ha1a4n1";
        libraryHaskellDepends = [ base bytestring template-haskell text ];
···
        ];
        description = "Textual Type Classes";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ttl-hashtables" = callPackage
···
        broken = true;
      }) {};
 
+  "typeable-mock" = callPackage
+    ({ mkDerivation, base, call-stack, containers, hspec
+     , variadic-function
+     }:
+     mkDerivation {
+       pname = "typeable-mock";
+       version = "0.1.0.1";
+       sha256 = "1hfjyk5r2xikwfdz5hfiffc22dci821xzcj8lnml4kh7d0w55mfa";
+       libraryHaskellDepends = [
+         base call-stack containers variadic-function
+       ];
+       testHaskellDepends = [
+         base call-stack containers hspec variadic-function
+       ];
+       description = "Mock functions and expressions anywhere";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "typeable-th" = callPackage
     ({ mkDerivation, base, template-haskell, transformers }:
      mkDerivation {
···
     ({ mkDerivation, base, bytestring, unordered-containers }:
      mkDerivation {
        pname = "uniq-deep";
-       version = "1.2.0";
-       sha256 = "1r0gq0mlnl9wdn3v0pdq3vnwn6r4pzc6j7ssha93lms9380kl4nx";
+       version = "1.2.1";
+       sha256 = "0281yfiv6qmq1q5pvrvf6qg4nwzzav6rvb4mcdzqshsrbw9n12ig";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
   "uri-bytestring" = callPackage
     ({ mkDerivation, attoparsec, base, base-compat, blaze-builder
      , bytestring, containers, criterion, deepseq, deepseq-generics
-     , hedgehog, HUnit, network-uri, safe, semigroups, tasty
-     , tasty-hedgehog, tasty-hunit, template-haskell, th-lift-instances
-     , transformers
+     , hedgehog, HUnit, network-uri, safe, tasty, tasty-hedgehog
+     , tasty-hunit, template-haskell, th-lift-instances, transformers
      }:
      mkDerivation {
        pname = "uri-bytestring";
-       version = "0.3.3.0";
-       sha256 = "1zpynqz2q29cfk77n0d6lrnzmrqqi5nijvqd2pkz2fax3s6qhysz";
+       version = "0.3.3.1";
+       sha256 = "0s0k26v5x6601rbpkjkl5vp3dkp9xwj1dlgy4xkl470i4sna1rzk";
        libraryHaskellDepends = [
          attoparsec base blaze-builder bytestring containers
          template-haskell th-lift-instances
        ];
        testHaskellDepends = [
          attoparsec base base-compat blaze-builder bytestring containers
-         hedgehog HUnit safe semigroups tasty tasty-hedgehog tasty-hunit
-         transformers
+         hedgehog HUnit safe tasty tasty-hedgehog tasty-hunit transformers
        ];
        benchmarkHaskellDepends = [
          base blaze-builder bytestring criterion deepseq deepseq-generics
···
     ({ mkDerivation, base, hspec }:
      mkDerivation {
        pname = "validity";
-       version = "0.11.0.0";
-       sha256 = "1jawa7d37al29zp2b5hba9w348g926ckbxp51l9bprii5v47lyln";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base hspec ];
-       description = "Validity typeclass";
-       license = lib.licenses.mit;
-     }) {};
-
-  "validity_0_11_0_1" = callPackage
-    ({ mkDerivation, base, hspec }:
-     mkDerivation {
-       pname = "validity";
        version = "0.11.0.1";
        sha256 = "086nj5ymp4mxxfw9qjgjhd4j3z7gl2y9d89p0b7bkap5ampgdw2x";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "Validity typeclass";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "validity-aeson" = callPackage
···
     ({ mkDerivation, base, hspec }:
      mkDerivation {
        pname = "variadic-function";
-       version = "0.1.0.1";
-       sha256 = "0p458anbqlx23x77wp1nh465za3dad5s0gjrkdhi364rr4v58i3a";
+       version = "0.1.0.2";
+       sha256 = "0kwrhraq45vb9bs0xn4xbahywwrxcspmvmc4l133rilgzx2gcv5w";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "Create and transform functions with variable arity";
···
        license = lib.licenses.mit;
      }) {};
 
+  "vector-builder_0_3_8_2" = callPackage
+    ({ mkDerivation, attoparsec, base, QuickCheck, quickcheck-instances
+     , rerebase, tasty, tasty-hunit, tasty-quickcheck, vector
+     }:
+     mkDerivation {
+       pname = "vector-builder";
+       version = "0.3.8.2";
+       sha256 = "1g1zxp6xcwcq3372a5qqs44cl09a48p21m1jsys5bsampprlmcgs";
+       libraryHaskellDepends = [ base vector ];
+       testHaskellDepends = [
+         attoparsec QuickCheck quickcheck-instances rerebase tasty
+         tasty-hunit tasty-quickcheck
+       ];
+       description = "Vector builder";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "vector-bytes-instances" = callPackage
     ({ mkDerivation, base, bytes, tasty, tasty-quickcheck, vector }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "vector-sized";
-       version = "1.4.3.1";
-       sha256 = "0vm6wvbn3g4r028p46yh24rz7pr429w03jshpwyj2z2c6b058klr";
-       libraryHaskellDepends = [
-         adjunctions base binary comonad deepseq distributive
-         finite-typelits hashable indexed-list-literals primitive vector
-       ];
-       description = "Size tagged vectors";
-       license = lib.licenses.bsd3;
-       maintainers = with lib.maintainers; [ expipiplus1 ];
-     }) {};
-
-  "vector-sized_1_4_4" = callPackage
-    ({ mkDerivation, adjunctions, base, binary, comonad, deepseq
-     , distributive, finite-typelits, hashable, indexed-list-literals
-     , primitive, vector
-     }:
-     mkDerivation {
-       pname = "vector-sized";
        version = "1.4.4";
        sha256 = "0rlzwxcxzrxg7nwqijigj80fr4fyi5c2a8785898kir5hcyd6v1d";
        libraryHaskellDepends = [
···
        ];
        description = "Size tagged vectors";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ expipiplus1 ];
      }) {};
 
···
      }:
      mkDerivation {
        pname = "vulkan";
-       version = "3.11.1";
-       sha256 = "18ci35csymc788hr2md5cfxmra3ad0rc5mrbk37jjf0qga9a375x";
+       version = "3.11.2";
+       sha256 = "1pvszf89q1b7r5a1lzdvc28cylmlgnvvss5nw6497iclzh6hs82i";
        libraryHaskellDepends = [ base bytestring transformers vector ];
        libraryPkgconfigDepends = [ vulkan ];
        testHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "warp";
-       version = "3.3.16";
-       sha256 = "1qnngw7afh448hv7fzp4l36j7hz6f8a8f1qga976j8l53qhmgcf1";
-       libraryHaskellDepends = [
-         array auto-update base bsb-http-chunked bytestring case-insensitive
-         containers ghc-prim hashable http-date http-types http2 iproute
-         network simple-sendfile stm streaming-commons text time-manager
-         unix unix-compat unliftio vault wai word8 x509
-       ];
-       testHaskellDepends = [
-         array async auto-update base bsb-http-chunked bytestring
-         case-insensitive containers directory ghc-prim hashable hspec
-         http-client http-date http-types http2 HUnit iproute network
-         process QuickCheck simple-sendfile stm streaming-commons text time
-         time-manager unix unix-compat unliftio vault wai word8 x509
-       ];
-       benchmarkHaskellDepends = [
-         auto-update base bytestring containers gauge hashable http-date
-         http-types network time-manager unix unix-compat unliftio x509
-       ];
-       description = "A fast, light-weight web server for WAI applications";
-       license = lib.licenses.mit;
-     }) {};
-
-  "warp_3_3_17" = callPackage
-    ({ mkDerivation, array, async, auto-update, base, bsb-http-chunked
-     , bytestring, case-insensitive, containers, directory, gauge
-     , ghc-prim, hashable, hspec, http-client, http-date, http-types
-     , http2, HUnit, iproute, network, process, QuickCheck
-     , simple-sendfile, stm, streaming-commons, text, time, time-manager
-     , unix, unix-compat, unliftio, vault, wai, word8, x509
-     }:
-     mkDerivation {
-       pname = "warp";
        version = "3.3.17";
        sha256 = "0v54ca3wpa79gdyiikwhbv9h8b5vr3d60piq3ndb2v7s7fi1qpm0";
        libraryHaskellDepends = [
···
        ];
        description = "A fast, light-weight web server for WAI applications";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "warp-dynamic" = callPackage
···
     ({ mkDerivation, base, network, systemd, unix, wai, warp }:
      mkDerivation {
        pname = "warp-systemd";
-       version = "0.1.1.0";
-       sha256 = "1gi9xkaa3wi5n2vhmlc7s4zm48l2fakwnd7bw007hzfqi17zz13x";
+       version = "0.2.0.0";
+       sha256 = "114ipqsfvg4bx15n7mnpym8pnj668854s4vdz188awzd0n60hf8z";
        libraryHaskellDepends = [ base network systemd unix wai warp ];
        description = "Socket activation and other systemd integration for the Warp web server (WAI)";
        license = lib.licenses.bsd3;
···
        pname = "windns";
        version = "0.1.0.1";
        sha256 = "016d1cf51jqvhbzlf5kbizv4l4dymradac1420rl47q2k5faczq8";
-       revision = "2";
-       editedCabalFile = "129amxjf05b6vi9ln8ijxry062av8bmv3wnng0jis71fyw8ldr0p";
+       revision = "3";
+       editedCabalFile = "10jidn34rmv0amhw3c24pkl64q5xl3c6l9yqwcvqdn0vkbd0bf2v";
        libraryHaskellDepends = [ base bytestring deepseq ];
        librarySystemDepends = [ dnsapi ];
        description = "Domain Name Service (DNS) lookup via the <windns.h>/dnsapi.dll standard library";
···
      }:
      mkDerivation {
        pname = "xlsx";
-       version = "0.8.3";
-       sha256 = "11g6bfir21wgafnkzzx26r6mz8m39isaz2yqw92k5ymdb1qhs95q";
-       libraryHaskellDepends = [
-         attoparsec base base64-bytestring binary-search bytestring conduit
-         containers data-default deepseq errors extra filepath lens mtl
-         network-uri old-locale safe text time transformers vector xeno
-         xml-conduit zip-archive zlib
-       ];
-       testHaskellDepends = [
-         base bytestring containers Diff groom lens mtl raw-strings-qq
-         smallcheck tasty tasty-hunit tasty-smallcheck text time vector
-         xml-conduit
-       ];
-       benchmarkHaskellDepends = [ base bytestring criterion ];
-       description = "Simple and incomplete Excel file parser/writer";
-       license = lib.licenses.mit;
-     }) {};
-
-  "xlsx_0_8_4" = callPackage
-    ({ mkDerivation, attoparsec, base, base64-bytestring, binary-search
-     , bytestring, conduit, containers, criterion, data-default, deepseq
-     , Diff, errors, extra, filepath, groom, lens, mtl, network-uri
-     , old-locale, raw-strings-qq, safe, smallcheck, tasty, tasty-hunit
-     , tasty-smallcheck, text, time, transformers, vector, xeno
-     , xml-conduit, zip-archive, zlib
-     }:
-     mkDerivation {
-       pname = "xlsx";
        version = "0.8.4";
        sha256 = "0xmz9qpqyz2gwlrjsy2m79s4xswb6lz7fbvybd4awg5vy0y6pl41";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base bytestring criterion ];
        description = "Simple and incomplete Excel file parser/writer";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "xlsx-tabular" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod";
-       version = "1.6.1.1";
-       sha256 = "1iiaixd1xrqjcvknl9g3yvr26nbpfa2amh2ayfxmnpjlxvdhfnyn";
-       libraryHaskellDepends = [
-         aeson base bytestring conduit data-default-class directory
-         fast-logger file-embed monad-logger shakespeare streaming-commons
-         template-haskell text unix unordered-containers wai wai-extra
-         wai-logger warp yaml yesod-core yesod-form yesod-persistent
-       ];
-       description = "Creation of type-safe, RESTful web applications";
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod_1_6_1_2" = callPackage
-    ({ mkDerivation, aeson, base, bytestring, conduit
-     , data-default-class, directory, fast-logger, file-embed
-     , monad-logger, shakespeare, streaming-commons, template-haskell
-     , text, unix, unordered-containers, wai, wai-extra, wai-logger
-     , warp, yaml, yesod-core, yesod-form, yesod-persistent
-     }:
-     mkDerivation {
-       pname = "yesod";
        version = "1.6.1.2";
        sha256 = "13r0ispprj41kgn2rkc7zhy1rxfmgpjbmdlnys15h0ihhh3zhw2f";
        libraryHaskellDepends = [
···
        ];
        description = "Creation of type-safe, RESTful web applications";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-alerts" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod-core";
-       version = "1.6.20.1";
-       sha256 = "1y24sn30fm7bjq9rfv4lclz3vraaac9qbd2xgz949agm2irjwg4p";
-       libraryHaskellDepends = [
-         aeson auto-update base blaze-html blaze-markup bytestring
-         case-insensitive cereal clientsession conduit conduit-extra
-         containers cookie deepseq entropy fast-logger http-types memory
-         monad-logger mtl parsec path-pieces primitive random resourcet
-       pname = "javascript-bridge";
-         unliftio unordered-containers vector wai wai-extra wai-logger warp
-         word8
-       ];
-       testHaskellDepends = [
-         async base bytestring clientsession conduit conduit-extra
-         containers cookie hspec hspec-expectations http-types HUnit network
-         path-pieces random resourcet shakespeare streaming-commons
-         template-haskell text transformers unliftio wai wai-extra warp
-       ];
-       benchmarkHaskellDepends = [
-         base blaze-html bytestring gauge shakespeare text
-       ];
-       description = "Creation of type-safe, RESTful web applications";
-       license = lib.licenses.mit;
-     }) {};
-
-  "yesod-core_1_6_20_2" = callPackage
-    ({ mkDerivation, aeson, async, auto-update, base, blaze-html
-     , blaze-markup, bytestring, case-insensitive, cereal, clientsession
-     , conduit, conduit-extra, containers, cookie, deepseq, entropy
-     , fast-logger, gauge, hspec, hspec-expectations, http-types, HUnit
-     , memory, monad-logger, mtl, network, parsec, path-pieces
-     , primitive, random, resourcet, shakespeare, streaming-commons
-     , template-haskell, text, time, transformers, unix-compat, unliftio
-     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
-     , word8
-     }:
-     mkDerivation {
-       pname = "yesod-core";
        version = "1.6.20.2";
        sha256 = "184j6nslwrfxw4zmsxlii6gs1z0h350kgmbnr5y3wwk3n4dsdzyb";
        libraryHaskellDepends = [
···
        ];
        description = "Creation of type-safe, RESTful web applications";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "yesod-crud" = callPackage
···
      }:
      mkDerivation {
        pname = "yesod-form-bootstrap4";
-       version = "3.0.0";
-       sha256 = "19lnn0xw13gcvp2jzw01pq47jfhxgwm1c84px3xm582p9vqyygx7";
+       version = "3.0.1";
+       sha256 = "0yf4b14y8b5066lwdr7r2ayiavsnkar3s8q984yb1nrz5956f7qd";
        libraryHaskellDepends = [
          base blaze-html blaze-markup shakespeare text yesod-core yesod-form
        ];
···
      }) {};
 
   "yesod-recaptcha2" = callPackage
-    ({ mkDerivation, aeson, base, classy-prelude, http-conduit
+    ({ mkDerivation, aeson, base, http-conduit, string-transform, text
      , yesod-core, yesod-form
      }:
      mkDerivation {
        pname = "yesod-recaptcha2";
-       version = "1.0.1";
-       sha256 = "0mf9n016jxiq6ayq80fv9zldfjh9yskcq8p9grfr0dl8njj88yn5";
+       version = "1.0.2";
+       sha256 = "0ql05yxq3k8sywncaz3cf3xaihf4pd0ijn139ms8snyps36k6l8h";
        libraryHaskellDepends = [
-         aeson base classy-prelude http-conduit yesod-core yesod-form
+         aeson base http-conduit string-transform text yesod-core yesod-form
        ];
        description = "yesod recaptcha2";
        license = lib.licenses.mit;

pkgs/development/haskell-modules/make-package-set.nix

···
         #       );
         #     });
         #   in
-        #   hpkgs.shellFor {
+        #   haskellPkgs.shellFor {
         #     packages = p: [ p.foo ];
         #     genericBuilderArgsModifier = args: args // { doCheck = true; doBenchmark = true };
         #   }

pkgs/development/libraries/agda/standard-library/default.nix

···
 
 mkDerivation rec {
   pname = "standard-library";
-  version = "1.6";
+  version = "1.7";
 
   src = fetchFromGitHub {
     repo = "agda-stdlib";
     owner = "agda";
     rev = "v${version}";
-    sha256 = "1smvnid7r1mc4lp34pfrbzgzrcl0gmw0dlkga8z0r3g2zhj98lz1";
+    sha256 = "14h3jprm6924g9576v25axn9v6xnip354hvpzlcqsc5qqyj7zzjs";
   };
 
   nativeBuildInputs = [ (ghcWithPackages (self : [ self.filemanip ])) ];
···
     runhaskell GenerateEverything.hs
     # We will only build/consider Everything.agda, in particular we don't want Everything*.agda
     # do be copied to the store.
-    rm EverythingSafe.agda EverythingSafeGuardedness.agda EverythingSafeSizedTypes.agda
+    rm EverythingSafe.agda
   '';
 
   passthru.tests = { inherit (nixosTests) agda; };

pkgs/development/libraries/argp-standalone/default.nix

···
 
   patchFlags = lib.optional stdenv.hostPlatform.isDarwin "-p0";
 
-  preConfigure = lib.optionalString stdenv.hostPlatform.isLinux "export CFLAGS='-fgnu89-inline'";
+  # For currently unknown reason, `-fPIC` has to be passed explicitly, otherwise
+  # downstream software like `elfutils` will get `recompile errors like:
+  #     libargp.a(argp-help.o): relocation R_X86_64_PC32 against symbol `program_invocation_short_name' can not be used when making a shared object; recompile with -fPIC
+  # It seems that nixpkgs's on-by-default `-fPIC` is not in effect here.
+  preConfigure = lib.optionalString stdenv.hostPlatform.isLinux "export CFLAGS='-fgnu89-inline -fPIC'";
 
   postInstall = ''
     mkdir -p $out/lib $out/include

pkgs/misc/vscode-extensions/default.nix

···
         mktplcRef = {
           name = "vscode-tailwindcss";
           publisher = "bradlc";
-          version = "0.6.6";
-          sha256 = "sha256-CRd+caKHFOXBnePr/LqNkzw0kRGYvNSkf4ecNgedpdA=";
+          version = "0.6.13";
+          sha256 = "098vrm28b7jpzk0c2d0cgxvdw4jsswzf18cx1m9jwsm1j40fp5f4";
         };
         meta = with lib; {
           license = licenses.mpl20;
···
         mktplcRef = {
           name = "bracket-pair-colorizer-2";
           publisher = "CoenraadS";
-          version = "0.2.0";
-          sha256 = "0nppgfbmw0d089rka9cqs3sbd5260dhhiipmjfga3nar9vp87slh";
+          version = "0.2.1";
+          sha256 = "0bfvzs4ac537zqhnqaa38jf4lhiy1fmqcv6lq89nnx8k963380z7";
         };
         meta = with lib; {
           license = licenses.mit;
···
         mktplcRef = {
           name = "vscode-great-icons";
           publisher = "emmanuelbeziat";
-          version = "2.1.64";
-          sha256 = "sha256-qsL1vWiEAYeWkMDNSrr1yzg0QxroEQQeznoDL3Ujy/o=";
+          version = "2.1.79";
+          sha256 = "1cr1pxgxlfr643sfxbcr2xd53s1dnzcpacjj0ffkgizfda2psy78";
         };
         meta = with lib; {
           license = licenses.mit;
···
         mktplcRef = {
           name = "prettier-vscode";
           publisher = "esbenp";
-          version = "5.8.0";
-          sha256 = "0h7wc4pffyq1i8vpj4a5az02g2x04y7y1chilmcfmzg2w42xpby7";
+          version = "8.0.1";
+          sha256 = "017lqpmzjxq5f1zr49akcm9gfki0qq8v7pj7gks6a3szjdx16mnl";
         };
       };
 
···
         mktplcRef = {
           name = "svg";
           publisher = "jock";
-          version = "1.4.4";
-          sha256 = "0kn2ic7pgbd4rbvzpsxfwyiwxa1iy92l0h3jsppxc8gk8xbqm2nc";
+          version = "1.4.7";
+          sha256 = "04ghqg4s7g7yylmvbxzwzpnyy4zin2bwlgvflh18m77w4j0ckpiq";
         };
         meta = with lib; {
           license = licenses.mit;
···
         mktplcRef = {
           name = "magit";
           publisher = "kahole";
-          version = "0.6.15";
-          sha256 = "sha256-fRXm70FXnHduoywI4YC9ya6/J7wyd6EBzbnrcijBIbA=";
+          version = "0.6.18";
+          sha256 = "0sqzz5bbqqg60aypvwxcqnxrr72gmwfj9sv0amgkyaf60zg5sf7w";
         };
         meta = {
           license = lib.licenses.mit;
···
         mktplcRef = {
           name = "crates";
           publisher = "serayuzgur";
-          version = "0.5.3";
-          sha256 = "1xk7ayv590hsm3scqpyh6962kvgdlinnpkx0vapr7vs4y08dx72f";
+          version = "0.5.9";
+          sha256 = "0l26pyvw7n3bszf97yx6qps72acq112akg3q4jq5mvlibng1nwk0";
         };
         meta = {
           license = lib.licenses.mit;
···
         mktplcRef = {
           name = "svelte-vscode";
           publisher = "svelte";
-          version = "105.0.0";
-          sha256 = "sha256-my3RzwUW5MnajAbEnqxtrIR701XH+AKYLbnKD7ivASE=";
+          version = "105.3.0";
+          sha256 = "11plqsj3c4dv0xg2d76pxrcn382qr9wbh1lhln2x8mzv840icvwr";
         };
         meta = {
           license = lib.licenses.mit;
···
         mktplcRef = {
           name = "shellcheck";
           publisher = "timonwong";
-          version = "0.14.1";
-          sha256 = "sha256-X3ihMxANcqNLWl9oTZjCgwRt1uBsSN2BmC2D4dPRFLE=";
+          version = "0.14.4";
+          sha256 = "05z314sw9nqym3qlj7dcwm0fz1hb23xppzqn3nr2wcj17hs8zz4m";
         };
         nativeBuildInputs = [ jq ];
         postInstall = ''
···
         mktplcRef = {
           name = "vim";
           publisher = "vscodevim";
-          version = "1.11.3";
-          sha256 = "1smzsgcrkhghbnpy51gp28kh74l7y4s2m8pfxabb4ffb751254j0";
+          version = "1.21.5";
+          sha256 = "1v1xs1wcigisr6xip31i02cfryxrb157sla34y59pwlnhc5x1gny";
         };
         meta = {
           license = lib.licenses.mit;

pkgs/misc/vscode-extensions/update_installed_exts.sh

···
 if [ $# -ne 0 ]; then
     CODE=$1
 else
-    CODE=$(command -v code)
+    CODE=$(command -v code || command -v codium)
 fi
 
 if [ -z "$CODE" ]; then

pkgs/os-specific/linux/lxcfs/default.nix

···
 with lib;
 stdenv.mkDerivation rec {
   pname = "lxcfs";
-  version = "4.0.8";
+  version = "4.0.9";
 
   src = fetchFromGitHub {
     owner = "lxc";
     repo = "lxcfs";
     rev = "lxcfs-${version}";
-    sha256 = "sha256-8Tack2gM3AU3coGXs5hEbAaBCo5ss1sGUFFEjZDn5Lg=";
+    sha256 = "0zx58lair8hwi4bxm5h7i8n1j5fcdgw5cr6f4wk9qhks0sr5dip5";
   };
 
   nativeBuildInputs = [ pkg-config help2man autoreconfHook makeWrapper ];

pkgs/test/haskell/default.nix

···
   shellFor = callPackage ./shellFor { };
   documentationTarball = callPackage ./documentationTarball { };
   setBuildTarget = callPackage ./setBuildTarget { };
+  writers = callPackage ./writers { };
 }

pkgs/test/haskell/documentationTarball/default.nix

···
   drv = haskellPackages.vector;
   docs = pkgs.haskell.lib.documentationTarball drv;
 
-in pkgs.runCommand "test haskell.lib.documentationTarball" { } ''
+in pkgs.runCommand "test haskell.lib.documentationTarball" {
+  meta = {
+    inherit (docs.meta) platforms;
+  };
+} ''
   tar xvzf "${docs}/${drv.name}-docs.tar.gz"
 
   # Check for Haddock html

pkgs/test/haskell/setBuildTarget/default.nix

···
          fi
      '';
 
-in pkgs.runCommand "test haskell.lib.setBuildTarget" {} ''
+in
+pkgs.runCommand "test haskell.lib.setBuildTarget" {
+  meta = {
+    inherit (drv.meta) platforms;
+  };
+} ''
   ${test "foo" "bar"}
   ${test "bar" "foo"}
   touch "$out"

pkgs/test/haskell/shellFor/default.nix

···
       additionalMaintainers = with lib.maintainers; [ cdepillabout ];
       allMaintainers = oldMaintainers ++ additionalMaintainers;
     in
-    oldMeta // { maintainers = allMaintainers; };
+    oldMeta // {
+      maintainers = allMaintainers;
+      inherit (cabal-install.meta) platforms;
+    };
 })

pkgs/test/haskell/writers/default.nix

···
+# Wrap only the haskell-related tests from tests.writers
+# in their own derivation for Hydra CI in the haskell-updates
+# jobset. Can presumably removed as soon as tests.writers is
+# always green on darwin as well:
+# https://github.com/NixOS/nixpkgs/issues/126182
+{ runCommand, tests }:
+
+let
+  inherit (tests.writers)
+    writeTest
+    bin
+    simple
+    path
+    ;
+in
+
+runCommand "test-haskell-writers" {
+  meta = {
+    inherit (tests.writers.meta) platforms;
+  };
+} ''
+  ${writeTest "success" "test-haskell-bin-writer" "${bin.haskell}/bin/${bin.haskell.name}"}
+  ${writeTest "success" "test-haskell-simple-writer" simple.haskell}
+  ${writeTest "success" "test-haskell-path-writer" path.haskell}
+  touch $out
+''

pkgs/top-level/haskell-packages.nix

···
 
     ghc884 = callPackage ../development/compilers/ghc/8.8.4.nix {
       # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
-      bootPkgs = if stdenv.isAarch64 then
+      # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them
+      bootPkgs = if stdenv.isAarch64 || stdenv.targetPlatform.isMusl then
           packages.ghc8102BinaryMinimal
         else
           packages.ghc865Binary;
···
     };
     ghc8104 = callPackage ../development/compilers/ghc/8.10.4.nix {
       # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
-      bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then
+      # Musl bindists do not exist for ghc 8.6.5, so we use 8.10.* for them
+      bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 || stdenv.targetPlatform.isMusl then
           packages.ghc8102BinaryMinimal
         else
           packages.ghc865Binary;

pkgs/top-level/release-haskell.nix

···
       haskellPackages = packagePlatforms pkgs.haskellPackages;
       haskell.compiler = packagePlatforms pkgs.haskell.compiler;
 
-      tests = let
-        testPlatforms = packagePlatforms pkgs.tests;
-      in {
-        haskell = testPlatforms.haskell;
-        writers = testPlatforms.writers;
+      tests.haskell = packagePlatforms pkgs.tests.haskell;
+
+      pkgsMusl.haskell.compiler = packagePlatforms pkgs.pkgsMusl.haskell.compiler // {
+        # remove musl ghc865Binary since it is known to be broken and
+        # causes an evaluation error on darwin.
+        # TODO: remove ghc865Binary altogether and use ghc8102Binary
+        ghc865Binary = {};
       };
 
       # test some statically linked packages to catch regressions
···
         };
         constituents = accumulateDerivations [
           # haskell specific tests
-          jobs.tests.haskell
-          # writeHaskell and writeHaskellBin
-          # TODO: writeHaskell currently fails on darwin
-          jobs.tests.writers.x86_64-linux
-          jobs.tests.writers.aarch64-linux
+          #
+          # TODO: The writers test appears to be failing on darwin for unknown
+          # reasons.  See https://github.com/NixOS/nixpkgs/pull/129606#issuecomment-881307871.
+          (lib.recursiveUpdate jobs.tests.haskell { writers.x86_64-darwin = null; })
           # important top-level packages
           jobs.cabal-install
           jobs.cabal2nix
···
           jobs.pkgsStatic.haskell.packages.integer-simple.ghc8104.lens.aarch64-linux
           jobs.pkgsStatic.haskell.packages.integer-simple.ghc8104.random.x86_64-linux
           jobs.pkgsStatic.haskell.packages.integer-simple.ghc8104.random.aarch64-linux
+        ];
+      };
+      muslGHCs = pkgs.releaseTools.aggregate {
+        name = "haskell-pkgsMusl-ghcs";
+        meta = {
+          description = "GHCs built with musl";
+          maintainers = with lib.maintainers; [
+            nh2
+          ];
+        };
+        constituents = accumulateDerivations [
+          jobs.pkgsMusl.haskell.compiler.ghc8102Binary
+          jobs.pkgsMusl.haskell.compiler.ghc884
+          jobs.pkgsMusl.haskell.compiler.ghc8104
+          jobs.pkgsMusl.haskell.compiler.ghc901
         ];
       };
     }