Merge pull request #192273 from NixOS/haskell-updates

haskellPackages: update stackage and hackage

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "e456824564bb5457549a70dc03c7ae00b3dfaec3",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e456824564bb5457549a70dc03c7ae00b3dfaec3.tar.gz",
-  "sha256": "0kvjhghjhs5b6ldp4yyyy158lqk54aahqqp4n0mm67p7qv09i5xr",
-  "msg": "Update from Hackage at 2022-09-19T12:29:18Z"
+  "commit": "12bd870a1ed095ff74dbe08ef4d5d930821e878d",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/12bd870a1ed095ff74dbe08ef4d5d930821e878d.tar.gz",
+  "sha256": "196pl60xyv4ij1nxz4hv5fhmliisb5dmxl8w1jfl07z22cpd92p5",
+  "msg": "Update from Hackage at 2022-09-21T15:25:15Z"
 }

pkgs/development/compilers/ghc/9.4.2.nix

···
-# Preliminary GHC 9.4.2 expression using the make build system.
-# TODO(@sternenseemann): port to hadrian, so we are prepared for 9.6
-# where make support will be dropped.
+# DO NOT port this expression to hadrian. It is not possible to build a GHC
+# cross compiler with 9.4.* and hadrian.
 { lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages
 
 # build-tools

pkgs/development/compilers/ghc/common-hadrian.nix

···
+{ version
+, rev ? null
+, sha256
+, url ?
+    if rev != null
+    then "https://gitlab.haskell.org/ghc/ghc.git"
+    else "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz"
+
+}:
+
+{ lib
+, stdenv
+, pkgsBuildTarget
+, pkgsHostTarget
+, targetPackages
+
+# build-tools
+, bootPkgs
+, autoconf
+, automake
+, coreutils
+, fetchpatch
+, fetchurl
+, fetchgit
+, perl
+, python3
+, m4
+, sphinx
+, xattr
+, autoSignDarwinBinariesHook
+, bash
+
+, libiconv ? null, ncurses
+, glibcLocales ? null
+
+, # GHC can be built with system libffi or a bundled one.
+  libffi ? null
+
+, useLLVM ? !(stdenv.targetPlatform.isx86
+              || stdenv.targetPlatform.isPower
+              || stdenv.targetPlatform.isSparc
+              || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin))
+, # LLVM is conceptually a run-time-only depedendency, but for
+  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
+  # build-time dependency too.
+  buildTargetLlvmPackages
+, llvmPackages
+
+, # If enabled, GHC will be built with the GPL-free but slightly slower native
+  # bignum backend instead of the faster but GPLed gmp backend.
+  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
+, gmp
+
+, # If enabled, use -fPIC when compiling static libs.
+  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
+
+  # aarch64 outputs otherwise exceed 2GB limit
+, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
+
+, # Whether to build dynamic libs for the standard library (on the target
+  # platform). Static libs are always built.
+  enableShared ? with stdenv.targetPlatform; !isWindows && !useiOSPrebuilt && !isStatic
+
+, # Whether to build terminfo.
+  enableTerminfo ? !stdenv.targetPlatform.isWindows
+
+, # Libdw.c only supports x86_64, i686 and s390x as of 2022-08-04
+  enableDwarf ? (stdenv.targetPlatform.isx86 ||
+                 (stdenv.targetPlatform.isS390 && stdenv.targetPlatform.is64bit)) &&
+                lib.meta.availableOn stdenv.hostPlatform elfutils &&
+                lib.meta.availableOn stdenv.targetPlatform elfutils &&
+                # HACK: elfutils is marked as broken on static platforms
+                # which availableOn can't tell.
+                !stdenv.targetPlatform.isStatic &&
+                !stdenv.hostPlatform.isStatic
+, elfutils
+
+, # What flavour to build. Flavour string may contain a flavour and flavour
+  # transformers as accepted by hadrian.
+  ghcFlavour ?
+    let
+      # TODO(@sternenseemann): does using the static flavour make sense?
+      baseFlavour = "release";
+      # Note: in case hadrian's flavour transformers cease being expressive
+      # enough for us, we'll need to resort to defining a "nixpkgs" flavour
+      # in hadrianUserSettings and using that instead.
+      transformers =
+        lib.optionals useLLVM [ "llvm" ]
+        ++ lib.optionals (!enableShared) [
+          "fully_static"
+          "no_dynamic_ghc"
+        ]
+        ++ lib.optionals (!enableProfiledLibs) [ "no_profiled_libs" ]
+        # While split sections are now enabled by default in ghc 8.8 for windows,
+        # they seem to lead to `too many sections` errors when building base for
+        # profiling.
+        ++ lib.optionals (!stdenv.targetPlatform.isWindows) [ "split_sections" ]
+      ;
+    in
+      baseFlavour + lib.concatMapStrings (t: "+${t}") transformers
+
+, # Contents of the UserSettings.hs file to use when compiling hadrian.
+  hadrianUserSettings ? ''
+    module UserSettings (
+        userFlavours, userPackages, userDefaultFlavour,
+        verboseCommand, buildProgressColour, successColour, finalStage
+        ) where
+
+    import Flavour.Type
+    import Expression
+    import {-# SOURCE #-} Settings.Default
+
+    -- no way to set this via the command line
+    finalStage :: Stage
+    finalStage = ${
+      if stdenv.hostPlatform == stdenv.targetPlatform
+      then "Stage2" # native compiler
+      else "Stage1" # cross compiler
+    }
+
+    userDefaultFlavour :: String
+    userDefaultFlavour = "release"
+
+    userFlavours :: [Flavour]
+    userFlavours = []
+
+    -- Disable Colours
+    buildProgressColour :: BuildProgressColour
+    buildProgressColour = mkBuildProgressColour (Dull Reset)
+    successColour :: SuccessColour
+    successColour = mkSuccessColour (Dull Reset)
+
+    -- taken from src/UserSettings.hs unchanged, need to be there
+    userPackages :: [Package]
+    userPackages = []
+    verboseCommand :: Predicate
+    verboseCommand = do
+        verbosity <- expr getVerbosity
+        return $ verbosity >= Verbose
+  ''
+
+, #  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
+  )
+
+, # Whether to disable the large address space allocator
+  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
+  disableLargeAddressSpace ? stdenv.targetPlatform.isiOS
+}:
+
+assert !enableNativeBignum -> gmp != null;
+
+assert stdenv.hostPlatform == stdenv.targetPlatform || throw ''
+  hadrian doesn't support building an installable GHC cross-compiler at the moment.
+  Consider using GHC 9.4.2 or lower which support this via the make build system.
+  See also: https://gitlab.haskell.org/ghc/ghc/-/issues/22090
+'';
+
+let
+  src = (if rev != null then fetchgit else fetchurl) ({
+    inherit url sha256;
+  } // lib.optionalAttrs (rev != null) {
+    inherit rev;
+  });
+
+  inherit (stdenv) buildPlatform hostPlatform targetPlatform;
+
+  inherit (bootPkgs) ghc;
+
+  # TODO(@Ericson2314) Make unconditional
+  targetPrefix = lib.optionalString
+    (targetPlatform != hostPlatform)
+    "${targetPlatform.config}-";
+
+  hadrianSettings =
+    # -fexternal-dynamic-refs apparently (because it's not clear from the
+    # documentation) makes the GHC RTS able to load static libraries, which may
+    # be needed for TemplateHaskell. This solution was described in
+    # https://www.tweag.io/blog/2020-09-30-bazel-static-haskell
+    lib.optionals enableRelocatedStaticLibs [
+      "*.*.rts.*.opts += -fPIC -fexternal-dynamic-refs"
+      "*.*.ghc.*.opts += -fPIC -fexternal-dynamic-refs"
+    ]
+    ++ lib.optionals targetPlatform.useAndroidPrebuilt [
+      "*.*.ghc.c.opts += -optc-std=gnu99"
+    ];
+
+  # GHC's build system hadrian built from the GHC-to-build's source tree
+  # using our bootstrap GHC.
+  hadrian = bootPkgs.callPackage ../../tools/haskell/hadrian {
+    ghcSrc = src;
+    ghcVersion = version;
+    userSettings = hadrianUserSettings;
+  };
+
+  # Splicer will pull out correct variations
+  libDeps = platform: lib.optional enableTerminfo ncurses
+    ++ [libffi]
+    # Bindist configure script fails w/o elfutils in linker search path
+    # https://gitlab.haskell.org/ghc/ghc/-/issues/22081
+    ++ lib.optional enableDwarf elfutils
+    ++ lib.optional (!enableNativeBignum) gmp
+    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
+
+  # TODO(@sternenseemann): is buildTarget LLVM unnecessary?
+  # GHC doesn't seem to have {LLC,OPT}_HOST
+  toolsForTarget = [
+    pkgsBuildTarget.targetPackages.stdenv.cc
+  ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;
+
+  targetCC = builtins.head toolsForTarget;
+
+  # Sometimes we have to dispatch between the bintools wrapper and the unwrapped
+  # derivation for certain tools depending on the platform.
+  bintoolsFor = {
+    # GHC needs install_name_tool on all darwin platforms. On aarch64-darwin it is
+    # part of the bintools wrapper (due to codesigning requirements), but not on
+    # x86_64-darwin.
+    install_name_tool =
+      if stdenv.targetPlatform.isAarch64
+      then targetCC.bintools
+      else targetCC.bintools.bintools;
+    # Same goes for strip.
+    strip =
+      # TODO(@sternenseemann): also use wrapper if linker == "bfd" or "gold"
+      if stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin
+      then targetCC.bintools
+      else targetCC.bintools.bintools;
+  };
+
+  # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
+  # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
+  # see #84670 and #49071 for more background.
+  useLdGold = targetPlatform.linker == "gold" ||
+    (targetPlatform.linker == "bfd" && (targetCC.bintools.bintools.hasGold or false) && !targetPlatform.isMusl);
+
+  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
+  variantSuffix = lib.concatStrings [
+    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
+    (lib.optionalString enableNativeBignum "-native-bignum")
+  ];
+
+in
+
+# C compiler, bintools and LLVM are used at build time, but will also leak into
+# the resulting GHC's settings file and used at runtime. This means that we are
+# currently only able to build GHC if hostPlatform == buildPlatform.
+assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc;
+assert buildTargetLlvmPackages.llvm == llvmPackages.llvm;
+assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;
+
+stdenv.mkDerivation ({
+  pname = "${targetPrefix}ghc${variantSuffix}";
+  inherit version;
+
+  inherit src;
+
+  enableParallelBuilding = true;
+
+  postPatch = ''
+    patchShebangs --build .
+  '';
+
+  # GHC needs the locale configured during the Haddock phase.
+  LANG = "en_US.UTF-8";
+
+  # GHC is a bit confused on its cross terminology.
+  # TODO(@sternenseemann): investigate coreutils dependencies and pass absolute paths
+  preConfigure = ''
+    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
+      export "''${env#TARGET_}=''${!env}"
+    done
+    # GHC is a bit confused on its cross terminology, as these would normally be
+    # the *host* tools.
+    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
+    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
+    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
+    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
+    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
+    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
+    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
+    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
+    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
+    export STRIP="${bintoolsFor.strip}/bin/${bintoolsFor.strip.targetPrefix}strip"
+  '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") ''
+    export OTOOL="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}otool"
+    export INSTALL_NAME_TOOL="${bintoolsFor.install_name_tool}/bin/${bintoolsFor.install_name_tool.targetPrefix}install_name_tool"
+  '' + lib.optionalString useLLVM ''
+    export LLC="${lib.getBin buildTargetLlvmPackages.llvm}/bin/llc"
+    export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt"
+  '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) ''
+    # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm
+    export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang"
+  '' +
+  lib.optionalString (stdenv.isLinux && hostPlatform.libc == "glibc") ''
+    export LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"
+  '' + lib.optionalString (!stdenv.isDarwin) ''
+    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
+  '' + lib.optionalString stdenv.isDarwin ''
+    export NIX_LDFLAGS+=" -no_dtrace_dof"
+
+    # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7
+    export XATTR=${lib.getBin xattr}/bin/xattr
+  ''
+  # If we are not using release tarballs, some files need to be generated using
+  # the boot script.
+  + lib.optionalString (rev != null) ''
+    echo ${version} > VERSION
+    echo ${rev} > GIT_COMMIT_ID
+    ./boot
+  ''
+  + lib.optionalString targetPlatform.useAndroidPrebuilt ''
+    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
+  '' + lib.optionalString targetPlatform.isMusl ''
+      echo "patching llvm-targets for musl targets..."
+      echo "Cloning these existing '*-linux-gnu*' targets:"
+      grep linux-gnu llvm-targets | sed 's/^/  /'
+      echo "(go go gadget sed)"
+      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
+      echo "llvm-targets now contains these '*-linux-musl*' targets:"
+      grep linux-musl llvm-targets | sed 's/^/  /'
+
+      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
+      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
+      for x in configure aclocal.m4; do
+        substituteInPlace $x \
+          --replace '*-android*|*-gnueabi*)' \
+                    '*-android*|*-gnueabi*|*-musleabi*)'
+      done
+  ''
+  # Create bash array hadrianFlagsArray for use in buildPhase. Do it in
+  # preConfigure, so overrideAttrs can be used to modify it effectively.
+  # hadrianSettings are passed via the command line so they are more visible
+  # in the build log.
+  + ''
+    hadrianFlagsArray=(
+      "-j$NIX_BUILD_CORES"
+      ${lib.escapeShellArgs hadrianSettings}
+    )
+  '';
+
+  # TODO(@Ericson2314): Always pass "--target" and always prefix.
+  configurePlatforms = [ "build" "host" ]
+    ++ lib.optional (targetPlatform != hostPlatform) "target";
+
+  # `--with` flags for libraries needed for RTS linker
+  configureFlags = [
+    "--datadir=$doc/share/doc/ghc"
+    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
+  ] ++ lib.optionals (libffi != null) [
+    "--with-system-libffi"
+    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
+    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
+  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [
+    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
+    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
+  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
+    "--with-iconv-includes=${libiconv}/include"
+    "--with-iconv-libraries=${libiconv}/lib"
+  ] ++ lib.optionals (targetPlatform != hostPlatform) [
+    "--enable-bootstrap-with-devel-snapshot"
+  ] ++ lib.optionals useLdGold [
+    "CFLAGS=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
+    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
+  ] ++ lib.optionals (disableLargeAddressSpace) [
+    "--disable-large-address-space"
+  ] ++ lib.optionals enableDwarf [
+    "--enable-dwarf-unwind"
+    "--with-libdw-includes=${lib.getDev elfutils}/include"
+    "--with-libdw-libraries=${lib.getLib elfutils}/lib"
+  ];
+
+  # Make sure we never relax`$PATH` and hooks support for compatibility.
+  strictDeps = true;
+
+  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
+  dontAddExtraLibs = true;
+
+  nativeBuildInputs = [
+    perl ghc hadrian bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
+  ] ++ lib.optionals (rev != null) [
+    # We need to execute the boot script
+    autoconf automake m4 python3
+  ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [
+    autoSignDarwinBinariesHook
+  ] ++ lib.optionals enableDocs [
+    sphinx
+  ];
+
+  # For building runtime libs
+  depsBuildTarget = toolsForTarget;
+
+  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
+
+  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
+  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
+
+  hadrianFlags = [
+    "--flavour=${ghcFlavour}"
+    "--bignum=${if enableNativeBignum then "native" else "gmp"}"
+    "--docs=${if enableDocs then "no-sphinx-pdfs" else "no-sphinx"}"
+  ];
+
+  buildPhase = ''
+    runHook preBuild
+
+    # hadrianFlagsArray is created in preConfigure
+    echo "hadrianFlags: $hadrianFlags ''${hadrianFlagsArray}"
+
+    # We need to go via the bindist for installing
+    hadrian $hadrianFlags "''${hadrianFlagsArray}" binary-dist-dir
+
+    runHook postBuild
+  '';
+
+  # required, because otherwise all symbols from HSffi.o are stripped, and
+  # that in turn causes GHCi to abort
+  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
+
+  checkTarget = "test";
+
+  hardeningDisable =
+    [ "format" ]
+    # In nixpkgs, musl based builds currently enable `pie` hardening by default
+    # (see `defaultHardeningFlags` in `make-derivation.nix`).
+    # But GHC cannot currently produce outputs that are ready for `-pie` linking.
+    # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear.
+    # See:
+    # * https://github.com/NixOS/nixpkgs/issues/129247
+    # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580
+    ++ lib.optional stdenv.targetPlatform.isMusl "pie";
+
+  # big-parallel allows us to build with more than 2 cores on
+  # Hydra which already warrants a significant speedup
+  requiredSystemFeatures = [ "big-parallel" ];
+
+  outputs = [ "out" "doc" ];
+
+  # We need to configure the bindist *again* before installing
+  # https://gitlab.haskell.org/ghc/ghc/-/issues/22058
+  # TODO(@sternenseemann): it would be nice if the bindist could be an intermediate
+  # derivation, but since it is > 2GB even on x86_64-linux, not a good idea?
+  preInstall = ''
+    pushd _build/bindist/*
+
+    ./configure $configureFlags "''${configureFlagsArray[@]}"
+  '';
+
+  postInstall = ''
+    # leave bindist directory
+    popd
+
+    # Install the bash completion file.
+    install -Dm 644 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
+  '';
+
+  passthru = {
+    inherit bootPkgs targetPrefix;
+
+    inherit llvmPackages;
+    inherit enableShared;
+
+    # Our Cabal compiler name
+    haskellCompilerName = "ghc-${version}";
+
+    # Expose hadrian used for bootstrapping, for debugging purposes
+    inherit hadrian;
+  };
+
+  meta = {
+    homepage = "http://haskell.org/ghc";
+    description = "The Glasgow Haskell Compiler";
+    maintainers = with lib.maintainers; [
+      guibou
+    ] ++ lib.teams.haskell.members;
+    timeout = 24 * 3600;
+    inherit (ghc.meta) license platforms;
+  };
+
+  dontStrip = targetPlatform.useAndroidPrebuilt || targetPlatform.isWasm;
+} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
+  dontPatchELF = true;
+  noAuditTmpdir = true;
+})

pkgs/development/compilers/ghc/head.nix

···
-{ lib, stdenv, pkgsBuildTarget, pkgsHostTarget, targetPackages
-
-# build-tools
-, bootPkgs
-, autoconf, autoreconfHook, automake, coreutils, fetchgit, perl, python3, m4, sphinx
-, xattr, autoSignDarwinBinariesHook
-, bash
-
-, libiconv ? null, ncurses
-
-, # GHC can be built with system libffi or a bundled one.
-  libffi ? null
-
-  # Libdw.c only supports x86_64, i686 and s390x
-, enableDwarf ? (stdenv.targetPlatform.isx86 ||
-                 (stdenv.targetPlatform.isS390 && stdenv.targetPlatform.is64bit)) &&
-                lib.meta.availableOn stdenv.hostPlatform elfutils &&
-                lib.meta.availableOn stdenv.targetPlatform elfutils
-, elfutils # for DWARF support
-
-, useLLVM ? !(stdenv.targetPlatform.isx86
-              || stdenv.targetPlatform.isPower
-              || stdenv.targetPlatform.isSparc
-              || (stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin))
-, # LLVM is conceptually a run-time-only depedendency, but for
-  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
-  # build-time dependency too.
-  buildTargetLlvmPackages, llvmPackages
-
-, # If enabled, GHC will be built with the GPL-free but slightly slower native
-  # bignum backend instead of the faster but GPLed gmp backend.
-  enableNativeBignum ? !(lib.meta.availableOn stdenv.hostPlatform gmp)
-, gmp
-
-, # If enabled, use -fPIC when compiling static libs.
-  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
-
-  # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
-
-, # Whether to build dynamic libs for the standard library (on the target
-  # platform). Static libs are always built.
-  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
-
-, version ? "9.3.20220406"
-, # What flavour to build. An empty string indicates no
-  # specific flavour and falls back to ghc default values.
-  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "perf-cross" else "perf-cross-ncg")
-
-, #  Whether to build sphinx documentation.
-  enableDocs ? (
-    # Docs disabled for musl and cross because it's a large task to keep
-    # all `sphinx` dependencies building in those environments.
-    # `sphinx` pullls in among others:
-    # Ruby, Python, Perl, Rust, OpenGL, Xorg, gtk, LLVM.
-    (stdenv.targetPlatform == stdenv.hostPlatform)
-    && !stdenv.hostPlatform.isMusl
-  )
-
-, enableHaddockProgram ?
-    # Disabled for cross; see note [HADDOCK_DOCS].
-    (stdenv.targetPlatform == stdenv.hostPlatform)
-
-, # Whether to disable the large address space allocator
-  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isiOS
-}:
-
-assert !enableNativeBignum -> gmp != null;
-
-# Cross cannot currently build the `haddock` program for silly reasons,
-# see note [HADDOCK_DOCS].
-assert (stdenv.targetPlatform != stdenv.hostPlatform) -> !enableHaddockProgram;
-
-let
-  inherit (stdenv) buildPlatform hostPlatform targetPlatform;
-
-  inherit (bootPkgs) ghc;
-
-  # TODO(@Ericson2314) Make unconditional
-  targetPrefix = lib.optionalString
-    (targetPlatform != hostPlatform)
-    "${targetPlatform.config}-";
-
-  buildMK = dontStrip: ''
-    BuildFlavour = ${ghcFlavour}
-    ifneq \"\$(BuildFlavour)\" \"\"
-    include mk/flavours/\$(BuildFlavour).mk
-    endif
-    BUILD_SPHINX_HTML = ${if enableDocs then "YES" else "NO"}
-    BUILD_SPHINX_PDF = NO
-  '' +
-  # Note [HADDOCK_DOCS]:
-  # Unfortunately currently `HADDOCK_DOCS` controls both whether the `haddock`
-  # program is built (which we generally always want to have a complete GHC install)
-  # and whether it is run on the GHC sources to generate hyperlinked source code
-  # (which is impossible for cross-compilation); see:
-  # https://gitlab.haskell.org/ghc/ghc/-/issues/20077
-  # This implies that currently a cross-compiled GHC will never have a `haddock`
-  # program, so it can never generate haddocks for any packages.
-  # If this is solved in the future, we'd like to unconditionally
-  # build the haddock program (removing the `enableHaddockProgram` option).
-  ''
-    HADDOCK_DOCS = ${if enableHaddockProgram then "YES" else "NO"}
-    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    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}
-  '' + lib.optionalString dontStrip ''
-    STRIP_CMD = :
-  '' + lib.optionalString (!enableProfiledLibs) ''
-    GhcLibWays = "v dyn"
-  '' + lib.optionalString enableRelocatedStaticLibs ''
-    GhcLibHcOpts += -fPIC
-    GhcRtsHcOpts += -fPIC
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    EXTRA_CC_OPTS += -std=gnu99
-  ''
-  # While split sections are now enabled by default in ghc 8.8 for windows,
-  # they seem to lead to `too many sections` errors when building base for
-  # profiling.
-  + lib.optionalString targetPlatform.isWindows ''
-    SplitSections = NO
-  '';
-
-  # Splicer will pull out correct variations
-  libDeps = platform:
-       [libffi ncurses]
-    ++ lib.optional (!enableNativeBignum) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv
-    ++ lib.optional enableDwarf elfutils;
-
-  # TODO(@sternenseemann): is buildTarget LLVM unnecessary?
-  # GHC doesn't seem to have {LLC,OPT}_HOST
-  toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
-  ] ++ lib.optional useLLVM buildTargetLlvmPackages.llvm;
-
-  targetCC = builtins.head toolsForTarget;
-
-  # Sometimes we have to dispatch between the bintools wrapper and the unwrapped
-  # derivation for certain tools depending on the platform.
-  bintoolsFor = {
-    # GHC needs install_name_tool on all darwin platforms. On aarch64-darwin it is
-    # part of the bintools wrapper (due to codesigning requirements), but not on
-    # x86_64-darwin.
-    install_name_tool =
-      if stdenv.targetPlatform.isAarch64
-      then targetCC.bintools
-      else targetCC.bintools.bintools;
-    # Same goes for strip.
-    strip =
-      # TODO(@sternenseemann): also use wrapper if linker == "bfd" or "gold"
-      if stdenv.targetPlatform.isAarch64 && stdenv.targetPlatform.isDarwin
-      then targetCC.bintools
-      else targetCC.bintools.bintools;
-  };
-
-  # Use gold either following the default, or to avoid the BFD linker due to some bugs / perf issues.
-  # But we cannot avoid BFD when using musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
-  # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.linker == "gold" ||
-    (targetPlatform.linker == "bfd" && (targetCC.bintools.bintools.hasGold or false) && !targetPlatform.isMusl);
-
-  # Makes debugging easier to see which variant is at play in `nix-store -q --tree`.
-  variantSuffix = lib.concatStrings [
-    (lib.optionalString stdenv.hostPlatform.isMusl "-musl")
-    (lib.optionalString enableNativeBignum "-native-bignum")
-  ];
-
-in
-
-# C compiler, bintools and LLVM are used at build time, but will also leak into
-# the resulting GHC's settings file and used at runtime. This means that we are
-# currently only able to build GHC if hostPlatform == buildPlatform.
-assert targetCC == pkgsHostTarget.targetPackages.stdenv.cc;
-assert buildTargetLlvmPackages.llvm == llvmPackages.llvm;
-assert stdenv.targetPlatform.isDarwin -> buildTargetLlvmPackages.clang == llvmPackages.clang;
-
-stdenv.mkDerivation (rec {
-  inherit version;
-  inherit (src) rev;
-  pname = "${targetPrefix}ghc${variantSuffix}";
-
-  src = fetchgit {
-    url = "https://gitlab.haskell.org/ghc/ghc.git/";
-    rev = "c44432db254d2fc960d7864e080cb50e65dfa7c6";
-    sha256 = "0xagijcfcw3a19s6dmh6z7085lvkrakys3lcby4ncq1v0syh507h";
-  };
-
-  enableParallelBuilding = true;
-
-  outputs = [ "out" "doc" ];
-
-  postPatch = "patchShebangs .";
-
-  # GHC is a bit confused on its cross terminology.
-  # TODO(@sternenseemann): investigate coreutils dependencies and pass absolute paths
-  preConfigure = ''
-    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
-      export "''${env#TARGET_}=''${!env}"
-    done
-    # GHC is a bit confused on its cross terminology, as these would normally be
-    # the *host* tools.
-    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}c++"
-    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
-    # and more generally have a faster linker.
-    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
-    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
-    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
-    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
-    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
-    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
-    export STRIP="${bintoolsFor.strip}/bin/${bintoolsFor.strip.targetPrefix}strip"
-  '' + lib.optionalString (stdenv.targetPlatform.linker == "cctools") ''
-    export OTOOL="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}otool"
-    export INSTALL_NAME_TOOL="${bintoolsFor.install_name_tool}/bin/${bintoolsFor.install_name_tool.targetPrefix}install_name_tool"
-  '' + lib.optionalString useLLVM ''
-    export LLC="${lib.getBin buildTargetLlvmPackages.llvm}/bin/llc"
-    export OPT="${lib.getBin buildTargetLlvmPackages.llvm}/bin/opt"
-  '' + lib.optionalString (useLLVM && stdenv.targetPlatform.isDarwin) ''
-    # LLVM backend on Darwin needs clang: https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/codegens.html#llvm-code-generator-fllvm
-    export CLANG="${buildTargetLlvmPackages.clang}/bin/${buildTargetLlvmPackages.clang.targetPrefix}clang"
-  '' + ''
-
-    # otherwise haddock fails when generating the compiler docs
-    export LANG=C.UTF-8
-
-    echo -n "${buildMK dontStrip}" > mk/build.mk
-    echo ${version} > VERSION
-    echo ${src.rev} > GIT_COMMIT_ID
-    ./boot
-    sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
-  '' + lib.optionalString (!stdenv.isDarwin) ''
-    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
-  '' + lib.optionalString stdenv.isDarwin ''
-    export NIX_LDFLAGS+=" -no_dtrace_dof"
-
-    # GHC tries the host xattr /usr/bin/xattr by default which fails since it expects python to be 2.7
-    export XATTR=${lib.getBin xattr}/bin/xattr
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
-  '' + lib.optionalString targetPlatform.isMusl ''
-      echo "patching llvm-targets for musl targets..."
-      echo "Cloning these existing '*-linux-gnu*' targets:"
-      grep linux-gnu llvm-targets | sed 's/^/  /'
-      echo "(go go gadget sed)"
-      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
-      echo "llvm-targets now contains these '*-linux-musl*' targets:"
-      grep linux-musl llvm-targets | sed 's/^/  /'
-
-      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
-      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
-      for x in configure aclocal.m4; do
-        substituteInPlace $x \
-          --replace '*-android*|*-gnueabi*)' \
-                    '*-android*|*-gnueabi*|*-musleabi*)'
-      done
-  '';
-
-  # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ]
-    ++ lib.optional (targetPlatform != hostPlatform) "target";
-
-  # `--with` flags for libraries needed for RTS linker
-  configureFlags = [
-    "--datadir=$doc/share/doc/ghc"
-    "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) [
-    "--with-system-libffi"
-    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
-    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableNativeBignum) [
-    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
-    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
-    "--with-iconv-includes=${libiconv}/include"
-    "--with-iconv-libraries=${libiconv}/lib"
-  ] ++ lib.optionals (targetPlatform != hostPlatform) [
-    "--enable-bootstrap-with-devel-snapshot"
-  ] ++ lib.optionals useLdGold [
-    "CFLAGS=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-  ] ++ lib.optional disableLargeAddressSpace "--disable-large-address-space"
-    ++ lib.optionals enableDwarf [
-    "--enable-dwarf-unwind"
-    "--with-libdw-includes=${lib.getDev elfutils}/include"
-    "--with-libdw-libraries=${lib.getLib elfutils}/lib"
-  ];
-
-  # Make sure we never relax`$PATH` and hooks support for compatibility.
-  strictDeps = true;
-
-  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
-  dontAddExtraLibs = true;
-
-  nativeBuildInputs = [
-    perl autoconf autoreconfHook automake m4 python3
-    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
-  ] ++ lib.optionals (stdenv.isDarwin && stdenv.isAarch64) [
-    autoSignDarwinBinariesHook
-  ] ++ lib.optionals enableDocs [
-    sphinx
-  ];
-
-  # For building runtime libs
-  depsBuildTarget = toolsForTarget;
-
-  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
-
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
-
-  # required, because otherwise all symbols from HSffi.o are stripped, and
-  # that in turn causes GHCi to abort
-  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
-
-  checkTarget = "test";
-
-  hardeningDisable =
-    [ "format" ]
-    # In nixpkgs, musl based builds currently enable `pie` hardening by default
-    # (see `defaultHardeningFlags` in `make-derivation.nix`).
-    # But GHC cannot currently produce outputs that are ready for `-pie` linking.
-    # Thus, disable `pie` hardening, otherwise `recompile with -fPIE` errors appear.
-    # See:
-    # * https://github.com/NixOS/nixpkgs/issues/129247
-    # * https://gitlab.haskell.org/ghc/ghc/-/issues/19580
-    ++ lib.optional stdenv.targetPlatform.isMusl "pie";
-
-  # big-parallel allows us to build with more than 2 cores on
-  # Hydra which already warrants a significant speedup
-  requiredSystemFeatures = [ "big-parallel" ];
-
-  postInstall = ''
-    # Install the bash completion file.
-    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
-  '';
-
-  passthru = {
-    inherit bootPkgs targetPrefix;
-
-    inherit llvmPackages;
-    inherit enableShared;
-
-    # This is used by the haskell builder to query
-    # the presence of the haddock program.
-    hasHaddock = enableHaddockProgram;
-
-    # Our Cabal compiler name
-    haskellCompilerName = "ghc-${version}";
-  };
-
-  meta = {
-    homepage = "http://haskell.org/ghc";
-    description = "The Glasgow Haskell Compiler";
-    maintainers = with lib.maintainers; [
-      guibou
-    ] ++ lib.teams.haskell.members;
-    timeout = 24 * 3600;
-    inherit (ghc.meta) license platforms;
-    # ghcHEAD times out on aarch64-linux on Hydra.
-    hydraPlatforms = builtins.filter (p: p != "aarch64-linux") ghc.meta.platforms;
-  };
-
-  dontStrip = (targetPlatform.useAndroidPrebuilt || targetPlatform.isWasm);
-
-} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt{
-  dontPatchELF = true;
-  noAuditTmpdir = true;
-})
+import ./common-hadrian.nix {
+  version = "9.5.20220921";
+  rev = "2463df2fe21b5b37ecada3df8c6726c534d24590";
+  sha256 = "1k2h4myqbs31fdzw5n4iw0qn44mp7d33kjwrr15ix4r54r8yskzs";
+}

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

···
   # The shipped Setup.hs file is broken.
   csv = overrideCabal (drv: { preCompileBuildDriver = "rm Setup.hs"; }) super.csv;
 
-  # 2022-02-25: Upstream fixes are not released. Remove this override on update.
-  cabal-fmt = assert super.cabal-fmt.version == "0.1.5.1"; lib.pipe super.cabal-fmt [
-    doJailbreak
-    (appendPatch (fetchpatch {
-      url = "https://github.com/phadej/cabal-fmt/commit/842630f70adb5397245109f77dba07662836e964.patch";
-      sha256 = "sha256-s0W/TI3wHA73MFyKKcNBJFHgFAmBDLGbLaIvWbe/Bsg=";
-    }))
-  ];
+  cabal-fmt = doJailbreak (super.cabal-fmt.override {
+    # Needs newer Cabal-syntex version.
+    Cabal-syntax = self.Cabal-syntax_3_8_1_0;
+  });
 
   # Tests require ghc-9.2.
   ema = dontCheck super.ema;

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

···
   - himg
   - hindley-milner
   - hindley-milner-type-check
+  - hinotify-conduit
   - hinquire
   - hinstaller
   - hinter
···
   - ige
   - ignore
   - igraph
+  - ihaskell-charts
+  - ihaskell-diagrams
+  - ihaskell-gnuplot
   - ihaskell-parsec
+  - ihaskell-plot
   - ihaskell-widgets
   - ihp-hsx
   - illuminate
···
   - to-haskell
   - token-bucket
   - tokenify
+  - tokenizer
   - tokenizer-streaming
   - token-limiter
   - token-search

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

···
   - fourmolu == 0.3.0.0                 # 2022-09-21: needed for hls on ghc 8.8
   - ormolu == 0.1.4.1                   # 2022-09-21: needed for hls on ghc 8.8
   - hlint == 3.2.8                      # 2022-09-21: needed for hls on ghc 8.8
+  - hlint == 3.4.1                      # 2022-09-21: needed for hls with ghc-lib-parser 9.2
 
 package-maintainers:
   abbradar:

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

···
-# Stackage LTS 19.23
+# Stackage LTS 19.24
 # This file is auto-generated by
 # maintainers/scripts/haskell/update-stackage.sh
 default-package-overrides:
···
   - bencoding ==0.4.5.4
   - between ==0.11.0.0
   - bibtex ==0.1.0.6
-  - bifunctors ==5.5.12
+  - bifunctors ==5.5.13
   - bimap ==0.4.0
   - bimaps ==0.1.0.2
   - bimap-server ==0.1.0.1
···
   - event-list ==0.1.2
   - eventstore ==1.4.2
   - every ==0.0.1
-  - evm-opcodes ==0.1.1
+  - evm-opcodes ==0.1.2
   - exact-combinatorics ==0.2.0.11
   - exact-pi ==0.5.0.2
   - exception-hierarchy ==0.1.0.6
···
   - ghc-lib ==9.0.2.20211226
   - ghc-lib-parser ==9.0.2.20211226
   - ghc-lib-parser-ex ==9.0.0.6
-  - ghc-parser ==0.2.3.0
+  - ghc-parser ==0.2.4.0
   - ghc-paths ==0.1.0.12
   - ghc-prof ==1.4.1.11
   - ghc-source-gen ==0.4.3.0
···
   - grouped-list ==0.2.3.0
   - groups ==0.5.3
   - gtk2hs-buildtools ==0.13.8.3
-  - gtk-sni-tray ==0.1.8.0
-  - gtk-strut ==0.1.3.1
+  - gtk-sni-tray ==0.1.8.1
+  - gtk-strut ==0.1.3.2
   - guarded-allocation ==0.0.1
   - hackage-cli ==0.0.3.6
   - hackage-db ==2.1.2
···
   - haskell-src ==1.0.4
   - haskell-src-exts ==1.23.1
   - haskell-src-exts-util ==0.2.5
-  - haskell-src-meta ==0.8.10
+  - haskell-src-meta ==0.8.11
   - haskey-btree ==0.3.0.1
   - haskintex ==0.8.0.1
   - haskoin-core ==0.21.2
···
   - has-transformers ==0.1.0.4
   - hasty-hamiltonian ==1.3.4
   - HaTeX ==3.22.3.1
-  - HaXml ==1.25.9
+  - HaXml ==1.25.11
   - haxr ==3000.11.4.1
   - HCodecs ==0.5.2
   - hdaemonize ==0.5.6
···
   - ieee754 ==0.8.0
   - if ==0.1.0.0
   - iff ==0.0.6
-  - ihaskell ==0.10.2.2
+  - ihaskell ==0.10.3.0
   - ihaskell-hvega ==0.5.0.3
   - ihs ==0.1.0.3
   - ilist ==0.4.0.1
···
   - iproute ==1.7.12
   - IPv6Addr ==2.0.5
   - ipynb ==0.2
-  - ipython-kernel ==0.10.2.2
+  - ipython-kernel ==0.10.3.0
   - irc ==0.6.1.0
   - irc-client ==1.1.2.2
   - irc-conduit ==0.3.0.5
···
   - postgresql-binary ==0.12.5
   - postgresql-libpq ==0.9.4.3
   - postgresql-libpq-notify ==0.2.0.0
-  - postgresql-migration ==0.2.1.3
+  - postgresql-migration ==0.2.1.4
   - postgresql-orm ==0.5.1
   - postgresql-query ==3.9.0
   - postgresql-schema ==0.1.14
···
   - PrimitiveArray ==0.10.1.1
   - primitive-extras ==0.10.1.5
   - primitive-offset ==0.2.0.0
-  - primitive-unaligned ==0.1.1.1
+  - primitive-unaligned ==0.1.1.2
   - primitive-unlifted ==0.1.3.1
   - prim-uniq ==0.2
   - print-console-colors ==0.1.0.0
···
   - protocol-buffers-descriptor ==2.4.17
   - protocol-radius ==0.0.1.1
   - protocol-radius-test ==0.1.0.1
-  - proto-lens ==0.7.1.1
+  - proto-lens ==0.7.1.2
   - proto-lens-arbitrary ==0.1.2.11
   - proto-lens-optparse ==0.1.1.9
   - proto-lens-protobuf-types ==0.7.1.2
   - proto-lens-protoc ==0.7.1.1
-  - proto-lens-runtime ==0.7.0.2
+  - proto-lens-runtime ==0.7.0.3
   - proto-lens-setup ==0.4.0.6
   - protolude ==0.3.2
   - proxied ==0.3.1
···
   - sexp-grammar ==2.3.3.1
   - sexpr-parser ==0.2.2.0
   - SHA ==1.6.4.4
-  - shake ==0.19.6
+  - shake ==0.19.7
   - shake-language-c ==0.12.0
   - shake-plus ==0.3.4.0
   - shakespeare ==2.0.30
···
   - svg-tree ==0.6.2.4
   - swagger2 ==2.8.4
   - swish ==0.10.2.0
-  - syb ==0.7.2.1
+  - syb ==0.7.2.2
   - sydtest-discover ==0.0.0.2
   - symbol ==0.2.4
   - symengine ==0.1.2.0
···
   - tdigest ==0.2.1.1
   - teardown ==0.5.0.1
   - telegram-bot-simple ==0.4.5
-  - template-haskell-compat-v0208 ==0.1.9
+  - template-haskell-compat-v0208 ==0.1.9.1
   - temporary ==1.3
   - temporary-rc ==1.2.0.3
   - temporary-resourcet ==0.1.0.1
···
   - text-zipper ==0.11
   - tfp ==1.0.2
   - tf-random ==0.5
-  - th-abstraction ==0.4.4.0
+  - th-abstraction ==0.4.5.0
   - th-bang-compat ==0.0.1.0
   - th-compat ==0.1.4
   - th-constraint-compat ==0.0.1.0
···
   - writer-cps-transformers ==0.5.6.1
   - wss-client ==0.3.0.0
   - wuss ==1.1.19
-  - X11 ==1.10.2
+  - X11 ==1.10.3
   - X11-xft ==0.3.4
   - x11-xim ==0.0.9.0
   - x509 ==1.7.7

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

···
      }:
      mkDerivation {
        pname = "HaXml";
-       version = "1.25.9";
-       sha256 = "0ia27ffpdx59sa4mnyhks2bngrgaahwg150znnvnna30s9ncdfq1";
-       revision = "1";
-       editedCabalFile = "1p6v6ibkfbz4wklayzil9bmwsa0y5zcs9hzvl0qyjcnclpgalh7l";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring containers filepath polyparse pretty random
-       ];
-       executableHaskellDepends = [ base directory polyparse pretty ];
-       description = "Utilities for manipulating XML documents";
-       license = lib.licenses.lgpl21Only;
-     }) {};
-
-  "HaXml_1_25_11" = callPackage
-    ({ mkDerivation, base, bytestring, containers, directory, filepath
-     , polyparse, pretty, random
-     }:
-     mkDerivation {
-       pname = "HaXml";
        version = "1.25.11";
        sha256 = "1l5kmiqvnqzdzz3jyaphy7ckglm6jhn0b10kf47yizv0w496bmjg";
        isLibrary = true;
···
        executableHaskellDepends = [ base directory polyparse pretty ];
        description = "Utilities for manipulating XML documents";
        license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "Hach" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "aeson_2_1_0_0" = callPackage
+  "aeson_2_1_1_0" = callPackage
     ({ mkDerivation, attoparsec, base, base-compat
      , base-compat-batteries, base-orphans, base16-bytestring
      , bytestring, containers, data-fix, deepseq, Diff, directory, dlist
···
      }:
      mkDerivation {
        pname = "aeson";
-       version = "2.1.0.0";
-       sha256 = "151wyyw0ip0f2w4mfxcs58c26rsvhaac7s0yba76gnhnzbskwxha";
-       revision = "2";
-       editedCabalFile = "0yp12cmkj5sz25kxzn6g1fz2d6acbq5rvff5dg2wg5zkjwfkhzqj";
+       version = "2.1.1.0";
+       sha256 = "1bdn4j2jglpxhy3kl3y5pf8dr032qjjfbl8ivjk591fdcy6rgbm3";
        libraryHaskellDepends = [
          attoparsec base base-compat-batteries bytestring containers
          data-fix deepseq dlist generically ghc-prim hashable
···
      }:
      mkDerivation {
        pname = "bifunctors";
-       version = "5.5.12";
-       sha256 = "0pbidsv1w3bvzs8w6sv8g1iqf0l9r1y0b1fmvd67cwlp01r7f1n6";
-       revision = "1";
-       editedCabalFile = "1sf3nbcsbj5m5gw26kv036a1v4zmn91rw7x2iamxwx1ji668a3xy";
-       libraryHaskellDepends = [
-         base base-orphans comonad containers tagged template-haskell
-         th-abstraction transformers
-       ];
-       testHaskellDepends = [
-         base hspec QuickCheck template-haskell transformers
-         transformers-compat
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Bifunctors";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "bifunctors_5_5_13" = callPackage
-    ({ mkDerivation, base, base-orphans, comonad, containers, hspec
-     , hspec-discover, QuickCheck, tagged, template-haskell
-     , th-abstraction, transformers, transformers-compat
-     }:
-     mkDerivation {
-       pname = "bifunctors";
        version = "5.5.13";
        sha256 = "1myvlzxk9xrm6vf9863wnv8py3ccgfxqxyc0sqxz0v3rwfnjgk16";
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "Bifunctors";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "bighugethesaurus" = callPackage
···
      }) {};
 
   "cabal-fmt" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, containers, directory
-     , filepath, mtl, optparse-applicative, parsec, pretty, process
-     , tasty, tasty-golden
+    ({ mkDerivation, base, bytestring, Cabal-syntax, containers
+     , directory, filepath, integer-logarithms, mtl
+     , optparse-applicative, parsec, pretty, process, QuickCheck, tasty
+     , tasty-golden, tasty-hunit, tasty-quickcheck, temporary
      }:
      mkDerivation {
        pname = "cabal-fmt";
-       version = "0.1.5.1";
-       sha256 = "0z8zc48lb6nnf12477j3x5dq7nkfk877q8q1kcrdsvdkz07nzz57";
+       version = "0.1.6";
+       sha256 = "0vbdcc89jl5iwblb57m9g2250miwq0db7rn449dcpknskfrfrrfr";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
-         base bytestring Cabal containers directory filepath mtl parsec
-         pretty
+         base bytestring Cabal-syntax containers directory filepath mtl
+         parsec pretty
        ];
        executableHaskellDepends = [
          base bytestring directory filepath optparse-applicative
        ];
        testHaskellDepends = [
-         base bytestring Cabal containers filepath process tasty
-         tasty-golden
+         base bytestring Cabal-syntax containers filepath integer-logarithms
+         process QuickCheck tasty tasty-golden tasty-hunit tasty-quickcheck
+         temporary
        ];
        doHaddock = false;
        description = "Format .cabal files";
···
      }:
      mkDerivation {
        pname = "canonical-json";
-       version = "0.6.0.0";
-       sha256 = "0lb847hvgkn49g6rvmavk14brvvpiy6q5fswk3cm9rc53hbq02zz";
-       revision = "1";
-       editedCabalFile = "18i3msxza5phvv5mz7gjqcygrm8rxd86pk2vqnsa715qrhsz88ch";
+       version = "0.6.0.1";
+       sha256 = "0znfbazzcx33xi2gi44vqhhdl9ja308zkxydarwkacwd0pckkprk";
        libraryHaskellDepends = [
          base bytestring containers deepseq parsec pretty
        ];
···
      }:
      mkDerivation {
        pname = "cleveland";
-       version = "0.2.0";
-       sha256 = "1y99n14283vlgcy517bz1qcdaw5lad30lkg6yd4id7z6pfg9bl3d";
+       version = "0.2.1";
+       sha256 = "1qqk1mld2wfckpgvsj48w8rh9pdkbqq1p36wkvrphf35hl0hr882";
        libraryHaskellDepends = [
          aeson base-noprelude bytestring constraints containers criterion
          cryptonite data-default directory either exceptions file-embed fmt
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "config-ini_0_2_5_0" = callPackage
+    ({ mkDerivation, base, containers, directory, hedgehog, ini
+     , megaparsec, text, transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "config-ini";
+       version = "0.2.5.0";
+       sha256 = "07vgpydzd44ayhq9c3q1335vphw384z8baf0wd0mnarr48yfaz3g";
+       libraryHaskellDepends = [
+         base containers megaparsec text transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         base containers directory hedgehog ini text unordered-containers
+       ];
+       description = "A library for simple INI-based configuration files";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "config-manager" = callPackage
     ({ mkDerivation, base, directory, filepath, HUnit, parsec
      , temporary, test-framework, test-framework-hunit, text, time
···
        pname = "consumers";
        version = "2.3.0.0";
        sha256 = "0kx4kfs9sp9mkwxdwb0c2dicbxb7k4cyfmvqzln4vrzqxykc73wv";
+       revision = "1";
+       editedCabalFile = "0hw2s92fy55l79byz1wsmyhxf2qvpch3827k5agccn7j97k33bcr";
        libraryHaskellDepends = [
          base containers exceptions extra hpqtypes lifted-base
          lifted-threads log-base monad-control monad-time mtl stm time
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "diagrams-lib_1_4_5_2" = callPackage
+  "diagrams-lib_1_4_5_3" = callPackage
     ({ mkDerivation, active, adjunctions, array, base, bytestring
      , cereal, colour, containers, criterion, data-default-class
      , deepseq, diagrams-core, diagrams-solve, directory, distributive
···
      }:
      mkDerivation {
        pname = "diagrams-lib";
-       version = "1.4.5.2";
-       sha256 = "1vx51g9znb4a9bf20pjd9zr98wmh39avk2i06217p0iidcw8whz6";
+       version = "1.4.5.3";
+       sha256 = "0h762gc9l4gsbx3r035mkfrwqblwshjaxk943bq277rw9d5vi7ic";
        libraryHaskellDepends = [
          active adjunctions array base bytestring cereal colour containers
          data-default-class diagrams-core diagrams-solve directory
···
        license = lib.licenses.gpl2Only;
      }) {};
 
+  "dsp_0_2_5_2" = callPackage
+    ({ mkDerivation, array, base, containers, QuickCheck, random }:
+     mkDerivation {
+       pname = "dsp";
+       version = "0.2.5.2";
+       sha256 = "0inar9c0n4x0li9c7krr17qv7zc49162wchhyn6ix7adni8j92z0";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ array base containers random ];
+       testHaskellDepends = [ array base containers QuickCheck ];
+       description = "Haskell Digital Signal Processing";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "dstring" = callPackage
     ({ mkDerivation, base, base-unicode-symbols, dlist }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "evm-opcodes";
-       version = "0.1.1";
-       sha256 = "07y2j1d6q9mnq3qaz2nf9394p88rnil6naanfxb608d9qa0cxbg9";
-       libraryHaskellDepends = [
-         base bytestring cereal containers data-dword text
-       ];
-       testHaskellDepends = [
-         base bytestring cereal containers data-dword hedgehog hspec tasty
-         tasty-discover tasty-hedgehog tasty-hspec text
-       ];
-       testToolDepends = [ tasty-discover ];
-       benchmarkHaskellDepends = [
-         base bytestring cereal containers data-dword tasty-bench text
-       ];
-       description = "Opcode types for Ethereum Virtual Machine (EVM)";
-       license = lib.licenses.mit;
-     }) {};
-
-  "evm-opcodes_0_1_2" = callPackage
-    ({ mkDerivation, base, bytestring, cereal, containers, data-dword
-     , hedgehog, hspec, tasty, tasty-bench, tasty-discover
-     , tasty-hedgehog, tasty-hspec, text
-     }:
-     mkDerivation {
-       pname = "evm-opcodes";
        version = "0.1.2";
        sha256 = "0p7gb3k64jsjscfxf2cd34igkm9j8q0rq3irfh1x4jdryvck2jch";
        libraryHaskellDepends = [
···
        ];
        description = "Opcode types for Ethereum Virtual Machine (EVM)";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "evoke" = callPackage
···
      }) {};
 
   "freckle-app" = callPackage
-    ({ mkDerivation, aeson, base, Blammo, bugsnag, bytestring
+    ({ mkDerivation, aeson, aws-xray-client-persistent
+     , aws-xray-client-wai, base, Blammo, bugsnag, bytestring
      , case-insensitive, conduit, containers, datadog, doctest, dotenv
      , ekg-core, envparse, errors, exceptions, extra, filepath, Glob
      , hashable, hspec, hspec-core, hspec-expectations-lifted
···
      }:
      mkDerivation {
        pname = "freckle-app";
-       version = "1.6.0.3";
-       sha256 = "0nv29d82zsrf6x30jsjgi9wlnfshy50h3pi5x7igxm3zxhh9saf6";
+       version = "1.7.0.0";
+       sha256 = "1dndz28fnlwkyskxh2b3afi2imf0ax5sxvqgbd6jl4f06lmk7i5p";
        libraryHaskellDepends = [
-         aeson base Blammo bugsnag bytestring case-insensitive conduit
-         containers datadog doctest dotenv ekg-core envparse errors
-         exceptions extra filepath Glob hashable hspec hspec-core
-         hspec-expectations-lifted hspec-junit-formatter http-client
-         http-conduit http-link-header http-types immortal lens memcache
-         monad-control MonadRandom mtl network-uri path-pieces persistent
-         persistent-postgresql postgresql-simple primitive resource-pool
-         retry safe scientist semigroupoids template-haskell text time
-         transformers transformers-base typed-process unliftio unliftio-core
+         aeson aws-xray-client-persistent aws-xray-client-wai base Blammo
+         bugsnag bytestring case-insensitive conduit containers datadog
+         doctest dotenv ekg-core envparse errors exceptions extra filepath
+         Glob hashable hspec hspec-core hspec-expectations-lifted
+         hspec-junit-formatter http-client http-conduit http-link-header
+         http-types immortal lens memcache monad-control MonadRandom mtl
+         network-uri path-pieces persistent persistent-postgresql
+         postgresql-simple primitive resource-pool retry safe scientist
+         semigroupoids template-haskell text time transformers
+         transformers-base typed-process unliftio unliftio-core
          unordered-containers vector wai wai-extra yaml yesod-core
        ];
        testHaskellDepends = [
···
      , fgl-visualize, file-embed, filepath, free, futhark-data
      , futhark-manifest, futhark-server, githash, half, happy, haskeline
      , language-c-quote, lens, lsp, mainland-pretty, megaparsec, mtl
-     , mwc-random, neat-interpolation, parallel, process, process-extras
-     , QuickCheck, random, regex-tdfa, srcloc, statistics, tasty
-     , tasty-hunit, tasty-quickcheck, template-haskell, temporary
-     , terminal-size, text, time, transformers, vector, versions
-     , zip-archive, zlib
+     , mwc-random, neat-interpolation, parallel, prettyprinter
+     , prettyprinter-ansi-terminal, process, process-extras, QuickCheck
+     , random, regex-tdfa, srcloc, statistics, tasty, tasty-hunit
+     , tasty-quickcheck, template-haskell, temporary, terminal-size
+     , text, time, transformers, vector, versions, zip-archive, zlib
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.22.1";
-       sha256 = "1h3ihd0cymcnbv5ms49dmfpgyngmai58v61sw5j04zi7f9xjyr0n";
+       version = "0.22.2";
+       sha256 = "027w745vs121jsah29kqgw288s40ag25jszbf0sb2dh1xb30lvpw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          fgl-visualize file-embed filepath free futhark-data
          futhark-manifest futhark-server githash half haskeline
          language-c-quote lens lsp mainland-pretty megaparsec mtl mwc-random
-         neat-interpolation parallel process process-extras random
+         neat-interpolation parallel prettyprinter
+         prettyprinter-ansi-terminal process process-extras random
          regex-tdfa srcloc statistics template-haskell temporary
          terminal-size text time transformers vector versions zip-archive
          zlib
···
        license = lib.licenses.mit;
      }) {};
 
+  "generic-functor_1_0_0_0" = callPackage
+    ({ mkDerivation, ap-normalize, base, transformers }:
+     mkDerivation {
+       pname = "generic-functor";
+       version = "1.0.0.0";
+       sha256 = "0cnwzz7303z55nr64bi56w2bqxh7wxmv8wxzmh5xb37k674qjgz6";
+       libraryHaskellDepends = [ ap-normalize base ];
+       testHaskellDepends = [ base transformers ];
+       description = "Deriving generalized functors with GHC.Generics";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "generic-labels" = callPackage
     ({ mkDerivation, base, Cabal, generic-lens-core, inspection-testing
      }:
···
        license = lib.licenses.mit;
      }) {};
 
+  "genvalidity-hspec_1_0_0_2" = callPackage
+    ({ mkDerivation, base, genvalidity, genvalidity-property, hspec
+     , hspec-core, QuickCheck, transformers, validity
+     }:
+     mkDerivation {
+       pname = "genvalidity-hspec";
+       version = "1.0.0.2";
+       sha256 = "00sv0mzlvny5ch7c9fnd19szqd0pjrkvi080x1i62qa5fdzs5yc4";
+       libraryHaskellDepends = [
+         base genvalidity genvalidity-property hspec hspec-core QuickCheck
+         transformers validity
+       ];
+       testHaskellDepends = [
+         base genvalidity hspec hspec-core QuickCheck
+       ];
+       description = "Standard spec's for GenValidity instances";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "genvalidity-hspec-aeson" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deepseq, genvalidity
      , genvalidity-aeson, genvalidity-hspec, genvalidity-property
···
      }) {};
 
   "ghc-parser" = callPackage
-    ({ mkDerivation, base, cpphs, ghc, happy }:
-     mkDerivation {
-       pname = "ghc-parser";
-       version = "0.2.3.0";
-       sha256 = "1sm93n6w2zqkp4dhr604bk67sis1rb6jb6imsxr64vjfm7bkigln";
-       libraryHaskellDepends = [ base ghc ];
-       libraryToolDepends = [ cpphs happy ];
-       description = "Haskell source parser from GHC";
-       license = lib.licenses.mit;
-     }) {};
-
-  "ghc-parser_0_2_4_0" = callPackage
     ({ mkDerivation, base, ghc }:
      mkDerivation {
        pname = "ghc-parser";
···
        libraryHaskellDepends = [ base ghc ];
        description = "Haskell source parser from GHC";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-paths" = callPackage
···
      }:
      mkDerivation {
        pname = "ghc-tags-core";
-       version = "0.4.1.0";
-       sha256 = "0lcgbp61zvaa52ynp4lwnjf7vwk126f496r16zfbc6saxrgdmz0p";
+       version = "0.4.2.2";
+       sha256 = "1mp1c5jvvbmypjh45nnvlkvqrj4hj55pcb9f42qwv5xw4yan86m1";
        libraryHaskellDepends = [
          attoparsec base bytestring containers deepseq directory
          filepath-bytestring ghc mtl pipes pipes-attoparsec pipes-bytestring
···
      }:
      mkDerivation {
        pname = "ghc-tags-plugin";
-       version = "0.5.1.0";
-       sha256 = "0k8lg8k4vd6z12zfks50j6i9mz827bgchjg55snbgnh3h30is6ab";
+       version = "0.5.2.0";
+       sha256 = "1n8b3xsyji5p1w1wrpwscp71mhnh4y6i9v881wml4s49fp6rv3dj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "gtk-sni-tray";
-       version = "0.1.8.0";
-       sha256 = "0b8b8hvsv60zvnjidqm1qchxdgqdf5gcmm5pz8fvrvcjqq27b1xa";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base bytestring containers dbus directory enclosed-exceptions
-         filepath gi-cairo gi-cairo-connector gi-cairo-render
-         gi-dbusmenugtk3 gi-gdk gi-gdkpixbuf gi-glib gi-gtk gtk-strut
-         haskell-gi haskell-gi-base hslogger status-notifier-item text
-         transformers transformers-base unix
-       ];
-       libraryPkgconfigDepends = [ gtk3 ];
-       executableHaskellDepends = [
-         base dbus dbus-hslogger gi-gdk gi-gtk gtk-strut hslogger
-         optparse-applicative status-notifier-item text unix
-       ];
-       description = "A standalone StatusNotifierItem/AppIndicator tray";
-       license = lib.licenses.bsd3;
-       badPlatforms = lib.platforms.darwin;
-       mainProgram = "gtk-sni-tray-standalone";
-     }) {inherit (pkgs) gtk3;};
-
-  "gtk-sni-tray_0_1_8_1" = callPackage
-    ({ mkDerivation, base, bytestring, containers, dbus, dbus-hslogger
-     , directory, enclosed-exceptions, filepath, gi-cairo
-     , gi-cairo-connector, gi-cairo-render, gi-dbusmenugtk3, gi-gdk
-     , gi-gdkpixbuf, gi-glib, gi-gtk, gtk-strut, gtk3, haskell-gi
-     , haskell-gi-base, hslogger, optparse-applicative
-     , status-notifier-item, text, transformers, transformers-base, unix
-     }:
-     mkDerivation {
-       pname = "gtk-sni-tray";
        version = "0.1.8.1";
        sha256 = "0i131ks6m5akgcfahcbfqhg1i5dxz0y6rba3is4s3m5va6spp5yf";
        isLibrary = true;
···
        description = "A standalone StatusNotifierItem/AppIndicator tray";
        license = lib.licenses.bsd3;
        badPlatforms = lib.platforms.darwin;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "gtk-sni-tray-standalone";
      }) {inherit (pkgs) gtk3;};
 
···
      }:
      mkDerivation {
        pname = "gtk-strut";
-       version = "0.1.3.1";
-       sha256 = "1zy5qv628n2hs8lrg9bggri2gj2jcyl7xwlrz8w4ndgnpsw9zk7c";
-       libraryHaskellDepends = [
-         base data-default gi-gdk gi-gtk hslogger text transformers
-       ];
-       description = "Libary for creating strut windows with gi-gtk";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "gtk-strut_0_1_3_2" = callPackage
-    ({ mkDerivation, base, data-default, gi-gdk, gi-gtk, hslogger, text
-     , transformers
-     }:
-     mkDerivation {
-       pname = "gtk-strut";
        version = "0.1.3.2";
        sha256 = "0rymacvllin8ni2fd7yyfq43rbbyb921c4nm4z7aa2z82fsrkw3q";
        libraryHaskellDepends = [
···
        ];
        description = "Library for creating strut windows with gi-gtk";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gtk-toggle-button-list" = callPackage
···
      }) {};
 
   "haiji" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, data-default, doctest
-     , filepath, mtl, process-extras, scientific, tagged, tasty
-     , tasty-hunit, tasty-th, template-haskell, text, transformers
-     , unordered-containers, vector
+    ({ mkDerivation, aeson, attoparsec, base, data-default, mtl
+     , process-extras, scientific, tagged, tasty, tasty-hunit, tasty-th
+     , template-haskell, text, transformers, unordered-containers
+     , vector
      }:
      mkDerivation {
        pname = "haiji";
-       version = "0.3.3.0";
-       sha256 = "1fmdiimjk2cnafjb2v8xdbnlwp6m79khl920l8gv1jcvqjmv9vvs";
+       version = "0.3.4.0";
+       sha256 = "1m97lnd993xpxcbm3n2qgqzqjb5j3jvkzkdcb1h9qjd3lr88j1cf";
        libraryHaskellDepends = [
          aeson attoparsec base data-default mtl scientific tagged
          template-haskell text transformers unordered-containers vector
        ];
        testHaskellDepends = [
-         aeson base data-default doctest filepath process-extras tasty
-         tasty-hunit tasty-th text
+         aeson base data-default process-extras tasty tasty-hunit tasty-th
+         text
        ];
        description = "A typed template engine, subset of jinja2";
        license = lib.licenses.bsd3;
···
        ];
        pname = "hsqml";
        license = lib.licenses.bsd3;
-     }) {};
-
-       pname = "hsqml";
-       pname = "hsqml";
-       pname = "hsqml";
-     }:
-     mkDerivation {
-       pname = "hsqml";
-       pname = "hsqml";
-       pname = "hsqml";
-       libraryHaskellDepends = [
-       pname = "hsqml";
-       ];
-       testHaskellDepends = [
-       pname = "hsqml";
-         template-haskell
-       ];
-       pname = "hsqml";
-       license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
        pname = "hsqml";
···
 
   "hegg" = callPackage
     ({ mkDerivation, base, containers, deriving-compat, tasty
-     , tasty-hunit, tasty-quickcheck, transformers
+     , tasty-bench, tasty-hunit, tasty-quickcheck, transformers
      }:
      mkDerivation {
        pname = "hegg";
-       version = "0.1.0.0";
-       sha256 = "00i18as11njqc10g360aca0l9diz474lsm73rwkg53bwwnfssg1n";
+       version = "0.2.0.0";
+       sha256 = "124rdj3lmssn57gy3nffinyg1p03wd3w672v7l2aa8gzrpan20cg";
        libraryHaskellDepends = [ base containers transformers ];
        testHaskellDepends = [
          base containers deriving-compat tasty tasty-hunit tasty-quickcheck
+       ];
+       benchmarkHaskellDepends = [
+         base containers deriving-compat tasty tasty-bench tasty-hunit
+         tasty-quickcheck
        ];
        description = "Fast equality saturation in Haskell";
        license = lib.licenses.bsd3;
···
        ];
        description = "inotify conduit sources";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hinquire" = callPackage
···
        maintainers = [ lib.maintainers.maralorn ];
      }) {};
 
+  "hlint_3_5" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, cmdargs
+     , containers, cpphs, data-default, deriving-aeson, directory, extra
+     , file-embed, filepath, filepattern, ghc-lib-parser
+     , ghc-lib-parser-ex, hscolour, process, refact, text, transformers
+     , uniplate, unordered-containers, utf8-string, vector, yaml
+     }:
+     mkDerivation {
+       pname = "hlint";
+       version = "3.5";
+       sha256 = "0kxdrqybnma508g1z42s3rc3cay11m8nl5ziddyw31m020515gcq";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal base bytestring cmdargs containers cpphs
+         data-default deriving-aeson directory extra file-embed filepath
+         filepattern ghc-lib-parser ghc-lib-parser-ex hscolour process
+         refact text transformers uniplate unordered-containers utf8-string
+         vector yaml
+       ];
+       executableHaskellDepends = [ base ];
+       description = "Source code suggestions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hlint";
+       maintainers = [ lib.maintainers.maralorn ];
+     }) {};
+
   "hlint-test" = callPackage
     ({ mkDerivation, base, hlint }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "hurl-xml";
-       version = "0.1.0.0";
-       sha256 = "14z0b68fsqpbhap6yywjv3y48bz0chn4p0hhklw9zgyyhhrvlz1z";
+       version = "0.2.0.0";
+       sha256 = "1xcjc0ckq2wb6nmszaf97iciqa6il8f20rp3vjy1a6gmiclib8mh";
        libraryHaskellDepends = [
          base bytestring containers css-syntax data-default-class directory
          file-embed filepath html-conduit hurl network-uri stylist-traits
···
      }:
      mkDerivation {
        pname = "ihaskell";
-       version = "0.10.2.2";
-       sha256 = "1lcyhj19v44wc6blj31fc4gfzsbqj0wnf9fyll8xi4nq0wq0zw89";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson base base64-bytestring binary bytestring cmdargs containers
-         directory exceptions filepath ghc ghc-boot ghc-parser ghc-paths
-         haskeline hlint http-client http-client-tls ipython-kernel 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;
-       mainProgram = "ihaskell";
-     }) {};
-
-  "ihaskell_0_10_3_0" = callPackage
-    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
-     , 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, parsec, process, random, raw-strings-qq, setenv
-     , shelly, split, stm, strict, text, time, transformers, unix
-     , unordered-containers, utf8-string, vector
-     }:
-     mkDerivation {
-       pname = "ihaskell";
        pname = "hsqml";
        sha256 = "0caghqp1k04mhfxqpz2hics92wdw8krnjycqsxsjp8s7impl36vl";
        isLibrary = true;
···
        ];
        description = "A Haskell backend kernel for the Jupyter project";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "ihaskell";
      }) {};
 
···
        ];
        description = "IHaskell display instances for charts types";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ihaskell-diagrams" = callPackage
···
        ];
        description = "IHaskell display instances for diagram types";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ihaskell-display" = callPackage
···
        libraryHaskellDepends = [ base bytestring gnuplot ihaskell ];
        description = "IHaskell display instance for Gnuplot (from gnuplot package)";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ihaskell-graphviz" = callPackage
···
        libraryHaskellDepends = [ base bytestring hmatrix ihaskell plot ];
        description = "IHaskell display instance for Plot (from plot package)";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "ihaskell-rlangqq" = callPackage
···
      }:
      mkDerivation {
        pname = "ipython-kernel";
-       version = "0.10.2.2";
-       sha256 = "1zvpabfqnkga2smp4p0p46i9llkvxdcdvf0ysafh5xia4ls2icyq";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         aeson base binary bytestring containers cryptonite directory
-         filepath memory parsec process temporary text transformers
-         unordered-containers uuid zeromq4-haskell
-       ];
-       description = "A library for creating kernels for IPython frontends";
-       license = lib.licenses.mit;
-     }) {};
-
-  "ipython-kernel_0_10_3_0" = callPackage
-    ({ mkDerivation, aeson, base, binary, bytestring, containers
-     , cryptonite, directory, filepath, memory, parsec, process
-     , temporary, text, transformers, unordered-containers, uuid
-     , zeromq4-haskell
-     }:
-     mkDerivation {
-       pname = "ipython-kernel";
        pname = "hsqml";
        sha256 = "0zvcqgvrykfmp706snbpxy8ia0hkxshrj8r8kfwkvkwhxd72ad5c";
        isLibrary = true;
···
        ];
        description = "A library for creating kernels for IPython frontends";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "irc" = callPackage
···
      }:
      mkDerivation {
        pname = "launchdarkly-server-sdk";
-       version = "3.0.1";
-       sha256 = "08smhjp2vjnjz2dvgpswgsrv7vjwrawgm3vbylgysc816w56bxg7";
+       version = "3.0.2";
+       sha256 = "1wh0an9g3hzpmdp2jayag7dknajivl07h273ar1qplrfd1js5fd6";
        libraryHaskellDepends = [
          aeson attoparsec base base16-bytestring bytestring clock containers
          cryptohash exceptions extra generic-lens hashtables hedis
···
      }:
      mkDerivation {
        pname = "log-base";
-       version = "0.11.1.0";
-       sha256 = "0gq92n2xbvrsaqyf2mjfcdpxrgvv2ls299mijjmm6b0m9qzh3r2y";
+       version = "0.12.0.0";
+       sha256 = "0z646qhyp636q24fxwkkpbg2z5f5vfyskkl04jrk9hpfvba3arsg";
        libraryHaskellDepends = [
          aeson aeson-pretty base bytestring deepseq exceptions mmorph
          monad-control mtl semigroups stm text time transformers-base
···
 
   "log-elasticsearch" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
-     , bytestring, deepseq, http-client, http-client-tls, http-types
+     , bytestring, deepseq, http-client, http-client-openssl, http-types
      , log-base, network-uri, semigroups, text, text-show, time
-     , transformers, unordered-containers, vector
+     , transformers, unliftio-core, unordered-containers, vector
      }:
      mkDerivation {
        pname = "log-elasticsearch";
-       version = "0.12.2.0";
-       sha256 = "1laj93wiy092ha7w1dmaggpqkyq6y8zc3l1s56h2dv7jrxhfpc7n";
+       version = "0.13.0.0";
+       sha256 = "1jc3891y71rxidwhyfqkkh4jf7kvfw8if622z2fbdl7wgr40saqj";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bytestring deepseq
-         http-client http-client-tls http-types log-base network-uri
-         semigroups text text-show time transformers unordered-containers
-         vector
+         http-client http-client-openssl http-types log-base network-uri
+         semigroups text text-show time transformers unliftio-core
+         unordered-containers vector
        ];
        description = "Structured logging solution (Elasticsearch back end)";
        license = lib.licenses.bsd3;
···
   "log-postgres" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
      , bytestring, deepseq, hpqtypes, http-client, lifted-base, log-base
-     , mtl, semigroups, split, text, text-show, time
+     , mtl, semigroups, split, text, text-show, time, unliftio-core
      , unordered-containers, vector
      }:
      mkDerivation {
        pname = "log-postgres";
-       version = "0.8.1.0";
-       sha256 = "01j6x59cahsajymzcqjp7miy46azjnarsgs8ymc5blak2wbws2i5";
+       version = "0.9.0.0";
+       sha256 = "0a61vzps32garq2alk7gqg0ga25acv1in3fzxhrmsmqgzimxhi6b";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bytestring deepseq
          hpqtypes http-client lifted-base log-base mtl semigroups split text
-         text-show time unordered-containers vector
+         text-show time unliftio-core unordered-containers vector
        ];
        description = "Structured logging solution (PostgreSQL back end)";
        license = lib.licenses.bsd3;
···
      }:
      mkDerivation {
        pname = "lorentz";
-       version = "0.14.0";
-       sha256 = "1f9yhkg8q4bzsbrk6srgkaqlykj00i7jsvdqvjp9b2nd6mn7cf1j";
+       version = "0.14.1";
+       sha256 = "0qvg3b0hmnjwarmvsynz7f2y362r6wszzm46168154xwmgyrkb3h";
        libraryHaskellDepends = [
          aeson-pretty base-noprelude bimap bytestring constraints containers
          cryptonite data-default first-class-families fmt lens morley
···
      }:
      mkDerivation {
        pname = "morley";
-       version = "1.17.0";
-       sha256 = "1a0z4351rf3aix5gwkacjvf9wjfgnv8b5xv8w1y1hk7c4cflaand";
+       version = "1.18.0";
+       sha256 = "0kv4rcq8yqdnmf14dsf03196nc717cih2pd574cc7qvfv2frwgh7";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "morley-client";
-       version = "0.2.0";
-       sha256 = "1pdaqvhg94bikn3dsdg7l98wwy62l3wyxzrkx5pzl0pkwzqqbfy0";
+       version = "0.2.1";
+       sha256 = "0a55lmbk1b2h7469hv084a0gyp48w57hjz05wlpc4npm0gp1ijxw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "net-mqtt";
-       version = "0.8.2.2";
-       sha256 = "1aadyks5id0pb9kz2ydqvy0sp6v5kliv9khmn1s47vvsb920zqy3";
+       version = "0.8.2.3";
+       sha256 = "0z75is6s7flxhcw4bqc0zzm81swvcq1yxcczw2dph93n4wbgsz90";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "postgresql-migration";
-       version = "0.2.1.3";
-       sha256 = "1qxkan5f328rv3nl31pvhz305k7b4ah98s0j1bc4hcaa5g5d3052";
-       revision = "5";
-       editedCabalFile = "06g55xijcgcy0gcgwrj8jd6lalfxvswmk2di0iv40s52b84ysqih";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base base64-bytestring bytestring cryptohash directory filepath
-         postgresql-simple text time
-       ];
-       executableHaskellDepends = [
-         base base64-bytestring bytestring cryptohash directory
-         postgresql-simple text time
-       ];
-       testHaskellDepends = [ base bytestring hspec postgresql-simple ];
-       description = "PostgreSQL Schema Migrations";
-       license = lib.licenses.bsd3;
-       mainProgram = "migrate";
-     }) {};
-
-  "postgresql-migration_0_2_1_4" = callPackage
-    ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash
-     , directory, filepath, hspec, postgresql-simple, text, time
-     }:
-     mkDerivation {
-       pname = "postgresql-migration";
        version = "0.2.1.4";
        sha256 = "0p8rggalgijw02p7m77x443md5dg1kjvvm06v980cchsj148c80s";
        isLibrary = true;
···
        testHaskellDepends = [ base bytestring hspec postgresql-simple ];
        description = "PostgreSQL Schema Migrations";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "migrate";
      }) {};
 
···
     ({ mkDerivation, base, primitive }:
      mkDerivation {
        pname = "primitive-unaligned";
-       version = "0.1.1.1";
-       sha256 = "1f3a46d9dr7x1k8b6ixnp9jzxkppx3g27qsxq4f244ndnf2jnchl";
-       revision = "1";
-       editedCabalFile = "1vksp8izwb2hwyc1li3cf209cf2vaj6ww9n3lyrksr8ymd1p6f16";
-       libraryHaskellDepends = [ base primitive ];
-       testHaskellDepends = [ base primitive ];
-       description = "Unaligned access to primitive arrays";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "primitive-unaligned_0_1_1_2" = callPackage
-    ({ mkDerivation, base, primitive }:
-     mkDerivation {
-       pname = "primitive-unaligned";
        version = "0.1.1.2";
        sha256 = "1ksl2gib15inbd80rf0bl3baj8fmk740liv4fdg9493dlhr3a4pa";
        libraryHaskellDepends = [ base primitive ];
        testHaskellDepends = [ base primitive ];
        description = "Unaligned access to primitive arrays";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "primitive-unlifted" = callPackage
···
      }:
      mkDerivation {
        pname = "proto-lens";
-       version = "0.7.1.1";
-       sha256 = "1a2w8bpi18djcfklgkvsla5zbfsncww260kw8a87jdd3l0v6gq7q";
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base bytestring containers deepseq ghc-prim lens-family parsec
-         pretty primitive profunctors tagged text transformers vector
-       ];
-       testHaskellDepends = [
-         base bytestring QuickCheck tasty tasty-quickcheck vector
-       ];
-       description = "A lens-based implementation of protocol buffers in Haskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "proto-lens_0_7_1_2" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim
-     , lens-family, parsec, pretty, primitive, profunctors, QuickCheck
-     , tagged, tasty, tasty-quickcheck, text, transformers, vector
-     }:
-     mkDerivation {
-       pname = "proto-lens";
        version = "0.7.1.2";
        sha256 = "0zbkwksmnpc5ivbhckg1kjivn1qbk9pz79vifyiydp90nxjh56fy";
        enableSeparateDataOutput = true;
···
        ];
        description = "A lens-based implementation of protocol buffers in Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "proto-lens-arbitrary" = callPackage
···
      }:
      mkDerivation {
        pname = "proto-lens-runtime";
-       version = "0.7.0.2";
-       sha256 = "1akspkc1vswdk2z8ilqdnpf01a851mrr820j516xxnlwmhql7y3k";
-       libraryHaskellDepends = [
-         base bytestring containers deepseq filepath lens-family proto-lens
-         text vector
-       ];
-       doHaddock = false;
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "proto-lens-runtime_0_7_0_3" = callPackage
-    ({ mkDerivation, base, bytestring, containers, deepseq, filepath
-     , lens-family, proto-lens, text, vector
-     }:
-     mkDerivation {
-       pname = "proto-lens-runtime";
        version = "0.7.0.3";
        sha256 = "1fb64xcrgd7v2l4hqqcs0riszklkxh516l7n4p9lwwqmagmgz36y";
        libraryHaskellDepends = [
···
        ];
        doHaddock = false;
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "proto-lens-setup" = callPackage
···
      }:
      mkDerivation {
        pname = "shake";
-       version = "0.19.6";
-       sha256 = "0hnm3h1ni4jq73a7b7yxhbg9wm8mrjda5kmkpnmclynnpwvvi7bx";
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-         base binary bytestring deepseq directory extra filepath filepattern
-         hashable heaps js-dgtable js-flot js-jquery primitive process
-         random time transformers unix unordered-containers utf8-string
-       ];
-       executableHaskellDepends = [
-         base binary bytestring deepseq directory extra filepath filepattern
-         hashable heaps js-dgtable js-flot js-jquery primitive process
-         random time transformers unix unordered-containers utf8-string
-       ];
-       testHaskellDepends = [
-         base binary bytestring deepseq directory extra filepath filepattern
-         hashable heaps js-dgtable js-flot js-jquery primitive process
-         QuickCheck random time transformers unix unordered-containers
-         utf8-string
-       ];
-       description = "Build system library, like Make, but more accurate dependencies";
-       license = lib.licenses.bsd3;
-       mainProgram = "shake";
-     }) {};
-
-  "shake_0_19_7" = callPackage
-    ({ mkDerivation, base, binary, bytestring, deepseq, directory
-     , extra, filepath, filepattern, hashable, heaps, js-dgtable
-     , js-flot, js-jquery, primitive, process, QuickCheck, random, time
-     , transformers, unix, unordered-containers, utf8-string
-     }:
-     mkDerivation {
-       pname = "shake";
        version = "0.19.7";
        sha256 = "1lcr6q53qwm308bny6gfawcjhxsmalqi3dnwckam02zp2apmcaim";
        isLibrary = true;
···
        ];
        description = "Build system library, like Make, but more accurate dependencies";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
        mainProgram = "shake";
      }) {};
 
···
      }:
      mkDerivation {
        pname = "shake-futhark";
-       version = "0.2.0.1";
-       sha256 = "0kwj2q0sfh80gcxamfh4k2cnr2mbbs41n43z5rwdawcmdb2c0xxy";
+       version = "0.2.0.2";
+       sha256 = "0rcm4m65l7lv0nzxwq29vklpxv960b1x3kx2fvrbyb9r2carh5h5";
        libraryHaskellDepends = [
          base containers directory filepath futhark shake text
        ];
···
        pname = "stack";
        version = "2.9.1";
        sha256 = "01020dx89m07qmjs58vs2kidhkzq3106md08w6c65bzxvlf6kcwk";
+       revision = "1";
+       editedCabalFile = "06xrw6k1vqkvgmb4cvxqmh756n7h9vynbb3smicb1149czrlwkv2";
        configureFlags = [
          "-fdisable-git-info" "-fhide-dependency-versions"
          "-fsupported-build"
···
        mainProgram = "hstrrand";
      }) {};
 
+  "string-random_0_1_4_3" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, containers
+     , optparse-applicative, pcre-heavy, QuickCheck, random, tasty
+     , tasty-hunit, tasty-quickcheck, text, transformers
+     }:
+     mkDerivation {
+       pname = "string-random";
+       version = "0.1.4.3";
+       sha256 = "1ddy6fbkwk0nwq4anq6nsbggrlamn5d3kz2q4iy7744igasij97g";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         attoparsec base containers random text transformers
+       ];
+       executableHaskellDepends = [ base optparse-applicative text ];
+       testHaskellDepends = [
+         base bytestring pcre-heavy QuickCheck tasty tasty-hunit
+         tasty-quickcheck text
+       ];
+       description = "A library for generating random string from a regular experession";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       mainProgram = "hstrrand";
+     }) {};
+
   "string-similarity" = callPackage
     ({ mkDerivation, base, bytestring, criterion, hspec, QuickCheck
      , suffixtree
···
     ({ mkDerivation, base, blaze-markup, blaze-svg, directory, text }:
      mkDerivation {
        pname = "svg-icons";
-       version = "0.4.0.2";
-       sha256 = "1z31ynhchk27hzfayrbnh9xzdq5ibz57ls2jk7j5jck9xmxl7zac";
+       version = "1.0.0.0";
+       sha256 = "1ddq3im8z4jqpxxk3qqa30372ybvp8capmxbi3xx5ik5vjrcp0cv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:
      mkDerivation {
        pname = "syb";
-       version = "0.7.2.1";
-       sha256 = "15ld5929n3lzfb5sy9nnm77x2l6i2sgsxw47jdrqcrz6fxpwc1qq";
-       libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base containers mtl tasty tasty-hunit ];
-       description = "Scrap Your Boilerplate";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "syb_0_7_2_2" = callPackage
-    ({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:
-     mkDerivation {
-       pname = "syb";
        version = "0.7.2.2";
        sha256 = "1qxjjndfwz2vvpz9707banmcn6jl2v6w6zp401zxaj327fccchw1";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base containers mtl tasty tasty-hunit ];
        description = "Scrap Your Boilerplate";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "syb-extras" = callPackage
···
     ({ mkDerivation, base, template-haskell }:
      mkDerivation {
        pname = "template-haskell-compat-v0208";
-       version = "0.1.9";
-       sha256 = "082i7m3chwcxggfx5mgd716w83dxw6l9v8y4gl3p37f8rd2lqbrj";
-       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_9_1" = callPackage
-    ({ mkDerivation, base, template-haskell }:
-     mkDerivation {
-       pname = "template-haskell-compat-v0208";
        version = "0.1.9.1";
        sha256 = "1z87rla4vcbghdrvjkay59b686f0by02102vwrcayn4vbwzn4am1";
        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
···
      }:
      mkDerivation {
        pname = "tesla";
-       version = "0.5.0.0";
-       sha256 = "1nlzibxw9ayb2yjhpfky0sxd8q44ss8hxvgs4vi9xkw4afymr2w5";
+       version = "0.5.1.0";
+       sha256 = "1blavadij1cvjp0dknsczvsms4ma7hh31zd8bmiksravxpcmdbw5";
        libraryHaskellDepends = [
          aeson base base64-bytestring bytestring casing containers
          cryptonite exceptions finite-typelits generic-deriving http-client
···
     ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
      mkDerivation {
        pname = "th-abstraction";
-       version = "0.4.4.0";
-       sha256 = "1nmgylmxgqc2hxjqcxqiws2qm8cimvc859b1fr341hn60an1d829";
-       libraryHaskellDepends = [
-         base containers ghc-prim template-haskell
-       ];
-       testHaskellDepends = [ base containers template-haskell ];
-       description = "Nicer interface for reified information about data types";
-       license = lib.licenses.isc;
-     }) {};
-
-  "th-abstraction_0_4_5_0" = callPackage
-    ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
-     mkDerivation {
-       pname = "th-abstraction";
        version = "0.4.5.0";
        sha256 = "09hm0famyqsq09lal2ylnhsb31hybj8zanldi7cqncky4i7y5m80";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base containers template-haskell ];
        description = "Nicer interface for reified information about data types";
        license = lib.licenses.isc;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-alpha" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "th-utilities_0_2_5_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , hspec, primitive, syb, template-haskell, text, th-abstraction
+     , th-orphans, vector
+     }:
+     mkDerivation {
+       pname = "th-utilities";
+       version = "0.2.5.0";
+       sha256 = "1qcp3f9q4b9p372vdngy7bzcxp9b669vddpijg4j5vz04njl41sa";
+       libraryHaskellDepends = [
+         base bytestring containers directory filepath primitive syb
+         template-haskell text th-abstraction th-orphans
+       ];
+       testHaskellDepends = [
+         base bytestring containers directory filepath hspec primitive syb
+         template-haskell text th-abstraction th-orphans vector
+       ];
+       description = "Collection of useful functions for use with Template Haskell";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "thank-you-stars" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
      , directory, filepath, hackage-db, hspec, hspec-discover, req
···
        ];
        description = "Simple tokenizer for English text";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "tokenizer" = callPackage
+    ({ mkDerivation, base, containers, hspec, megaparsec, transformers
+     }:
+     mkDerivation {
+       pname = "tokenizer";
+       version = "0.1.0.0";
+       sha256 = "1wwck2pl95va6dlafh2yj8hf1fpkh05si4fl188ap472anmlhwy3";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base containers transformers ];
+       testHaskellDepends = [
+         base containers hspec megaparsec transformers
+       ];
+       description = "Check uniqueness and tokenize safely";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "tokenizer-monad" = callPackage
···
      }:
      mkDerivation {
        pname = "welford-online-mean-variance";
-       version = "0.1.0.0";
-       sha256 = "0px7b1jbz5wn3zvmj0y4nrwy9m99615nw06hd3snaa60z4m88blm";
+       version = "0.1.0.1";
+       sha256 = "1zzahm5d47rx1zx70i24mj6slkddwpa6hwyplda36x9xpkpjzr51";
        libraryHaskellDepends = [ base cereal deepseq vector ];
        testHaskellDepends = [
          base cereal deepseq QuickCheck tasty tasty-discover
···
        pname = "zigzag";
        version = "0.0.1.0";
        sha256 = "1gy2hv4ggxfwrxg9v3qyxpfrm1j5sixckc2j3h37ckzsh5v06mga";
+       revision = "1";
+       editedCabalFile = "04n4m74hlh0fpy7qbgmm0piblc5d54nnj7322wnw2yj50am7hbxc";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
        description = "Zigzag encoding of integers into unsigned integers";

pkgs/development/tools/haskell/hadrian/default.nix

···
+{ # GHC source tree to build hadrian from
+  ghcSrc ? null, ghcVersion ? null
+, mkDerivation, base, bytestring, Cabal, containers, directory
+, extra, filepath, lib, mtl, parsec, shake, text, transformers
+, unordered-containers
+, userSettings ? null
+, writeText
+}:
+
+if ghcSrc == null || ghcVersion == null
+then throw "hadrian: need to specify ghcSrc and ghcVersion arguments manually"
+else
+
+mkDerivation {
+  pname = "hadrian";
+  version = ghcVersion;
+  src = ghcSrc;
+  postUnpack = ''
+    sourceRoot="$sourceRoot/hadrian"
+  '';
+  # Overwrite UserSettings.hs with a provided custom one
+  postPatch = lib.optionalString (userSettings != null) ''
+    install -m644 "${writeText "UserSettings.hs" userSettings}" src/UserSettings.hs
+  '';
+  configureFlags = [
+    # avoid QuickCheck dep which needs shared libs / TH
+    "-f-selftest"
+    # Building hadrian with -O1 takes quite some time with little benefit.
+    # Additionally we need to recompile it on every change of UserSettings.hs.
+    # See https://gitlab.haskell.org/ghc/ghc/-/merge_requests/1190
+    "-O0"
+  ];
+  isLibrary = false;
+  isExecutable = true;
+  executableHaskellDepends = [
+    base bytestring Cabal containers directory extra filepath mtl
+    parsec shake text transformers unordered-containers
+  ];
+  description = "GHC build system";
+  license = lib.licenses.bsd3;
+}

pkgs/top-level/haskell-packages.nix

···
     ghc94 = ghc942;
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix {
       bootPkgs =
-        if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then
-          packages.ghc8107
+        if stdenv.isAarch64 || stdenv.isAarch32 then
+          packages.ghc922BinaryMinimal
+        else if stdenv.hostPlatform.isPower64 && stdenv.hostPlatform.isLittleEndian then
+          packages.ghc924
         else
-          packages.ghc8107Binary;
+          packages.ghc922Binary;
       inherit (buildPackages.python3Packages) sphinx;
       # Need to use apple's patched xattr until
       # https://github.com/xattr/xattr/issues/44 and
       # https://github.com/xattr/xattr/issues/55 are solved.
       inherit (buildPackages.darwin) xattr autoSignDarwinBinariesHook;
+      # 2022-08-04: Support range >= 10 && < 14
       buildTargetLlvmPackages = pkgsBuildTarget.llvmPackages_12;
       llvmPackages = pkgs.llvmPackages_12;
-      libffi = pkgs.libffi;
     };
 
     ghcjs = compiler.ghcjs810;