Merge staging-next into staging

maintainers/maintainer-list.nix

···
     githubId = 1488603;
     name = "François Espinet";
   };
+  neverbehave = {
+    email = "[e-mail]";
+    github = "NeverBehave";
+    githubId = 17120571;
+    name = "Xinhao Luo";
+  };
   nikitavoloboev = {
     email = "[e-mail]";
     github = "nikitavoloboev";

pkgs/applications/editors/netbeans/default.nix

···
 }:
 
 let
-  version = "12.2";
+  version = "12.3";
   desktopItem = makeDesktopItem {
     name = "netbeans";
     exec = "netbeans";
···
   inherit version;
   src = fetchurl {
     url = "mirror://apache/netbeans/netbeans/${version}/netbeans-${version}-bin.zip";
-    sha512 = "b25cda9830e8fe1d05687b08cc5fa9bcac7e8e6d12776998a4da7e483b3be0d04493345e56be7e6198fa8f86428d57d4459bfa7372c2e3f918f4a1101d0a31a7";
+    sha512 = "2fy696qrfbdkzmq4cwd6l7v6rsc0bf9akh61w3azc544bq3vxl3v6s31hvg3ba0nsh0jv3nbdrk6jp1l4hwgcg9zg7kf2012a1vv2nk";
   };
 
   buildCommand = ''

pkgs/applications/misc/archivy/default.nix

···
-{ lib, python3, fetchPypi, appdirs, attrs, requests,
-beautifulsoup4, click-plugins, elasticsearch, flask_login, flask_wtf,
-pypandoc, python-dotenv, python-frontmatter, tinydb, validators,
-watchdog, wtforms, html2text, flask-compress }:
+{ lib, buildPythonApplication, fetchPypi, appdirs, attrs
+, beautifulsoup4, click-plugins, elasticsearch, flask-compress
+, flask_login, flask_wtf, html2text, python-dotenv, python-frontmatter
+, requests, tinydb, validators, werkzeug, wtforms }:
 
-python3.pkgs.buildPythonApplication rec {
+buildPythonApplication rec {
   pname = "archivy";
-  version = "1.0.2";
+  version = "1.1.1";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "6f706b925175852d8101a4afe2304ab7ee7d56e9658538b9a8e49e925978b87e";
+    sha256 = "sha256-yUXsTPb5oJYZA9MlHz7eLowRjD/ltq5VLTHeOMqcL/M=";
   };
 
   # Relax some dependencies
···
     beautifulsoup4
     click-plugins
     elasticsearch
+    flask-compress
     flask_login
     flask_wtf
-    pypandoc
+    html2text
     python-dotenv
     python-frontmatter
-    tinydb
     requests
+    tinydb
     validators
-    watchdog
+    werkzeug
     wtforms
-    html2text
-    flask-compress
   ];
 
   # __init__.py attempts to mkdir in read-only file system

pkgs/applications/networking/nextcloud-client/default.nix

···
     sqlite
   ];
 
+  qtWrapperArgs = [
+    "--prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ libsecret ]}"
+  ];
+
   cmakeFlags = [
     "-DCMAKE_INSTALL_LIBDIR=lib" # expected to be prefix-relative by build code setting RPATH
     "-DNO_SHIBBOLETH=1" # allows to compile without qtwebkit

pkgs/applications/video/corrscope/default.nix

···
+{ lib
+, mkDerivationWith
+, python3Packages
+, wrapQtAppsHook
+, ffmpeg
+, qtbase
+}:
+
+mkDerivationWith python3Packages.buildPythonApplication rec {
+  pname = "corrscope";
+  version = "0.7.0";
+
+  src = python3Packages.fetchPypi {
+    inherit pname version;
+    sha256 = "0m62p3jlbx5dlp3j8wn1ka1sqpffsxbpsgv2h5cvj1n1lsgbss2s";
+  };
+
+  postPatch = ''
+    substituteInPlace setup.py \
+      --replace 'attrs>=18.2.0,<19.0.0' 'attrs>=18.2.0' \
+      --replace 'numpy>=1.15,<2.0,!=1.19.4' 'numpy>=1.15,<2.0'
+  '';
+
+  nativeBuildInputs = [ wrapQtAppsHook ];
+
+  buildInputs = [ ffmpeg qtbase ];
+
+  propagatedBuildInputs = with python3Packages; [ appdirs attrs click matplotlib numpy pyqt5 ruamel_yaml ];
+
+  dontWrapQtApps = true;
+
+  preFixup = ''
+    makeWrapperArgs+=(
+      --prefix PATH : ${ffmpeg}/bin
+      "''${qtWrapperArgs[@]}"
+    )
+  '';
+
+  preCheck = "export HOME=$TEMP";
+
+  meta = with lib; {
+    description = "Render wave files into oscilloscope views, featuring advanced correlation-based triggering algorithm";
+    longDescription = ''
+      Corrscope renders oscilloscope views of WAV files recorded from chiptune (game music from
+      retro sound chips).
+
+      Corrscope uses "waveform correlation" to track complex waves (including SNES and Sega
+      Genesis/FM synthesis) which jump around on other oscilloscope programs.
+    '';
+    homepage = "https://github.com/corrscope/corrscope";
+    license = licenses.bsd2;
+    maintainers = with maintainers; [ OPNA2608 ];
+    platforms = platforms.all;
+  };
+}

pkgs/data/misc/hackage/default.nix

···
 { fetchurl }:
 
 fetchurl {
-  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/c0fe8e827d5ec71141700f5d5a90a6f6616ecbc5.tar.gz";
-  sha256 = "16is1cipkfiabbh01i247vqfviwzjpfhgf6pkli61wwlhnk0q95s";
+  url = "https://github.com/commercialhaskell/all-cabal-hashes/archive/fd3fefef13b49cbcd9a08b46c2aa4ceb204de5e0.tar.gz";
+  sha256 = "1dr4bqsisizw3qn9qxjpbk0rjri6s0gv9g9717cwfcixy940af2s";
 }

pkgs/data/themes/juno/default.nix

···
+{ lib, stdenv, fetchurl, gtk-engine-murrine }:
+
+stdenv.mkDerivation rec {
+  pname = "juno";
+  version = "0.0.1";
+
+  srcs = [
+    (fetchurl {
+      url = "https://github.com/gvolpe/Juno/releases/download/${version}/Juno.tar.xz";
+      sha256 = "1cghsn9qagcf1nlga5cal0aqch6hkjm5wk6ja791zxhdqy3crx1i";
+    })
+    (fetchurl {
+      url = "https://github.com/gvolpe/Juno/releases/download/${version}/Juno-mirage.tar.xz";
+      sha256 = "0zh6bc85svmwh8qrhpn8mim0pj322x2x2i9sxnp7p1938p5z5m2b";
+    })
+    (fetchurl {
+      url = "https://github.com/gvolpe/Juno/releases/download/${version}/Juno-ocean.tar.xz";
+      sha256 = "0m2wgmcn12dfq5badzlpzjc8792ba9hi32c79vfvqawdn1q3hrdx";
+    })
+    (fetchurl {
+      url = "https://github.com/gvolpe/Juno/releases/download/${version}/Juno-palenight.tar.xz";
+      sha256 = "1hn2l0m76x61ixjd253hi7czm65asdjdhqvvlv7idbccc40pvrak";
+    })
+  ];
+
+  sourceRoot = ".";
+
+  propagatedUserEnvPkgs = [ gtk-engine-murrine ];
+
+  installPhase = ''
+    runHook preInstall
+    mkdir -p $out/share/themes
+    cp -a Juno* $out/share/themes
+    rm $out/share/themes/*/{LICENSE,README.md}
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "GTK themes inspired by epic vscode themes";
+    homepage = "https://github.com/EliverLara/Juno";
+    license = licenses.gpl3Only;
+    platforms = platforms.all;
+    maintainers = [ maintainers.gvolpe ];
+  };
+}

pkgs/development/compilers/elm/default.nix

···
 { lib, stdenv, pkgs
-, haskell, nodejs
+, haskell, haskellPackages, nodejs
 , fetchurl, fetchpatch, makeWrapper, writeScriptBin
   # Rust dependecies
 , rustPlatform, openssl, pkg-config, Security
···
 let
   fetchElmDeps = import ./fetchElmDeps.nix { inherit stdenv lib fetchurl; };
 
-  hsPkgs = haskell.packages.ghc8103.override {
+  hsPkgs = haskellPackages.override {
     overrides = self: super: with haskell.lib; with lib;
       let elmPkgs = rec {
             elm = overrideCabal (self.callPackage ./packages/elm.nix { }) (drv: {

pkgs/development/compilers/ghc/8.10.1.nix

···
-{ lib, stdenv, pkgsBuildTarget, targetPackages
-
-# build-tools
-, bootPkgs
-, autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx
-, bash
-
-, libiconv ? null, ncurses
-
-, # GHC can be built with system libffi or a bundled one.
-  libffi ? null
-
-, useLLVM ? !stdenv.targetPlatform.isx86
-, # LLVM is conceptually a run-time-only depedendency, but for
-  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
-  # build-time dependency too.
-  buildLlvmPackages, llvmPackages
-
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp
-
-, # If enabled, use -fPIC when compiling static libs.
-  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
-
-  # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
-
-, # Whether to build dynamic libs for the standard library (on the target
-  # platform). Static libs are always built.
-  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
-
-, # Whether to build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
-
-, # What flavour to build. An empty string indicates no
-  # specific flavour and falls back to ghc default values.
-  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "perf-cross" else "perf-cross-ncg")
-
-, # Whether to disable the large address space allocator
-  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
-}:
-
-assert !enableIntegerSimple -> gmp != null;
-
-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
-    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
-  ''
-    # We only need to build stage1 on most cross-compilation because
-    # we will be running the compiler on the native system. In some
-    # situations, like native Musl compilation, we need the compiler
-    # to actually link to our new Libc. The iOS simulator is a special
-    # exception because we can’t actually run simulators binaries
-    # ourselves.
-  + lib.optionalString (targetPlatform != hostPlatform) ''
-    Stage1Only = ${if (targetPlatform.system == hostPlatform.system && !targetPlatform.isiOS) then "NO" else "YES"}
-    CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
-  '' + lib.optionalString dontStrip ''
-    STRIP_CMD = :
-  '' + lib.optionalString (!enableProfiledLibs) ''
-    GhcLibWays = "v dyn"
-  '' + lib.optionalString enableRelocatedStaticLibs ''
-    GhcLibHcOpts += -fPIC
-    GhcRtsHcOpts += -fPIC
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    EXTRA_CC_OPTS += -std=gnu99
-  '';
-
-  # Splicer will pull out correct variations
-  libDeps = platform: lib.optional enableTerminfo ncurses
-    ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
-
-  toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
-  ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
-
-  targetCC = builtins.head toolsForTarget;
-
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
-  # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
-
-in
-stdenv.mkDerivation (rec {
-  version = "8.10.1";
-  name = "${targetPrefix}ghc-${version}";
-
-  src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
-    sha256 = "1xgdl6ig5jzli3bg054vfryfkg0y6wggf68g66c32sr67bw0ffsf";
-  };
-
-  enableParallelBuilding = true;
-
-  outputs = [ "out" "doc" ];
-
-  patches = [
-    # See upstream patch at
-    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
-    # from source distributions, the auto-generated configure script needs to be
-    # patched as well, therefore we use an in-tree patch instead of pulling the
-    # upstream patch. Don't forget to check backport status of the upstream patch
-    # when adding new GHC releases in nixpkgs.
-    ./respect-ar-path.patch
-  ];
-
-  postPatch = "patchShebangs .";
-
-  # GHC is a bit confused on its cross terminology.
-  preConfigure = ''
-    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
-      export "''${env#TARGET_}=''${!env}"
-    done
-    # GHC is a bit confused on its cross terminology, as these would normally be
-    # the *host* tools.
-    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
-    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
-    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
-    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
-    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
-    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
-    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
-    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
-    export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"
-
-    echo -n "${buildMK dontStrip}" > mk/build.mk
-    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"
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
-  '' + lib.optionalString targetPlatform.isMusl ''
-      echo "patching llvm-targets for musl targets..."
-      echo "Cloning these existing '*-linux-gnu*' targets:"
-      grep linux-gnu llvm-targets | sed 's/^/  /'
-      echo "(go go gadget sed)"
-      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
-      echo "llvm-targets now contains these '*-linux-musl*' targets:"
-      grep linux-musl llvm-targets | sed 's/^/  /'
-
-      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
-      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
-      for x in configure aclocal.m4; do
-        substituteInPlace $x \
-          --replace '*-android*|*-gnueabi*)' \
-                    '*-android*|*-gnueabi*|*-musleabi*)'
-      done
-  '';
-
-  # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ]
-    ++ lib.optional (targetPlatform != hostPlatform) "target";
-
-  # `--with` flags for libraries needed for RTS linker
-  configureFlags = [
-    "--datadir=$doc/share/doc/ghc"
-    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) [
-    "--with-system-libffi"
-    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
-    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
-    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
-    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
-    "--with-iconv-includes=${libiconv}/include"
-    "--with-iconv-libraries=${libiconv}/lib"
-  ] ++ lib.optionals (targetPlatform != hostPlatform) [
-    "--enable-bootstrap-with-devel-snapshot"
-  ] ++ lib.optionals useLdGold [
-    "CFLAGS=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-  ] ++ lib.optionals (disableLargeAddressSpace) [
-    "--disable-large-address-space"
-  ];
-
-  # Make sure we never relax`$PATH` and hooks support for compatibility.
-  strictDeps = true;
-
-  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
-  dontAddExtraLibs = true;
-
-  nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
-    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
-  ];
-
-  # For building runtime libs
-  depsBuildTarget = toolsForTarget;
-
-  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
-
-  propagatedBuildInputs = [ targetPackages.stdenv.cc ]
-    ++ lib.optional useLLVM llvmPackages.llvm;
-
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
-
-  # required, because otherwise all symbols from HSffi.o are stripped, and
-  # that in turn causes GHCi to abort
-  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
-
-  checkTarget = "test";
-
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
-
-  postInstall = ''
-    # Install the bash completion file.
-    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
-
-    # Patch scripts to include "readelf" and "cat" in $PATH.
-    for i in "$out/bin/"*; do
-      test ! -h $i || continue
-      egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
-    done
-  '';
-
-  passthru = {
-    inherit bootPkgs targetPrefix;
-
-    inherit llvmPackages;
-    inherit enableShared;
-
-    # Our Cabal compiler name
-    haskellCompilerName = "ghc-${version}";
-  };
-
-  meta = {
-    homepage = "http://haskell.org/ghc";
-    description = "The Glasgow Haskell Compiler";
-    maintainers = with lib.maintainers; [ marcweber andres peti ];
-    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/8.10.2.nix

···
-{ lib, stdenv, pkgsBuildTarget, targetPackages
-
-# build-tools
-, bootPkgs
-, autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx
-, bash
-
-, libiconv ? null, ncurses
-
-, # GHC can be built with system libffi or a bundled one.
-  libffi ? null
-
-, useLLVM ? !stdenv.targetPlatform.isx86
-, # LLVM is conceptually a run-time-only depedendency, but for
-  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
-  # build-time dependency too.
-  buildLlvmPackages, llvmPackages
-
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp
-
-, # If enabled, use -fPIC when compiling static libs.
-  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
-
-  # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
-
-, # Whether to build dynamic libs for the standard library (on the target
-  # platform). Static libs are always built.
-  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
-
-, # Whether to build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
-
-, # What flavour to build. An empty string indicates no
-  # specific flavour and falls back to ghc default values.
-  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "perf-cross" else "perf-cross-ncg")
-
-, # Whether to disable the large address space allocator
-  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
-}:
-
-assert !enableIntegerSimple -> gmp != null;
-
-let
-  inherit (stdenv) buildPlatform hostPlatform targetPlatform;
-
-  inherit (bootPkgs) ghc;
-
-  # TODO(@Ericson2314) Make unconditional
-  targetPrefix = lib.optionalString
-    (targetPlatform != hostPlatform)
-    "${targetPlatform.config}-";
-
-  buildMK = ''
-    BuildFlavour = ${ghcFlavour}
-    ifneq \"\$(BuildFlavour)\" \"\"
-    include mk/flavours/\$(BuildFlavour).mk
-    endif
-    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
-  '' + lib.optionalString (targetPlatform != hostPlatform) ''
-    Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
-    CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
-  '' + lib.optionalString (!enableProfiledLibs) ''
-    GhcLibWays = "v dyn"
-  '' + lib.optionalString enableRelocatedStaticLibs ''
-    GhcLibHcOpts += -fPIC
-    GhcRtsHcOpts += -fPIC
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    EXTRA_CC_OPTS += -std=gnu99
-  '';
-
-  # Splicer will pull out correct variations
-  libDeps = platform: lib.optional enableTerminfo ncurses
-    ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
-
-  toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
-  ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
-
-  targetCC = builtins.head toolsForTarget;
-
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
-  # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
-
-in
-stdenv.mkDerivation (rec {
-  version = "8.10.2";
-  name = "${targetPrefix}ghc-${version}";
-
-  src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
-    sha256 = "02w8n085bw38vyp694j0lfk5wcnwkdaj7hhp0saj71x74533lmww";
-  };
-
-  enableParallelBuilding = true;
-
-  outputs = [ "out" "doc" ];
-
-  patches = [
-    # See upstream patch at
-    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
-    # from source distributions, the auto-generated configure script needs to be
-    # patched as well, therefore we use an in-tree patch instead of pulling the
-    # upstream patch. Don't forget to check backport status of the upstream patch
-    # when adding new GHC releases in nixpkgs.
-    ./respect-ar-path.patch
-
-    # https://gitlab.haskell.org/ghc/ghc/-/issues/18549
-    ./issue-18549.patch
-  ] ++ lib.optionals stdenv.isDarwin [
-    # Make Block.h compile with c++ compilers. Remove with the next release
-    (fetchpatch {
-      url = "https://gitlab.haskell.org/ghc/ghc/-/commit/97d0b0a367e4c6a52a17c3299439ac7de129da24.patch";
-      sha256 = "0r4zjj0bv1x1m2dgxp3adsf2xkr94fjnyj1igsivd9ilbs5ja0b5";
-    })
-  ];
-
-  postPatch = "patchShebangs .";
-
-  # GHC is a bit confused on its cross terminology.
-  preConfigure = ''
-    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
-      export "''${env#TARGET_}=''${!env}"
-    done
-    # GHC is a bit confused on its cross terminology, as these would normally be
-    # the *host* tools.
-    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
-    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
-    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
-    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
-    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
-    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
-    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
-    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
-    export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"
-
-    echo -n "${buildMK}" > mk/build.mk
-    sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
-  '' + lib.optionalString (!stdenv.isDarwin) ''
-    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
-  '' + lib.optionalString stdenv.isDarwin ''
-    export NIX_LDFLAGS+=" -no_dtrace_dof"
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
-  '' + lib.optionalString targetPlatform.isMusl ''
-      echo "patching llvm-targets for musl targets..."
-      echo "Cloning these existing '*-linux-gnu*' targets:"
-      grep linux-gnu llvm-targets | sed 's/^/  /'
-      echo "(go go gadget sed)"
-      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
-      echo "llvm-targets now contains these '*-linux-musl*' targets:"
-      grep linux-musl llvm-targets | sed 's/^/  /'
-
-      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
-      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
-      for x in configure aclocal.m4; do
-        substituteInPlace $x \
-          --replace '*-android*|*-gnueabi*)' \
-                    '*-android*|*-gnueabi*|*-musleabi*)'
-      done
-  '';
-
-  # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ]
-    ++ lib.optional (targetPlatform != hostPlatform) "target";
-
-  # `--with` flags for libraries needed for RTS linker
-  configureFlags = [
-    "--datadir=$doc/share/doc/ghc"
-    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) [
-    "--with-system-libffi"
-    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
-    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
-    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
-    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
-    "--with-iconv-includes=${libiconv}/include"
-    "--with-iconv-libraries=${libiconv}/lib"
-  ] ++ lib.optionals (targetPlatform != hostPlatform) [
-    "--enable-bootstrap-with-devel-snapshot"
-  ] ++ lib.optionals useLdGold [
-    "CFLAGS=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-  ] ++ lib.optionals (disableLargeAddressSpace) [
-    "--disable-large-address-space"
-  ];
-
-  # Make sure we never relax`$PATH` and hooks support for compatibility.
-  strictDeps = true;
-
-  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
-  dontAddExtraLibs = true;
-
-  nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
-    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
-  ];
-
-  # For building runtime libs
-  depsBuildTarget = toolsForTarget;
-
-  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
-
-  propagatedBuildInputs = [ targetPackages.stdenv.cc ]
-    ++ lib.optional useLLVM llvmPackages.llvm;
-
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
-
-  # required, because otherwise all symbols from HSffi.o are stripped, and
-  # that in turn causes GHCi to abort
-  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
-
-  checkTarget = "test";
-
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
-
-  postInstall = ''
-    # Install the bash completion file.
-    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
-
-    # Patch scripts to include "readelf" and "cat" in $PATH.
-    for i in "$out/bin/"*; do
-      test ! -h $i || continue
-      egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
-    done
-  '';
-
-  passthru = {
-    inherit bootPkgs targetPrefix;
-
-    inherit llvmPackages;
-    inherit enableShared;
-
-    # Our Cabal compiler name
-    haskellCompilerName = "ghc-${version}";
-  };
-
-  meta = {
-    homepage = "http://haskell.org/ghc";
-    description = "The Glasgow Haskell Compiler";
-    maintainers = with lib.maintainers; [ marcweber andres peti ];
-    timeout = 24 * 3600;
-    inherit (ghc.meta) license platforms;
-  };
-
-} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
-  dontStrip = true;
-  dontPatchELF = true;
-  noAuditTmpdir = true;
-})

pkgs/development/compilers/ghc/8.10.3.nix

···
-{ lib, stdenv, pkgsBuildTarget, targetPackages
-
-# build-tools
-, bootPkgs
-, autoconf, automake, coreutils, fetchpatch, fetchurl, perl, python3, m4, sphinx
-, bash
-
-, libiconv ? null, ncurses
-
-, # GHC can be built with system libffi or a bundled one.
-  libffi ? null
-
-, useLLVM ? !stdenv.targetPlatform.isx86
-, # LLVM is conceptually a run-time-only depedendency, but for
-  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
-  # build-time dependency too.
-  buildLlvmPackages, llvmPackages
-
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp
-
-, # If enabled, use -fPIC when compiling static libs.
-  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
-
-  # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
-
-, # Whether to build dynamic libs for the standard library (on the target
-  # platform). Static libs are always built.
-  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
-
-, # Whether to build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
-
-, # What flavour to build. An empty string indicates no
-  # specific flavour and falls back to ghc default values.
-  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "perf-cross" else "perf-cross-ncg")
-
-, # Whether to disable the large address space allocator
-  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
-}:
-
-assert !enableIntegerSimple -> gmp != null;
-
-let
-  inherit (stdenv) buildPlatform hostPlatform targetPlatform;
-
-  inherit (bootPkgs) ghc;
-
-  # TODO(@Ericson2314) Make unconditional
-  targetPrefix = lib.optionalString
-    (targetPlatform != hostPlatform)
-    "${targetPlatform.config}-";
-
-  buildMK = ''
-    BuildFlavour = ${ghcFlavour}
-    ifneq \"\$(BuildFlavour)\" \"\"
-    include mk/flavours/\$(BuildFlavour).mk
-    endif
-    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
-  '' + lib.optionalString (targetPlatform != hostPlatform) ''
-    Stage1Only = ${if targetPlatform.system == hostPlatform.system then "NO" else "YES"}
-    CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
-  '' + lib.optionalString (!enableProfiledLibs) ''
-    GhcLibWays = "v dyn"
-  '' + lib.optionalString enableRelocatedStaticLibs ''
-    GhcLibHcOpts += -fPIC
-    GhcRtsHcOpts += -fPIC
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    EXTRA_CC_OPTS += -std=gnu99
-  '';
-
-  # Splicer will pull out correct variations
-  libDeps = platform: lib.optional enableTerminfo ncurses
-    ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
-
-  toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
-  ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
-
-  targetCC = builtins.head toolsForTarget;
-
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
-  # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
-
-in
-stdenv.mkDerivation (rec {
-  version = "8.10.3";
-  name = "${targetPrefix}ghc-${version}";
-
-  src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
-    sha256 = "0cdrdvs5qnqr93cr9zvrlfjv2xr671kjjghnsw4afa4hahcq7p6c";
-  };
-
-  enableParallelBuilding = true;
-
-  outputs = [ "out" "doc" ];
-
-  patches = [
-    # See upstream patch at
-    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
-    # from source distributions, the auto-generated configure script needs to be
-    # patched as well, therefore we use an in-tree patch instead of pulling the
-    # upstream patch. Don't forget to check backport status of the upstream patch
-    # when adding new GHC releases in nixpkgs.
-    ./respect-ar-path.patch
-  ] ++ lib.optionals stdenv.isDarwin [
-    # Make Block.h compile with c++ compilers. Remove with the next release
-    (fetchpatch {
-      url = "https://gitlab.haskell.org/ghc/ghc/-/commit/97d0b0a367e4c6a52a17c3299439ac7de129da24.patch";
-      sha256 = "0r4zjj0bv1x1m2dgxp3adsf2xkr94fjnyj1igsivd9ilbs5ja0b5";
-    })
-  ];
-
-  postPatch = "patchShebangs .";
-
-  # GHC is a bit confused on its cross terminology.
-  preConfigure = ''
-    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
-      export "''${env#TARGET_}=''${!env}"
-    done
-    # GHC is a bit confused on its cross terminology, as these would normally be
-    # the *host* tools.
-    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
-    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
-    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
-    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
-    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
-    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
-    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
-    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
-    export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"
-
-    echo -n "${buildMK}" > mk/build.mk
-    sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
-  '' + lib.optionalString (!stdenv.isDarwin) ''
-    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
-  '' + lib.optionalString stdenv.isDarwin ''
-    export NIX_LDFLAGS+=" -no_dtrace_dof"
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
-  '' + lib.optionalString targetPlatform.isMusl ''
-      echo "patching llvm-targets for musl targets..."
-      echo "Cloning these existing '*-linux-gnu*' targets:"
-      grep linux-gnu llvm-targets | sed 's/^/  /'
-      echo "(go go gadget sed)"
-      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
-      echo "llvm-targets now contains these '*-linux-musl*' targets:"
-      grep linux-musl llvm-targets | sed 's/^/  /'
-
-      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
-      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
-      for x in configure aclocal.m4; do
-        substituteInPlace $x \
-          --replace '*-android*|*-gnueabi*)' \
-                    '*-android*|*-gnueabi*|*-musleabi*)'
-      done
-  '';
-
-  # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ]
-    ++ lib.optional (targetPlatform != hostPlatform) "target";
-
-  # `--with` flags for libraries needed for RTS linker
-  configureFlags = [
-    "--datadir=$doc/share/doc/ghc"
-    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) [
-    "--with-system-libffi"
-    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
-    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
-    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
-    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
-    "--with-iconv-includes=${libiconv}/include"
-    "--with-iconv-libraries=${libiconv}/lib"
-  ] ++ lib.optionals (targetPlatform != hostPlatform) [
-    "--enable-bootstrap-with-devel-snapshot"
-  ] ++ lib.optionals useLdGold [
-    "CFLAGS=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-  ] ++ lib.optionals (disableLargeAddressSpace) [
-    "--disable-large-address-space"
-  ];
-
-  # Make sure we never relax`$PATH` and hooks support for compatibility.
-  strictDeps = true;
-
-  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
-  dontAddExtraLibs = true;
-
-  nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
-    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
-  ];
-
-  # For building runtime libs
-  depsBuildTarget = toolsForTarget;
-
-  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
-
-  propagatedBuildInputs = [ targetPackages.stdenv.cc ]
-    ++ lib.optional useLLVM llvmPackages.llvm;
-
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
-
-  # required, because otherwise all symbols from HSffi.o are stripped, and
-  # that in turn causes GHCi to abort
-  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
-
-  checkTarget = "test";
-
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
-
-  postInstall = ''
-    # Install the bash completion file.
-    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
-
-    # Patch scripts to include "readelf" and "cat" in $PATH.
-    for i in "$out/bin/"*; do
-      test ! -h $i || continue
-      egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
-    done
-  '';
-
-  passthru = {
-    inherit bootPkgs targetPrefix;
-
-    inherit llvmPackages;
-    inherit enableShared;
-
-    # Our Cabal compiler name
-    haskellCompilerName = "ghc-${version}";
-  };
-
-  meta = {
-    homepage = "http://haskell.org/ghc";
-    description = "The Glasgow Haskell Compiler";
-    maintainers = with lib.maintainers; [ marcweber andres peti ];
-    timeout = 24 * 3600;
-    inherit (ghc.meta) license platforms;
-  };
-
-} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
-  dontStrip = true;
-  dontPatchELF = true;
-  noAuditTmpdir = true;
-})

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

···
-{ lib, stdenv, substituteAll
-, fetchurl, perl, gcc, llvm
-, ncurses5, gmp, glibc, libiconv
-, llvmPackages
-}:
-
-# Prebuilt only does native
-assert stdenv.targetPlatform == stdenv.hostPlatform;
-
-let
-  useLLVM = !stdenv.targetPlatform.isx86;
-
-  libPath = lib.makeLibraryPath ([
-    ncurses5 gmp
-  ] ++ lib.optional (stdenv.hostPlatform.isDarwin) libiconv);
-
-  libEnvVar = lib.optionalString stdenv.hostPlatform.isDarwin "DY"
-    + "LD_LIBRARY_PATH";
-
-  glibcDynLinker = assert stdenv.isLinux;
-    if stdenv.hostPlatform.libc == "glibc" then
-       # Could be stdenv.cc.bintools.dynamicLinker, keeping as-is to avoid rebuild.
-       ''"$(cat $NIX_CC/nix-support/dynamic-linker)"''
-    else
-      "${lib.getLib glibc}/lib/ld-linux*";
-
-in
-
-stdenv.mkDerivation rec {
-  version = "8.2.2";
-
-  name = "ghc-${version}-binary";
-
-  src = fetchurl ({
-    i686-linux = {
-      url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-i386-deb8-linux.tar.xz";
-      sha256 = "08w2ik55dp3n95qikmrflc91lsiq01xp53ki3jlhnbj8fqnxfrwy";
-    };
-    x86_64-linux = {
-      url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-deb8-linux.tar.xz";
-      sha256 = "0ahv26304pqi3dm7i78si4pxwvg5f5dc2jwsfgvcrhcx5g30bqj8";
-    };
-    armv7l-linux = {
-      url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-armv7-deb8-linux.tar.xz";
-      sha256 = "1jmv8qmnh5bn324fivbwdcaj55kvw7cb2zq9pafmlmv3qwwx7s46";
-    };
-    aarch64-linux = {
-      url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-aarch64-deb8-linux.tar.xz";
-      sha256 = "1k2amylcp1ad67c75h1pqf7czf9m0zj1i7hdc45ghjklnfq9hrk7";
-    };
-    x86_64-darwin = {
-      url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
-      sha256 = "09swx71gh5habzbx55shz2xykgr96xkcy09nzinnm4z0yxicy3zr";
-    };
-  }.${stdenv.hostPlatform.system}
-    or (throw "cannot bootstrap GHC on this platform"));
-
-  nativeBuildInputs = [ perl ];
-  propagatedBuildInputs = lib.optionals useLLVM [ llvmPackages.llvm ];
-
-  # Cannot patchelf beforehand due to relative RPATHs that anticipate
-  # the final install location/
-  ${libEnvVar} = libPath;
-
-  postUnpack =
-    # GHC has dtrace probes, which causes ld to try to open /usr/lib/libdtrace.dylib
-    # during linking
-    lib.optionalString stdenv.isDarwin ''
-      export NIX_LDFLAGS+=" -no_dtrace_dof"
-      # not enough room in the object files for the full path to libiconv :(
-      for exe in $(find . -type f -executable); do
-        isScript $exe && continue
-        ln -fs ${libiconv}/lib/libiconv.dylib $(dirname $exe)/libiconv.dylib
-        install_name_tool -change /usr/lib/libiconv.2.dylib @executable_path/libiconv.dylib -change /usr/local/lib/gcc/6/libgcc_s.1.dylib ${gcc.cc.lib}/lib/libgcc_s.1.dylib $exe
-      done
-    '' +
-
-    # Some scripts used during the build need to have their shebangs patched
-    ''
-      patchShebangs ghc-${version}/utils/
-      patchShebangs ghc-${version}/configure
-    '' +
-
-    # Strip is harmful, see also below. It's important that this happens
-    # first. The GHC Cabal build system makes use of strip by default and
-    # has hardcoded paths to /usr/bin/strip in many places. We replace
-    # those below, making them point to our dummy script.
-    ''
-      mkdir "$TMP/bin"
-      for i in strip; do
-        echo '#! ${stdenv.shell}' > "$TMP/bin/$i"
-        chmod +x "$TMP/bin/$i"
-      done
-      PATH="$TMP/bin:$PATH"
-    '' +
-    # We have to patch the GMP paths for the integer-gmp package.
-    ''
-      find . -name integer-gmp.buildinfo \
-          -exec sed -i "s@extra-lib-dirs: @extra-lib-dirs: ${gmp.out}/lib@" {} \;
-    '' + lib.optionalString stdenv.isDarwin ''
-      find . -name base.buildinfo \
-          -exec sed -i "s@extra-lib-dirs: @extra-lib-dirs: ${libiconv}/lib@" {} \;
-    '' +
-    # Rename needed libraries and binaries, fix interpreter
-    lib.optionalString stdenv.isLinux ''
-      find . -type f -perm -0100 -exec patchelf \
-          --replace-needed libncurses${lib.optionalString stdenv.is64bit "w"}.so.5 libncurses.so \
-          --replace-needed libtinfo.so libtinfo.so.5 \
-          --interpreter ${glibcDynLinker} {} \;
-
-      sed -i "s|/usr/bin/perl|perl\x00        |" ghc-${version}/ghc/stage2/build/tmp/ghc-stage2
-      sed -i "s|/usr/bin/gcc|gcc\x00        |" ghc-${version}/ghc/stage2/build/tmp/ghc-stage2
-    '' +
-    # We're kludging a glibc bindist into working with non-glibc...
-    # Here we patch up the use of `__strdup` (part of glibc binary ABI)
-    # to instead use `strdup` since musl doesn't provide __strdup
-    # (`__strdup` is defined to be an alias of `strdup` anyway[1]).
-    # [1] http://refspecs.linuxbase.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/baselib---strdup-1.html
-    # Use objcopy magic to make the change:
-    lib.optionalString stdenv.hostPlatform.isMusl ''
-      find ./ghc-${version}/rts -name "libHSrts*.a" -exec ''${OBJCOPY:-objcopy} --redefine-sym __strdup=strdup {} \;
-    '';
-
-  configurePlatforms = [ ];
-  configureFlags =
-  let
-    gcc-clang-wrapper = substituteAll {
-      inherit (stdenv) shell;
-      isExecutable = true;
-      src = ./gcc-clang-wrapper.sh;
-    };
-  in
-  [ "--with-gmp-libraries=${lib.getLib gmp}/lib"
-    "--with-gmp-includes=${lib.getDev gmp}/include"
-  ] ++ lib.optional stdenv.isDarwin            "--with-gcc=${gcc-clang-wrapper}"
-    ++ lib.optional stdenv.hostPlatform.isMusl "--disable-ld-override";
-
-  # Stripping combined with patchelf breaks the executables (they die
-  # with a segfault or the kernel even refuses the execve). (NIXPKGS-85)
-  dontStrip = true;
-
-  # No building is necessary, but calling make without flags ironically
-  # calls install-strip ...
-  dontBuild = true;
-
-  # On Linux, use patchelf to modify the executables so that they can
-  # find editline/gmp.
-  preFixup = lib.optionalString stdenv.isLinux ''
-    for p in $(find "$out" -type f -executable); do
-      if isELF "$p"; then
-        echo "Patchelfing $p"
-        patchelf --set-rpath "${libPath}:$(patchelf --print-rpath $p)" $p
-      fi
-    done
-  '' + lib.optionalString stdenv.isDarwin ''
-    # not enough room in the object files for the full path to libiconv :(
-    for exe in $(find "$out" -type f -executable); do
-      isScript $exe && continue
-      ln -fs ${libiconv}/lib/libiconv.dylib $(dirname $exe)/libiconv.dylib
-      install_name_tool -change /usr/lib/libiconv.2.dylib @executable_path/libiconv.dylib -change /usr/local/lib/gcc/6/libgcc_s.1.dylib ${gcc.cc.lib}/lib/libgcc_s.1.dylib $exe
-    done
-
-    for file in $(find "$out" -name setup-config); do
-      substituteInPlace $file --replace /usr/bin/ranlib "$(type -P ranlib)"
-    done
-  '';
-
-  doInstallCheck = true;
-  installCheckPhase = ''
-    unset ${libEnvVar}
-    # Sanity check, can ghc create executables?
-    cd $TMP
-    mkdir test-ghc; cd test-ghc
-    cat > main.hs << EOF
-      {-# LANGUAGE TemplateHaskell #-}
-      module Main where
-      main = putStrLn \$([|"yes"|])
-    EOF
-    $out/bin/ghc --make main.hs || exit 1
-    echo compilation ok
-    [ $(./main) == "yes" ]
-  '';
-
-  passthru = {
-    targetPrefix = "";
-    enableShared = true;
-  };
-
-  meta.license = lib.licenses.bsd3;
-  meta.platforms = ["x86_64-linux" "i686-linux" "x86_64-darwin" "armv7l-linux" "aarch64-linux"];
-}

pkgs/development/compilers/ghc/8.6.5.nix

···
-{ lib, stdenv, pkgsBuildTarget, targetPackages
-
-# build-tools
-, bootPkgs
-, autoconf, automake, coreutils, fetchurl, fetchpatch, perl, python3, m4, sphinx
-, bash
-
-, libiconv ? null, ncurses
-
-, # GHC can be built with system libffi or a bundled one.
-  libffi ? null
-
-, useLLVM ? !stdenv.targetPlatform.isx86 || stdenv.targetPlatform.isiOS
-, # LLVM is conceptually a run-time-only depedendency, but for
-  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
-  # build-time dependency too.
-  buildLlvmPackages, llvmPackages
-
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp
-
-, # If enabled, use -fPIC when compiling static libs.
-  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
-
-, # Whether to build dynamic libs for the standard library (on the target
-  # platform). Static libs are always built.
-  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
-
-, # Whether to build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
-
-, # What flavour to build. An empty string indicates no
-  # specific flavour and falls back to ghc default values.
-  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "perf-cross" else "perf-cross-ncg")
-
-, # Whether to disable the large address space allocator
-  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
-}:
-
-assert !enableIntegerSimple -> gmp != null;
-
-let
-  inherit (stdenv) buildPlatform hostPlatform targetPlatform;
-
-  inherit (bootPkgs) ghc;
-
-  # TODO(@Ericson2314) Make unconditional
-  targetPrefix = lib.optionalString
-    (targetPlatform != hostPlatform)
-    "${targetPlatform.config}-";
-
-  buildMK = ''
-    BuildFlavour = ${ghcFlavour}
-    ifneq \"\$(BuildFlavour)\" \"\"
-    include mk/flavours/\$(BuildFlavour).mk
-    endif
-    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
-  ''
-    # We only need to build stage1 on most cross-compilation because
-    # we will be running the compiler on the native system. In some
-    # situations, like native Musl compilation, we need the compiler
-    # to actually link to our new Libc. The iOS simulator is a special
-    # exception because we can’t actually run simulators binaries
-    # ourselves.
-  + lib.optionalString (targetPlatform != hostPlatform) ''
-    Stage1Only = ${if (targetPlatform.system == hostPlatform.system && !targetPlatform.isiOS) then "NO" else "YES"}
-    CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
-  '' + lib.optionalString enableRelocatedStaticLibs ''
-    GhcLibHcOpts += -fPIC
-    GhcRtsHcOpts += -fPIC
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    EXTRA_CC_OPTS += -std=gnu99
-  '';
-
-  # Splicer will pull out correct variations
-  libDeps = platform: lib.optional enableTerminfo ncurses
-    ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
-
-  toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
-  ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
-
-  targetCC = builtins.head toolsForTarget;
-
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
-  # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
-
-in
-stdenv.mkDerivation (rec {
-  version = "8.6.5";
-  name = "${targetPrefix}ghc-${version}";
-
-  src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
-    sha256 = "0qg3zsmbk4rkwkc3jpas3zs74qaxmw4sp4v1mhsbj0a0dzls2jjd";
-  };
-
-  enableParallelBuilding = true;
-
-  outputs = [ "out" "doc" ];
-
-  patches = [
-    # See upstream patch at
-    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
-    # from source distributions, the auto-generated configure script needs to be
-    # patched as well, therefore we use an in-tree patch instead of pulling the
-    # upstream patch. Don't forget to check backport status of the upstream patch
-    # when adding new GHC releases in nixpkgs.
-    ./respect-ar-path.patch
-
-    (fetchpatch { # https://phabricator.haskell.org/D5123
-     url = "https://gitlab.haskell.org/ghc/ghc/-/commit/13ff0b7ced097286e0d7b054f050871effe07f86.diff";
-     name = "D5123.diff";
-     sha256 = "140lmnqxra7xkwy370c5pyf8dgdwgmbpcrs1dapnwr2dh8bavn8c";
-    })
-    (fetchpatch { # https://github.com/haskell/haddock/issues/900
-     url = "https://patch-diff.githubusercontent.com/raw/haskell/haddock/pull/983.diff";
-     name = "loadpluginsinmodules.diff";
-     sha256 = "0bvvv0zsfq2581zsir97zfkggc1kkircbbajc2fz3b169ycpbha1";
-     extraPrefix = "utils/haddock/";
-     stripLen = 1;
-   })
-  ];
-
-  postPatch = "patchShebangs .";
-
-  # GHC is a bit confused on its cross terminology.
-  preConfigure = ''
-    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
-      export "''${env#TARGET_}=''${!env}"
-    done
-    # GHC is a bit confused on its cross terminology, as these would normally be
-    # the *host* tools.
-    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
-    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
-    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
-    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
-    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
-    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
-    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
-    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
-    export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"
-
-    echo -n "${buildMK}" > mk/build.mk
-    sed -i -e 's|-isysroot /Developer/SDKs/MacOSX10.5.sdk||' configure
-  '' + lib.optionalString (!stdenv.isDarwin) ''
-    export NIX_LDFLAGS+=" -rpath $out/lib/ghc-${version}"
-  '' + lib.optionalString stdenv.isDarwin ''
-    export NIX_LDFLAGS+=" -no_dtrace_dof"
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
-  '' + lib.optionalString targetPlatform.isMusl ''
-      echo "patching llvm-targets for musl targets..."
-      echo "Cloning these existing '*-linux-gnu*' targets:"
-      grep linux-gnu llvm-targets | sed 's/^/  /'
-      echo "(go go gadget sed)"
-      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
-      echo "llvm-targets now contains these '*-linux-musl*' targets:"
-      grep linux-musl llvm-targets | sed 's/^/  /'
-
-      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
-      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
-      for x in configure aclocal.m4; do
-        substituteInPlace $x \
-          --replace '*-android*|*-gnueabi*)' \
-                    '*-android*|*-gnueabi*|*-musleabi*)'
-      done
-  '';
-
-  # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ]
-    ++ lib.optional (targetPlatform != hostPlatform) "target";
-  # `--with` flags for libraries needed for RTS linker
-  configureFlags = [
-    "--datadir=$doc/share/doc/ghc"
-    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) ["--with-system-libffi" "--with-ffi-includes=${targetPackages.libffi.dev}/include" "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
-    "--with-gmp-includes=${targetPackages.gmp.dev}/include" "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
-    "--with-iconv-includes=${libiconv}/include" "--with-iconv-libraries=${libiconv}/lib"
-  ] ++ lib.optionals (targetPlatform != hostPlatform) [
-    "--enable-bootstrap-with-devel-snapshot"
-  ] ++ lib.optionals useLdGold [
-    "CFLAGS=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-  ] ++ lib.optionals (disableLargeAddressSpace) [
-    "--disable-large-address-space"
-  ];
-
-  # Make sure we never relax`$PATH` and hooks support for compatibility.
-  strictDeps = true;
-
-  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
-  dontAddExtraLibs = true;
-
-  nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
-    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
-  ];
-
-  # For building runtime libs
-  depsBuildTarget = toolsForTarget;
-
-  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
-
-  propagatedBuildInputs = [ targetPackages.stdenv.cc ]
-    ++ lib.optional useLLVM llvmPackages.llvm;
-
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
-
-  # required, because otherwise all symbols from HSffi.o are stripped, and
-  # that in turn causes GHCi to abort
-  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
-
-  # See #63511 - the only unstripped file is the debug rts which isn't meant to
-  # be stripped.
-  dontStrip = true;
-
-  checkTarget = "test";
-
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
-
-  postInstall = ''
-    # Install the bash completion file.
-    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
-
-    # Patch scripts to include "readelf" and "cat" in $PATH.
-    for i in "$out/bin/"*; do
-      test ! -h $i || continue
-      egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
-    done
-  ''
-  # Temporary work-around for https://github.com/NixOS/nixpkgs/issues/66277
-  + lib.optionalString hostPlatform.isAarch64 ''
-    rm -rf "$doc/share/doc/ghc/html/libraries"
-  '';
-
-  passthru = {
-    inherit bootPkgs targetPrefix;
-
-    inherit llvmPackages;
-    inherit enableShared;
-
-    # Our Cabal compiler name
-    haskellCompilerName = "ghc-${version}";
-  };
-
-  meta = {
-    homepage = "http://haskell.org/ghc";
-    description = "The Glasgow Haskell Compiler";
-    maintainers = with lib.maintainers; [ marcweber andres peti ];
-    timeout = 24 * 3600;
-    inherit (ghc.meta) license platforms;
-  };
-
-} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt {
-  dontStrip = true;
-  dontPatchELF = true;
-  noAuditTmpdir = true;
-})

pkgs/development/compilers/ghc/8.8.2.nix

···
-{ lib, stdenv, pkgsBuildTarget, targetPackages
-
-# build-tools
-, bootPkgs
-, autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx
-, bash
-
-, libiconv ? null, ncurses
-
-, # GHC can be built with system libffi or a bundled one.
-  libffi ? null
-
-, useLLVM ? !stdenv.targetPlatform.isx86
-, # LLVM is conceptually a run-time-only depedendency, but for
-  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
-  # build-time dependency too.
-  buildLlvmPackages, llvmPackages
-
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp
-
-, # If enabled, use -fPIC when compiling static libs.
-  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
-
-, # Whether to build dynamic libs for the standard library (on the target
-  # platform). Static libs are always built.
-  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
-
-, # Whether to build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
-
-, # What flavour to build. An empty string indicates no
-  # specific flavour and falls back to ghc default values.
-  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "perf-cross" else "perf-cross-ncg")
-
-, # Whether to disable the large address space allocator
-  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
-}:
-
-assert !enableIntegerSimple -> gmp != null;
-
-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
-    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
-  ''
-    # We only need to build stage1 on most cross-compilation because
-    # we will be running the compiler on the native system. In some
-    # situations, like native Musl compilation, we need the compiler
-    # to actually link to our new Libc. The iOS simulator is a special
-    # exception because we can’t actually run simulators binaries
-    # ourselves.
-  + lib.optionalString (targetPlatform != hostPlatform) ''
-    Stage1Only = ${if (targetPlatform.system == hostPlatform.system && !targetPlatform.isiOS) then "NO" else "YES"}
-    CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
-  '' + lib.optionalString dontStrip ''
-    STRIP_CMD = :
-  '' + lib.optionalString enableRelocatedStaticLibs ''
-    GhcLibHcOpts += -fPIC
-    GhcRtsHcOpts += -fPIC
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    EXTRA_CC_OPTS += -std=gnu99
-  '';
-
-  # Splicer will pull out correct variations
-  libDeps = platform: lib.optional enableTerminfo ncurses
-    ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
-
-  toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
-  ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
-
-  targetCC = builtins.head toolsForTarget;
-
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
-  # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
-
-in
-stdenv.mkDerivation (rec {
-  version = "8.8.2";
-  name = "${targetPrefix}ghc-${version}";
-
-  src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
-    sha256 = "02qa6wgjpxgakg7hv4zfdlrx9k7zxa5i02wnr6y9fsv8j16sbkh1";
-  };
-
-  enableParallelBuilding = true;
-
-  outputs = [ "out" "doc" ];
-
-  patches = [
-    # See upstream patch at
-    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
-    # from source distributions, the auto-generated configure script needs to be
-    # patched as well, therefore we use an in-tree patch instead of pulling the
-    # upstream patch. Don't forget to check backport status of the upstream patch
-    # when adding new GHC releases in nixpkgs.
-    ./respect-ar-path.patch
-  ];
-
-  postPatch = "patchShebangs .";
-
-  # GHC is a bit confused on its cross terminology.
-  preConfigure = ''
-    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
-      export "''${env#TARGET_}=''${!env}"
-    done
-    # GHC is a bit confused on its cross terminology, as these would normally be
-    # the *host* tools.
-    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
-    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
-    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
-    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
-    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
-    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
-    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
-    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
-    export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"
-
-    echo -n "${buildMK dontStrip}" > mk/build.mk
-    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"
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
-  '' + lib.optionalString targetPlatform.isMusl ''
-      echo "patching llvm-targets for musl targets..."
-      echo "Cloning these existing '*-linux-gnu*' targets:"
-      grep linux-gnu llvm-targets | sed 's/^/  /'
-      echo "(go go gadget sed)"
-      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
-      echo "llvm-targets now contains these '*-linux-musl*' targets:"
-      grep linux-musl llvm-targets | sed 's/^/  /'
-
-      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
-      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
-      for x in configure aclocal.m4; do
-        substituteInPlace $x \
-          --replace '*-android*|*-gnueabi*)' \
-                    '*-android*|*-gnueabi*|*-musleabi*)'
-      done
-  '';
-
-  # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ]
-    ++ lib.optional (targetPlatform != hostPlatform) "target";
-
-  # `--with` flags for libraries needed for RTS linker
-  configureFlags = [
-    "--datadir=$doc/share/doc/ghc"
-    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) [
-    "--with-system-libffi"
-    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
-    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
-    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
-    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
-    "--with-iconv-includes=${libiconv}/include"
-    "--with-iconv-libraries=${libiconv}/lib"
-  ] ++ lib.optionals (targetPlatform != hostPlatform) [
-    "--enable-bootstrap-with-devel-snapshot"
-  ] ++ lib.optionals useLdGold [
-    "CFLAGS=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-  ] ++ lib.optionals (disableLargeAddressSpace) [
-    "--disable-large-address-space"
-  ];
-
-  # Make sure we never relax`$PATH` and hooks support for compatibility.
-  strictDeps = true;
-
-  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
-  dontAddExtraLibs = true;
-
-  nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
-    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
-  ];
-
-  # For building runtime libs
-  depsBuildTarget = toolsForTarget;
-
-  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
-
-  propagatedBuildInputs = [ targetPackages.stdenv.cc ]
-    ++ lib.optional useLLVM llvmPackages.llvm;
-
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
-
-  # required, because otherwise all symbols from HSffi.o are stripped, and
-  # that in turn causes GHCi to abort
-  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
-
-  checkTarget = "test";
-
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
-
-  postInstall = ''
-    # Install the bash completion file.
-    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
-
-    # Patch scripts to include "readelf" and "cat" in $PATH.
-    for i in "$out/bin/"*; do
-      test ! -h $i || continue
-      egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
-    done
-  '';
-
-  passthru = {
-    inherit bootPkgs targetPrefix;
-
-    inherit llvmPackages;
-    inherit enableShared;
-
-    # Our Cabal compiler name
-    haskellCompilerName = "ghc-${version}";
-  };
-
-  meta = {
-    homepage = "http://haskell.org/ghc";
-    description = "The Glasgow Haskell Compiler";
-    maintainers = with lib.maintainers; [ marcweber andres peti ];
-    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/8.8.3.nix

···
-{ lib, stdenv, pkgsBuildTarget, targetPackages
-
-# build-tools
-, bootPkgs
-, autoconf, automake, coreutils, fetchurl, perl, python3, m4, sphinx
-, bash
-
-, libiconv ? null, ncurses
-
-, # GHC can be built with system libffi or a bundled one.
-  libffi ? null
-
-, useLLVM ? !stdenv.targetPlatform.isx86
-, # LLVM is conceptually a run-time-only depedendency, but for
-  # non-x86, we need LLVM to bootstrap later stages, so it becomes a
-  # build-time dependency too.
-  buildLlvmPackages, llvmPackages
-
-, # If enabled, GHC will be built with the GPL-free but slower integer-simple
-  # library instead of the faster but GPLed integer-gmp library.
-  enableIntegerSimple ? !(lib.any (lib.meta.platformMatch stdenv.hostPlatform) gmp.meta.platforms), gmp
-
-, # If enabled, use -fPIC when compiling static libs.
-  enableRelocatedStaticLibs ? stdenv.targetPlatform != stdenv.hostPlatform
-
-  # aarch64 outputs otherwise exceed 2GB limit
-, enableProfiledLibs ? !stdenv.targetPlatform.isAarch64
-
-, # Whether to build dynamic libs for the standard library (on the target
-  # platform). Static libs are always built.
-  enableShared ? !stdenv.targetPlatform.isWindows && !stdenv.targetPlatform.useiOSPrebuilt
-
-, # Whether to build terminfo.
-  enableTerminfo ? !stdenv.targetPlatform.isWindows
-
-, # What flavour to build. An empty string indicates no
-  # specific flavour and falls back to ghc default values.
-  ghcFlavour ? lib.optionalString (stdenv.targetPlatform != stdenv.hostPlatform)
-    (if useLLVM then "perf-cross" else "perf-cross-ncg")
-
-, # Whether to disable the large address space allocator
-  # necessary fix for iOS: https://www.reddit.com/r/haskell/comments/4ttdz1/building_an_osxi386_to_iosarm64_cross_compiler/d5qvd67/
-  disableLargeAddressSpace ? stdenv.targetPlatform.isDarwin && stdenv.targetPlatform.isAarch64
-}:
-
-assert !enableIntegerSimple -> gmp != null;
-
-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
-    DYNAMIC_GHC_PROGRAMS = ${if enableShared then "YES" else "NO"}
-    INTEGER_LIBRARY = ${if enableIntegerSimple then "integer-simple" else "integer-gmp"}
-  ''
-    # We only need to build stage1 on most cross-compilation because
-    # we will be running the compiler on the native system. In some
-    # situations, like native Musl compilation, we need the compiler
-    # to actually link to our new Libc. The iOS simulator is a special
-    # exception because we can’t actually run simulators binaries
-    # ourselves.
-  + lib.optionalString (targetPlatform != hostPlatform) ''
-    Stage1Only = ${if (targetPlatform.system == hostPlatform.system && !targetPlatform.isiOS) then "NO" else "YES"}
-    CrossCompilePrefix = ${targetPrefix}
-    HADDOCK_DOCS = NO
-    BUILD_SPHINX_HTML = NO
-    BUILD_SPHINX_PDF = NO
-  '' + lib.optionalString dontStrip ''
-    STRIP_CMD = :
-  '' + lib.optionalString (!enableProfiledLibs) ''
-    GhcLibWays = "v dyn"
-  '' + lib.optionalString enableRelocatedStaticLibs ''
-    GhcLibHcOpts += -fPIC
-    GhcRtsHcOpts += -fPIC
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    EXTRA_CC_OPTS += -std=gnu99
-  '';
-
-  # Splicer will pull out correct variations
-  libDeps = platform: lib.optional enableTerminfo ncurses
-    ++ [libffi]
-    ++ lib.optional (!enableIntegerSimple) gmp
-    ++ lib.optional (platform.libc != "glibc" && !targetPlatform.isWindows) libiconv;
-
-  toolsForTarget = [
-    pkgsBuildTarget.targetPackages.stdenv.cc
-  ] ++ lib.optional useLLVM buildLlvmPackages.llvm;
-
-  targetCC = builtins.head toolsForTarget;
-
-  # ld.gold is disabled for musl libc due to https://sourceware.org/bugzilla/show_bug.cgi?id=23856
-  # see #84670 and #49071 for more background.
-  useLdGold = targetPlatform.isLinux && !(targetPlatform.useLLVM or false) && !targetPlatform.isMusl;
-
-in
-stdenv.mkDerivation (rec {
-  version = "8.8.3";
-  name = "${targetPrefix}ghc-${version}";
-
-  src = fetchurl {
-    url = "https://downloads.haskell.org/ghc/${version}/ghc-${version}-src.tar.xz";
-    sha256 = "128g932i3wix6ic03v04nh5755vyjiidzri9iybwad72yfmc1p70";
-  };
-
-  enableParallelBuilding = true;
-
-  outputs = [ "out" "doc" ];
-
-  patches = [
-    # See upstream patch at
-    # https://gitlab.haskell.org/ghc/ghc/-/merge_requests/4885. Since we build
-    # from source distributions, the auto-generated configure script needs to be
-    # patched as well, therefore we use an in-tree patch instead of pulling the
-    # upstream patch. Don't forget to check backport status of the upstream patch
-    # when adding new GHC releases in nixpkgs.
-    ./respect-ar-path.patch
-  ];
-
-  postPatch = "patchShebangs .";
-
-  # GHC is a bit confused on its cross terminology.
-  preConfigure = ''
-    for env in $(env | grep '^TARGET_' | sed -E 's|\+?=.*||'); do
-      export "''${env#TARGET_}=''${!env}"
-    done
-    # GHC is a bit confused on its cross terminology, as these would normally be
-    # the *host* tools.
-    export CC="${targetCC}/bin/${targetCC.targetPrefix}cc"
-    export CXX="${targetCC}/bin/${targetCC.targetPrefix}cxx"
-    # Use gold to work around https://sourceware.org/bugzilla/show_bug.cgi?id=16177
-    export LD="${targetCC.bintools}/bin/${targetCC.bintools.targetPrefix}ld${lib.optionalString useLdGold ".gold"}"
-    export AS="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}as"
-    export AR="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ar"
-    export NM="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}nm"
-    export RANLIB="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}ranlib"
-    export READELF="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}readelf"
-    export STRIP="${targetCC.bintools.bintools}/bin/${targetCC.bintools.targetPrefix}strip"
-
-    echo -n "${buildMK dontStrip}" > mk/build.mk
-    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"
-  '' + lib.optionalString targetPlatform.useAndroidPrebuilt ''
-    sed -i -e '5i ,("armv7a-unknown-linux-androideabi", ("e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64", "cortex-a8", ""))' llvm-targets
-  '' + lib.optionalString targetPlatform.isMusl ''
-      echo "patching llvm-targets for musl targets..."
-      echo "Cloning these existing '*-linux-gnu*' targets:"
-      grep linux-gnu llvm-targets | sed 's/^/  /'
-      echo "(go go gadget sed)"
-      sed -i 's,\(^.*linux-\)gnu\(.*\)$,\0\n\1musl\2,' llvm-targets
-      echo "llvm-targets now contains these '*-linux-musl*' targets:"
-      grep linux-musl llvm-targets | sed 's/^/  /'
-
-      echo "And now patching to preserve '-musleabi' as done with '-gnueabi'"
-      # (aclocal.m4 is actual source, but patch configure as well since we don't re-gen)
-      for x in configure aclocal.m4; do
-        substituteInPlace $x \
-          --replace '*-android*|*-gnueabi*)' \
-                    '*-android*|*-gnueabi*|*-musleabi*)'
-      done
-  '';
-
-  # TODO(@Ericson2314): Always pass "--target" and always prefix.
-  configurePlatforms = [ "build" "host" ]
-    ++ lib.optional (targetPlatform != hostPlatform) "target";
-
-  # `--with` flags for libraries needed for RTS linker
-  configureFlags = [
-    "--datadir=$doc/share/doc/ghc"
-    "--with-curses-includes=${ncurses.dev}/include" "--with-curses-libraries=${ncurses.out}/lib"
-  ] ++ lib.optionals (libffi != null) [
-    "--with-system-libffi"
-    "--with-ffi-includes=${targetPackages.libffi.dev}/include"
-    "--with-ffi-libraries=${targetPackages.libffi.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && !enableIntegerSimple) [
-    "--with-gmp-includes=${targetPackages.gmp.dev}/include"
-    "--with-gmp-libraries=${targetPackages.gmp.out}/lib"
-  ] ++ lib.optionals (targetPlatform == hostPlatform && hostPlatform.libc != "glibc" && !targetPlatform.isWindows) [
-    "--with-iconv-includes=${libiconv}/include"
-    "--with-iconv-libraries=${libiconv}/lib"
-  ] ++ lib.optionals (targetPlatform != hostPlatform) [
-    "--enable-bootstrap-with-devel-snapshot"
-  ] ++ lib.optionals useLdGold [
-    "CFLAGS=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE1=-fuse-ld=gold"
-    "CONF_GCC_LINKER_OPTS_STAGE2=-fuse-ld=gold"
-  ] ++ lib.optionals (disableLargeAddressSpace) [
-    "--disable-large-address-space"
-  ];
-
-  # Make sure we never relax`$PATH` and hooks support for compatibility.
-  strictDeps = true;
-
-  # Don’t add -liconv to LDFLAGS automatically so that GHC will add it itself.
-  dontAddExtraLibs = true;
-
-  nativeBuildInputs = [
-    perl autoconf automake m4 python3 sphinx
-    ghc bootPkgs.alex bootPkgs.happy bootPkgs.hscolour
-  ];
-
-  # For building runtime libs
-  depsBuildTarget = toolsForTarget;
-
-  buildInputs = [ perl bash ] ++ (libDeps hostPlatform);
-
-  propagatedBuildInputs = [ targetPackages.stdenv.cc ]
-    ++ lib.optional useLLVM llvmPackages.llvm;
-
-  depsTargetTarget = map lib.getDev (libDeps targetPlatform);
-  depsTargetTargetPropagated = map (lib.getOutput "out") (libDeps targetPlatform);
-
-  # required, because otherwise all symbols from HSffi.o are stripped, and
-  # that in turn causes GHCi to abort
-  stripDebugFlags = [ "-S" ] ++ lib.optional (!targetPlatform.isDarwin) "--keep-file-symbols";
-
-  checkTarget = "test";
-
-  hardeningDisable = [ "format" ] ++ lib.optional stdenv.targetPlatform.isMusl "pie";
-
-  postInstall = ''
-    # Install the bash completion file.
-    install -D -m 444 utils/completion/ghc.bash $out/share/bash-completion/completions/${targetPrefix}ghc
-
-    # Patch scripts to include "readelf" and "cat" in $PATH.
-    for i in "$out/bin/"*; do
-      test ! -h $i || continue
-      egrep --quiet '^#!' <(head -n 1 $i) || continue
-      sed -i -e '2i export PATH="$PATH:${lib.makeBinPath [ targetPackages.stdenv.cc.bintools coreutils ]}"' $i
-    done
-  '';
-
-  passthru = {
-    inherit bootPkgs targetPrefix;
-
-    inherit llvmPackages;
-    inherit enableShared;
-
-    # Our Cabal compiler name
-    haskellCompilerName = "ghc-${version}";
-  };
-
-  meta = {
-    homepage = "http://haskell.org/ghc";
-    description = "The Glasgow Haskell Compiler";
-    maintainers = with lib.maintainers; [ marcweber andres peti ];
-    timeout = 24 * 3600;
-    inherit (ghc.meta) license platforms;
-  };
-
-  dontStrip = (targetPlatform.useAndroidPrebuilt || targetPlatform.isWasm);
-
-} // lib.optionalAttrs targetPlatform.useAndroidPrebuilt{
-  dontPatchELF = true;
-  noAuditTmpdir = true;
-})

pkgs/development/compilers/llvm/10/compiler-rt.nix

···
     # The compiler-rt build infrastructure sniffs supported platforms on Darwin
     # and finds i386;x86_64;x86_64h. We only build for x86_64, so linking fails
     # when it tries to use libc++ and libc++api for i386.
-    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.parsed.cpu.name}"
+    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.darwinArch}"
+    "-DDARWIN_osx_BUILTIN_ARCHS=${stdenv.hostPlatform.darwinArch}"
   ];
 
   outputs = [ "out" "dev" ];

pkgs/development/compilers/llvm/11/compiler-rt.nix

···
     "-DCMAKE_ASM_COMPILER_TARGET=${stdenv.hostPlatform.config}"
   ] ++ lib.optionals (stdenv.isDarwin) [
     "-DDARWIN_macosx_OVERRIDE_SDK_VERSION=ON"
-    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.parsed.cpu.name}"
+    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.darwinArch}"
+    "-DDARWIN_osx_BUILTIN_ARCHS=${stdenv.hostPlatform.darwinArch}"
   ] ++ lib.optionals (useLLVM || bareMetal || isMusl) [
     "-DCOMPILER_RT_BUILD_SANITIZERS=OFF"
     "-DCOMPILER_RT_BUILD_XRAY=OFF"

pkgs/development/compilers/llvm/5/compiler-rt.nix

···
     # The compiler-rt build infrastructure sniffs supported platforms on Darwin
     # and finds i386;x86_64;x86_64h. We only build for x86_64, so linking fails
     # when it tries to use libc++ and libc++api for i386.
-    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.parsed.cpu.name}"
+    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.darwinArch}"
   ];
 
   outputs = [ "out" "dev" ];

pkgs/development/compilers/llvm/6/compiler-rt.nix

···
     # The compiler-rt build infrastructure sniffs supported platforms on Darwin
     # and finds i386;x86_64;x86_64h. We only build for x86_64, so linking fails
     # when it tries to use libc++ and libc++api for i386.
-    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.parsed.cpu.name}"
+    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.darwinArch}"
   ];
 
   outputs = [ "out" "dev" ];

pkgs/development/compilers/llvm/7/compiler-rt.nix

···
     # The compiler-rt build infrastructure sniffs supported platforms on Darwin
     # and finds i386;x86_64;x86_64h. We only build for x86_64, so linking fails
     # when it tries to use libc++ and libc++api for i386.
-    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.parsed.cpu.name}"
+    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.darwinArch}"
   ];
 
   outputs = [ "out" "dev" ];

pkgs/development/compilers/llvm/8/compiler-rt.nix

···
     # The compiler-rt build infrastructure sniffs supported platforms on Darwin
     # and finds i386;x86_64;x86_64h. We only build for x86_64, so linking fails
     # when it tries to use libc++ and libc++api for i386.
-    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.parsed.cpu.name}"
+    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.darwinArch}"
   ];
 
   outputs = [ "out" "dev" ];

pkgs/development/compilers/llvm/9/compiler-rt.nix

···
     # The compiler-rt build infrastructure sniffs supported platforms on Darwin
     # and finds i386;x86_64;x86_64h. We only build for x86_64, so linking fails
     # when it tries to use libc++ and libc++api for i386.
-    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.parsed.cpu.name}"
+    "-DDARWIN_osx_ARCHS=${stdenv.hostPlatform.darwinArch}"
   ];
 
   outputs = [ "out" "dev" ];

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

···
     hinotify = if pkgs.stdenv.isLinux then self.hinotify else self.fsnotify;
   };
 
-  # Backport fix for bash: compgen: command not found
-  # which happens in nix-shell when a non-interactive bash is on PATH
-  # PR to master: https://github.com/pcapriotti/optparse-applicative/pull/408
-  optparse-applicative = appendPatch super.optparse-applicative (pkgs.fetchpatch {
-    name = "optparse-applicative-0.15.1-hercules-ci-compgen.diff";
-    url = "https://github.com/hercules-ci/optparse-applicative/compare/0.15.1...hercules-ci:0.15.1-nixpkgs-compgen.diff";
-    sha256 = "1bcp6b7gvc8pqbn1n1ybhizkkl5if7hk9ipgl746vk08v0d3xxql";
-  });
-
   # Fix test trying to access /home directory
   shell-conduit = overrideCabal super.shell-conduit (drv: {
     postPatch = "sed -i s/home/tmp/ test/Spec.hs";
···
   # https://github.com/froozen/kademlia/issues/2
   kademlia = dontCheck super.kademlia;
 
-  # Tests require older tasty
+  # Tests require older versions of tasty.
+  cborg = (doJailbreak super.cborg).override { base16-bytestring = self.base16-bytestring_0_1_1_7; };
   hzk = dontCheck super.hzk;
+  resolv = doJailbreak super.resolv;
+  tdigest = doJailbreak super.tdigest;
+  text-short = doJailbreak super.text-short;
+  tree-diff = doJailbreak super.tree-diff;
 
   # Tests require a Kafka broker running locally
   haskakafka = dontCheck super.haskakafka;
 
-  # Depends on broken "lss" package.
-  snaplet-lss = dontDistribute super.snaplet-lss;
-
-  # Depends on broken "NewBinary" package.
-  ASN1 = dontDistribute super.ASN1;
-
-  # Depends on broken "frame" package.
-  frame-markdown = dontDistribute super.frame-markdown;
-
-  # Depends on broken "Elm" package.
-  hakyll-elm = dontDistribute super.hakyll-elm;
-  haskelm = dontDistribute super.haskelm;
-  snap-elm = dontDistribute super.snap-elm;
-
-  # Depends on broken "hails" package.
-  hails-bin = dontDistribute super.hails-bin;
-
   bindings-levmar = overrideCabal super.bindings-levmar (drv: {
     extraLibraries = [ pkgs.blas ];
+  });
+
+  # Requires wrapQtAppsHook
+  qtah-cpp-qt5 = overrideCabal super.qtah-cpp-qt5 (drv: {
+    buildDepends = [ pkgs.qt5.wrapQtAppsHook ];
   });
 
   # The Haddock phase fails for one reason or another.
···
   # 2020-06-05: HACK: does not pass own build suite - `dontCheck`
   hnix = generateOptparseApplicativeCompletion "hnix" (dontCheck super.hnix);
 
-  # https://github.com/haskell-nix/hnix-store/issues/127
-  hnix-store-core = addTestToolDepend super.hnix-store-core self.tasty-discover;
-
   # Fails for non-obvious reasons while attempting to use doctest.
   search = dontCheck super.search;
 
···
   angel = dontCheck super.angel;
   apache-md5 = dontCheck super.apache-md5;              # http://hydra.cryp.to/build/498709/nixlog/1/raw
   app-settings = dontCheck super.app-settings;          # http://hydra.cryp.to/build/497327/log/raw
-  aws = appendPatch (dontCheck super.aws)               # needs aws credentials
-        (pkgs.fetchpatch {
-          # https://github.com/aristidb/aws/pull/271
-          # bump a version bound
-          url = https://github.com/aristidb/aws/commit/3639262ccd6761dea76f052692ac3aefbd254723.patch;
-          sha256 = "0nxaspldgayqjnidda8w7wps5gdpr2wz6vynl7vkaw8kzxks9bci";
-        });
+  aws = doJailbreak (dontCheck super.aws);              # needs aws credentials, jailbreak for base16-bytestring
   aws-kinesis = dontCheck super.aws-kinesis;            # needs aws credentials for testing
   binary-protocol = dontCheck super.binary-protocol;    # http://hydra.cryp.to/build/499749/log/raw
   binary-search = dontCheck super.binary-search;
···
   nats-queue = dontCheck super.nats-queue;
   netpbm = dontCheck super.netpbm;
   network = dontCheck super.network;
+  network_2_6_3_1 = dontCheck super.network_2_6_3_1; # package is missing files for test
   network-dbus = dontCheck super.network-dbus;
   notcpp = dontCheck super.notcpp;
   ntp-control = dontCheck super.ntp-control;
···
   # https://github.com/afcowie/locators/issues/1
   locators = dontCheck super.locators;
 
-  # Test suite won't compile against tasty-hunit 0.9.x.
-  zlib = dontCheck super.zlib;
-
   # Test suite won't compile against tasty-hunit 0.10.x.
   binary-parser = dontCheck super.binary-parser;
   binary-parsers = dontCheck super.binary-parsers;
···
 
   # https://github.com/liyang/thyme/issues/36
   thyme = dontCheck super.thyme;
-
-  # https://github.com/k0ral/hbro-contrib/issues/1
-  hbro-contrib = dontDistribute super.hbro-contrib;
 
   # Elm is no longer actively maintained on Hackage: https://github.com/NixOS/nixpkgs/pull/9233.
   Elm = markBroken super.Elm;
···
   # Jailbreak is necessary to break out of tasty < 1.x dependency.
   cryptohash-sha256 = markUnbroken (doJailbreak super.cryptohash-sha256);
 
+  # The test suite has all kinds of out-dated dependencies, so it feels easier
+  # to just disable it.
+  cryptohash-sha1 = dontCheck super.cryptohash-sha1;
+  cryptohash-md5 = dontCheck super.cryptohash-md5;
+
   # Needs tasty-quickcheck ==0.8.*, which we don't have.
-  cryptohash-sha1 = doJailbreak super.cryptohash-sha1;
-  cryptohash-md5 = doJailbreak super.cryptohash-md5;
   gitHUD = dontCheck super.gitHUD;
   githud = dontCheck super.githud;
 
···
   commonmark-extensions = dontCheck super.commonmark-extensions;
 
   # Testsuite trying to run `which haskeline-examples-Test`
-  haskeline_0_8_1_1 = dontCheck super.haskeline_0_8_1_1;
+  haskeline_0_8_1_2 = dontCheck super.haskeline_0_8_1_2;
 
   # Tests for list-t, superbuffer, and stm-containers
   # depend on HTF and it is broken, 2020-08-23
···
   #   PATH.
   update-nix-fetchgit = let deps = [ pkgs.git pkgs.nix pkgs.nix-prefetch-git ];
   in generateOptparseApplicativeCompletion "update-nix-fetchgit" (overrideCabal
-    (addTestToolDepends (super.update-nix-fetchgit.overrideScope (self: super: {
-      optparse-generic = self.optparse-generic_1_4_4;
-      optparse-applicative = self.optparse-applicative_0_16_1_0;
-    })) deps) (drv: {
+    (addTestToolDepends super.update-nix-fetchgit deps) (drv: {
       buildTools = drv.buildTools or [ ] ++ [ pkgs.makeWrapper ];
       postInstall = drv.postInstall or "" + ''
         wrapProgram "$out/bin/update-nix-fetchgit" --prefix 'PATH' ':' "${
···
   # https://github.com/haskell/haskell-language-server/issues/611
   haskell-language-server = dontCheck super.haskell-language-server;
 
+  # 2021-03-19: Too restrictive upper bound on optparse-applicative
+  stylish-haskell = doJailbreak super.stylish-haskell;
+
+  # 2021-03-19: https://github.com/facebookincubator/retrie/issues/24
+  retrie = doJailbreak super.retrie;
+
+  # Jailbreak because of restrictive upper bound on base16-bytestring
+  # 2021-03-19: https://github.com/Avi-D-coder/implicit-hie-cradle/pull/8
+  implicit-hie-cradle = doJailbreak super.implicit-hie-cradle;
+
   # 2021-03-09: Overrides because nightly is to old for hls 1.0.0
   lsp-test = doDistribute (dontCheck self.lsp-test_0_13_0_0);
 
···
 
   # 2021-03-21 Test hangs
   # https://github.com/haskell/haskell-language-server/issues/1562
-  ghcide = dontCheck super.ghcide;
+  # Jailbreak because of: https://github.com/haskell/haskell-language-server/pull/1595
+  ghcide = doJailbreak (dontCheck super.ghcide);
 
   # 2020-03-09: Tests broken in hackage release
   # fixed on upstream, but not released in hiedb 0.3.0.1
···
   # 2020-11-19: Jailbreaking until: https://github.com/snapframework/heist/pull/124
   heist = doJailbreak super.heist;
 
-  hinit = generateOptparseApplicativeCompletion "hi" (super.hinit.override { haskeline = self.haskeline_0_8_1_1; });
+  hinit = generateOptparseApplicativeCompletion "hi" (super.hinit.override { haskeline = self.haskeline_0_8_1_2; });
 
   # 2020-11-19: Jailbreaking until: https://github.com/snapframework/snap/pull/219
   snap = doJailbreak super.snap;
···
 
   # Test suite does not compile.
   feed = dontCheck super.feed;
+
+  spacecookie = overrideCabal super.spacecookie (old: {
+    buildTools = (old.buildTools or []) ++ [ pkgs.installShellFiles ];
+    # let testsuite discover the resulting binary
+    preCheck = ''
+      export SPACECOOKIE_TEST_BIN=./dist/build/spacecookie/spacecookie
+    '' + (old.preCheck or "");
+    # install man pages shipped in the sdist
+    postInstall = ''
+      installManPage docs/man/*
+    '' + (old.postInstall or "");
+  });
+
+  # Patch and jailbreak can be removed at next release, chatter > 0.9.1.0
+  # * Remove dependency on regex-tdfa-text
+  # * Jailbreak as bounds on cereal are too strict
+  # * Disable test suite which doesn't compile
+  #   https://github.com/creswick/chatter/issues/38
+  chatter = appendPatch
+    (dontCheck (doJailbreak (super.chatter.override { regex-tdfa-text = null; })))
+    (pkgs.fetchpatch {
+      url = "https://github.com/creswick/chatter/commit/e8c15a848130d7d27b8eb5e73e8a0db1366b2e62.patch";
+      sha256 = "1dzak8d12h54vss5fxnrclygz0fz9ygbqvxd5aifz5n3vrwwpj3g";
+    });
+
+  # test suite doesn't compile anymore due to changed hunit/tasty APIs
+  fullstop = dontCheck super.fullstop;
+
+  # https://github.com/jgm/pandoc/issues/7163
+  pandoc = dontCheck super.pandoc;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

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

···
   unix = null;
   xhtml = null;
 
-  cabal-install = super.cabal-install.override {
-    Cabal = super.Cabal_3_4_0_0;
-    hackage-security = super.hackage-security.override { Cabal = super.Cabal_3_4_0_0; };
-    # Usung dontCheck to break test dependency cycles
-    edit-distance = dontCheck (super.edit-distance.override { random = super.random_1_2_0; });
-    random = super.random_1_2_0;
-  };
+  # cabal-install needs more recent versions of Cabal and random, but an older
+  # version of base16-bytestring.
+  cabal-install = super.cabal-install.overrideScope (self: super: {
+    Cabal = self.Cabal_3_4_0_0;
+    base16-bytestring = self.base16-bytestring_0_1_1_7;
+    random = dontCheck super.random_1_2_0;  # break infinite recursion
+    hashable = doJailbreak super.hashable;  # allow random 1.2.x
+  });
 
   # cabal-install-parsers is written for Cabal 3.4
-  cabal-install-parsers = super.cabal-install-parsers.override {
-    Cabal = super.Cabal_3_4_0_0;
-    base16-bytestring = super.base16-bytestring_1_0_1_0;
-  };
+  cabal-install-parsers = super.cabal-install-parsers.override { Cabal = super.Cabal_3_4_0_0; };
 
   # Jailbreak to fix the build.
   base-noprelude = doJailbreak super.base-noprelude;
···
 
   # Break out of "Cabal < 3.2" constraint.
   stylish-haskell = doJailbreak super.stylish-haskell;
+
 }

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

···
-{ pkgs, haskellLib }:
-
-with haskellLib;
-
-self: super: {
-
-  # Suitable LLVM version.
-  llvmPackages = pkgs.llvmPackages;
-
-  # Disable GHC 8.2.x core libraries.
-  array = null;
-  base = null;
-  binary = null;
-  bytestring = null;
-  Cabal = null;
-  containers = null;
-  deepseq = null;
-  directory = null;
-  filepath = null;
-  ghc-boot = null;
-  ghc-boot-th = null;
-  ghc-compact = null;
-  ghc-heap = null;
-  ghc-prim = null;
-  ghci = null;
-  haskeline = null;
-  hoopl = null;
-  hpc = null;
-  integer-gmp = null;
-  pretty = null;
-  process = null;
-  rts = null;
-  template-haskell = null;
-  terminfo = null;
-  time = null;
-  transformers = null;
-  unix = null;
-  xhtml = null;
-
-  # These are now core libraries in GHC 8.4.x.
-  mtl = self.mtl_2_2_2;
-  parsec = self.parsec_3_1_14_0;
-  stm = self.stm_2_5_0_0;
-  text = self.text_1_2_4_0;
-
-  # Needs Cabal 3.0.x.
-  jailbreak-cabal = super.jailbreak-cabal.override { Cabal = self.Cabal_3_2_1_0; };
-
-  # https://github.com/bmillwood/applicative-quoters/issues/6
-  applicative-quoters = appendPatch super.applicative-quoters (pkgs.fetchpatch {
-    url = "https://patch-diff.githubusercontent.com/raw/bmillwood/applicative-quoters/pull/7.patch";
-    sha256 = "026vv2k3ks73jngwifszv8l59clg88pcdr4mz0wr0gamivkfa1zy";
-  });
-
-  # https://github.com/nominolo/ghc-syb/issues/20
-  ghc-syb-utils = dontCheck super.ghc-syb-utils;
-
-  # Upstream failed to distribute the testsuite for 8.2
-  # https://github.com/alanz/ghc-exactprint/pull/60
-  ghc-exactprint = dontCheck super.ghc-exactprint;
-
-  # Reduction stack overflow; size = 38
-  # https://github.com/jystic/hadoop-tools/issues/31
-  hadoop-rpc =
-    let patch = pkgs.fetchpatch
-          { url = "https://github.com/shlevy/hadoop-tools/commit/f03a46cd15ce3796932c3382e48bcbb04a6ee102.patch";
-            sha256 = "09ls54zy6gx84fmzwgvx18ssgm740cwq6ds70p0p125phi54agcp";
-            stripLen = 1;
-          };
-    in appendPatch super.hadoop-rpc patch;
-
-  # Custom Setup.hs breaks with Cabal 2
-  # https://github.com/NICTA/coordinate/pull/4
-  coordinate =
-    let patch = pkgs.fetchpatch
-          { url = "https://github.com/NICTA/coordinate/pull/4.patch";
-            sha256 = "06sfxk5cyd8nqgjyb95jkihxxk8m6dw9m3mlv94sm2qwylj86gqy";
-          };
-    in appendPatch super.coordinate patch;
-
-  # https://github.com/purescript/purescript/issues/3189
-  purescript = doJailbreak (super.purescript);
-
-  # These packages need Cabal 2.2.x, which is not the default.
-  cabal2nix = super.cabal2nix.overrideScope (self: super: { Cabal = self.Cabal_2_2_0_1; });
-  cabal2spec = super.cabal2spec.overrideScope (self: super: { Cabal = self.Cabal_2_2_0_1; });
-  distribution-nixpkgs = super.distribution-nixpkgs.overrideScope (self: super: { Cabal = self.Cabal_2_2_0_1; });
-  stack = super.stack.overrideScope (self: super: { Cabal = self.Cabal_2_2_0_1; });
-
-  # Older GHC versions need these additional dependencies.
-  ListLike = addBuildDepend super.ListLike self.semigroups;
-  base-compat-batteries = addBuildDepend super.base-compat-batteries self.contravariant;
-
-  # ghc versions prior to 8.8.x needs additional dependency to compile successfully.
-  ghc-lib-parser-ex = addBuildDepend super.ghc-lib-parser-ex self.ghc-lib-parser;
-
-}

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

···
-{ pkgs, haskellLib }:
-
-with haskellLib;
-
-self: super: {
-
-  # This compiler version needs llvm 5.x.
-  llvmPackages = pkgs.llvmPackages_5;
-
-  # Disable GHC 8.4.x core libraries.
-  array = null;
-  base = null;
-  binary = null;
-  bytestring = null;
-  Cabal = null;
-  containers = null;
-  deepseq = null;
-  directory = null;
-  filepath = null;
-  ghc-boot = null;
-  ghc-boot-th = null;
-  ghc-compact = null;
-  ghc-heap = null;
-  ghc-prim = null;
-  ghci = null;
-  haskeline = null;
-  hpc = null;
-  integer-gmp = null;
-  mtl = null;
-  parsec = null;
-  pretty = null;
-  process = null;
-  rts = null;
-  stm = null;
-  template-haskell = null;
-  terminfo = null;
-  text = null;
-  time = null;
-  transformers = null;
-  unix = null;
-  xhtml = null;
-
-  # Needs Cabal 3.2.x.
-  cabal-install = super.cabal-install.overrideScope (self: super: { Cabal = self.Cabal_3_2_1_0; });
-  jailbreak-cabal = super.jailbreak-cabal.override { Cabal = self.Cabal_3_2_1_0; };
-
-  # Restricts aeson to <1.4
-  # https://github.com/purescript/purescript/pull/3537
-  purescript = doJailbreak super.purescript;
-
-  # https://github.com/jcristovao/enclosed-exceptions/issues/12
-  enclosed-exceptions = dontCheck super.enclosed-exceptions;
-
-  # https://github.com/jaor/xmobar/issues/356
-  xmobar = super.xmobar.overrideScope (self: super: { hinotify = self.hinotify_0_3_9; });
-  hinotify_0_3_9 = dontCheck (doJailbreak super.hinotify_0_3_9); # allow async 2.2.x
-
-  # Reduction stack overflow; size = 38
-  # https://github.com/jystic/hadoop-tools/issues/31
-  hadoop-rpc =
-    let patch = pkgs.fetchpatch
-          { url = "https://github.com/shlevy/hadoop-tools/commit/f03a46cd15ce3796932c3382e48bcbb04a6ee102.patch";
-            sha256 = "09ls54zy6gx84fmzwgvx18ssgm740cwq6ds70p0p125phi54agcp";
-            stripLen = 1;
-          };
-    in appendPatch super.hadoop-rpc patch;
-
-  # stack-1.9.1 needs Cabal 2.4.x, a recent version of hpack, and a non-recent
-  # version of yaml. Go figure. We avoid overrideScope here because using it to
-  # change Cabal would re-compile every single package instead of just those
-  # that have it as an actual library dependency. The explicit overrides are
-  # more verbose but friendlier for Hydra.
-  stack = (doJailbreak super.stack).override {
-    Cabal = self.Cabal_2_4_1_0;
-    hpack = self.hpack.override { Cabal = self.Cabal_2_4_1_0; };
-    hackage-security = self.hackage-security.override { Cabal = self.Cabal_2_4_1_0; };
-  };
-
-  # Older GHC versions need these additional dependencies.
-  aeson = addBuildDepend super.aeson self.contravariant;
-  base-compat-batteries = addBuildDepend super.base-compat-batteries self.contravariant;
-
-  # Newer versions don't compile.
-  resolv = self.resolv_0_1_1_2;
-
-  # The old Haddock cannot process the newer documentation syntax.
-  fast-logger = dontHaddock super.fast-logger;
-
-  # ghc versions prior to 8.8.x needs additional dependency to compile successfully.
-  ghc-lib-parser-ex = addBuildDepend super.ghc-lib-parser-ex self.ghc-lib-parser;
-  hls-hlint-plugin = addBuildDepend super.hls-hlint-plugin self.ghc-lib;
-
-}

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

···
   haddock = self.haddock_2_23_1;
   haddock-api = self.haddock-api_2_23_1;
 
-  # These builds need newer versions of Cabal.
+  # This build needs a newer version of Cabal.
   cabal2spec = super.cabal2spec.override { Cabal = self.Cabal_3_2_1_0; };
-  cabal-install = super.cabal-install.override {
-    Cabal = super.Cabal_3_4_0_0;
-    hackage-security = super.hackage-security.override { Cabal = super.Cabal_3_4_0_0; };
-    # Using dontCheck to break test dependency cycles
-    edit-distance = dontCheck (super.edit-distance.override { random = super.random_1_2_0; });
-    random = super.random_1_2_0;
-  };
+
+  # cabal-install needs more recent versions of Cabal and random, but an older
+  # version of base16-bytestring.
+  cabal-install = super.cabal-install.overrideScope (self: super: {
+    Cabal = self.Cabal_3_4_0_0;
+    base16-bytestring = self.base16-bytestring_0_1_1_7;
+    random = dontCheck super.random_1_2_0;  # break infinite recursion
+    hashable = doJailbreak super.hashable;  # allow random 1.2.x
+  });
 
   # Ignore overly restrictive upper version bounds.
   aeson-diff = doJailbreak super.aeson-diff;

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

···
   unix = null;
   xhtml = null;
 
-  # Build cabal-install with the compiler's native Cabal.
-  cabal-install = (doJailbreak super.cabal-install).override {
-    # Use dontCheck to break test dependency cycles
-    edit-distance = dontCheck (super.edit-distance.override { random = super.random_1_2_0; });
-    random = super.random_1_2_0;
-  };
+  # cabal-install needs more recent versions of random, but an older
+  # version of base16-bytestring.
+  cabal-install = (doJailbreak super.cabal-install).overrideScope (self: super: {
+    Cabal = null;
+    base16-bytestring = self.base16-bytestring_0_1_1_7;
+    random = dontCheck super.random_1_2_0;  # break infinite recursion
+    hashable = doJailbreak super.hashable;  # allow random 1.2.x
+  });
 
   # Jailbreaks & Version Updates
   async = doJailbreak super.async;

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

···
-# GHCJS package fixes
-#
-# Please insert new packages *alphabetically*
-# in the OTHER PACKAGES section.
-{ pkgs, haskellLib }:
-
-let
-  removeLibraryHaskellDepends = pnames: depends:
-    builtins.filter (e: !(builtins.elem (e.pname or "") pnames)) depends;
-in
-
-with haskellLib;
-
-self: super:
-
-## GENERAL SETUP BASE PACKAGES
-
-  let # The stage 1 packages
-      stage1 = pkgs.lib.genAttrs super.ghc.stage1Packages (pkg: null);
-      # The stage 2 packages. Regenerate with ../compilers/ghcjs/gen-stage2.rb
-      stage2 = super.ghc.mkStage2 {
-        inherit (self) callPackage;
-      };
-  in stage1 // stage2 // {
-
-  # GHCJS does not ship with the same core packages as GHC.
-  # https://github.com/ghcjs/ghcjs/issues/676
-  stm = self.stm_2_5_0_0;
-  ghc-compact = self.ghc-compact_0_1_0_0;
-
-  network = addBuildTools super.network (pkgs.lib.optional pkgs.buildPlatform.isDarwin pkgs.buildPackages.darwin.libiconv);
-  zlib = addBuildTools super.zlib (pkgs.lib.optional pkgs.buildPlatform.isDarwin pkgs.buildPackages.darwin.libiconv);
-  unix-compat = addBuildTools super.unix-compat (pkgs.lib.optional pkgs.buildPlatform.isDarwin pkgs.buildPackages.darwin.libiconv);
-
-  # LLVM is not supported on this GHC; use the latest one.
-  inherit (pkgs) llvmPackages;
-
-  inherit (self.ghc.bootPkgs)
-    jailbreak-cabal alex happy gtk2hs-buildtools rehoo hoogle;
-
-  # Don't set integer-simple to null!
-  # GHCJS uses integer-gmp, so any package expression that depends on
-  # integer-simple is wrong.
-  #integer-simple = null;
-
-  # These packages are core libraries in GHC 8.6..x, but not here.
-  bin-package-db = null;
-  haskeline = self.haskeline_0_7_5_0;
-  hpc = self.hpc_0_6_0_3;
-  terminfo = self.terminfo_0_4_1_4;
-  xhtml = self.xhtml_3000_2_2_1;
-
-## OTHER PACKAGES
-
-  # haddock throws the error: No input file(s).
-  fail = dontHaddock super.fail;
-
-  cereal = addBuildDepend super.cereal [ self.fail ];
-
-  entropy = overrideCabal super.entropy (old: {
-    postPatch = old.postPatch or "" + ''
-      # cabal doesn’t find ghc in this script, since it’s in the bootPkgs
-      sed -e '/Simple.Program/a import Distribution.Simple.Program.Types' \
-          -e 's|mConf.*=.*$|mConf = Just $ simpleConfiguredProgram "ghc" (FoundOnSystem "${self.ghc.bootPkgs.ghc}/bin/ghc")|g' -i Setup.hs
-    '';
-  });
-
-  # https://github.com/kazu-yamamoto/logger/issues/97
-  fast-logger = overrideCabal super.fast-logger (old: {
-    postPatch = old.postPatch or "" + ''
-      # remove the Safe extensions, since ghcjs-boot directory
-      # doesn’t provide Trustworthy
-      sed -ie '/LANGUAGE Safe/d' System/Log/FastLogger/*.hs
-      cat System/Log/FastLogger/Date.hs
-    '';
-  });
-
-  # experimental
-  ghcjs-ffiqq = self.callPackage
-    ({ mkDerivation, base, template-haskell, ghcjs-base, split, containers, text, ghc-prim
-     }:
-     mkDerivation {
-       pname = "ghcjs-ffiqq";
-       version = "0.1.0.0";
-       src = pkgs.fetchFromGitHub {
-         owner = "ghcjs";
-         repo = "ghcjs-ffiqq";
-         rev = "b52338c2dcd3b0707bc8aff2e171411614d4aedb";
-         sha256 = "08zxfm1i6zb7n8vbz3dywdy67vkixfyw48580rwfp48rl1s2z1c7";
-       };
-       libraryHaskellDepends = [
-         base template-haskell ghcjs-base split containers text ghc-prim
-       ];
-       description = "FFI QuasiQuoter for GHCJS";
-       license = pkgs.lib.licenses.mit;
-     }) {};
-  # experimental
-  ghcjs-vdom = self.callPackage
-    ({ mkDerivation, base, ghc-prim, ghcjs-ffiqq, ghcjs-base, ghcjs-prim
-      , containers, split, template-haskell
-    }:
-    mkDerivation rec {
-      pname = "ghcjs-vdom";
-      version = "0.2.0.0";
-      src = pkgs.fetchFromGitHub {
-        owner = "ghcjs";
-        repo = pname;
-        rev = "1c1175ba22eca6d7efa96f42a72290ade193c148";
-        sha256 = "0c6l1dk2anvz94yy5qblrfh2iv495rjq4qmhlycc24dvd02f7n9m";
-      };
-      libraryHaskellDepends = [
-        base ghc-prim ghcjs-ffiqq ghcjs-base ghcjs-prim containers split
-        template-haskell
-      ];
-      license = pkgs.lib.licenses.mit;
-      description = "bindings for https://github.com/Matt-Esch/virtual-dom";
-    }) {};
-
-  ghcjs-dom = overrideCabal super.ghcjs-dom (drv: {
-    libraryHaskellDepends = with self; [
-      ghcjs-base ghcjs-dom-jsffi text transformers
-    ];
-    configureFlags = [ "-fjsffi" "-f-webkit" ];
-  });
-
-  ghcjs-dom-jsffi = overrideCabal super.ghcjs-dom-jsffi (drv: {
-    libraryHaskellDepends = (drv.libraryHaskellDepends or []) ++ [ self.ghcjs-base self.text ];
-    isLibrary = true;
-  });
-
-  ghc-paths = overrideCabal super.ghc-paths (drv: {
-    patches = [ ./patches/ghc-paths-nix-ghcjs.patch ];
-  });
-
-  http2 = addBuildDepends super.http2 [ self.aeson self.aeson-pretty self.hex self.unordered-containers self.vector self.word8 ];
-  # ghcjsBoot uses async 2.0.1.6, protolude wants 2.1.*
-
-  # These are the correct dependencies specified when calling `cabal2nix --compiler ghcjs`
-  # By default, the `miso` derivation present in hackage-packages.nix
-  # does not contain dependencies suitable for ghcjs
-  miso = overrideCabal super.miso (drv: {
-      libraryHaskellDepends = with self; [
-        BoundedChan bytestring containers ghcjs-base aeson base
-        http-api-data http-types network-uri scientific servant text
-        transformers unordered-containers vector
-      ];
-    });
-
-  pqueue = overrideCabal super.pqueue (drv: {
-    postPatch = ''
-      sed -i -e '12s|null|Data.PQueue.Internals.null|' Data/PQueue/Internals.hs
-      sed -i -e '64s|null|Data.PQueue.Internals.null|' Data/PQueue/Internals.hs
-      sed -i -e '32s|null|Data.PQueue.Internals.null|' Data/PQueue/Min.hs
-      sed -i -e '32s|null|Data.PQueue.Max.null|' Data/PQueue/Max.hs
-      sed -i -e '42s|null|Data.PQueue.Prio.Internals.null|' Data/PQueue/Prio/Min.hs
-      sed -i -e '42s|null|Data.PQueue.Prio.Max.null|' Data/PQueue/Prio/Max.hs
-    '';
-  });
-
-  profunctors = overrideCabal super.profunctors (drv: {
-    preConfigure = ''
-      sed -i 's/^{-# ANN .* #-}//' src/Data/Profunctor/Unsafe.hs
-    '';
-  });
-
-  protolude = doJailbreak super.protolude;
-
-  # reflex 0.3, made compatible with the newest GHCJS.
-  reflex = overrideCabal super.reflex (drv: {
-    src = pkgs.fetchFromGitHub {
-      owner = "ryantrinkle";
-      repo = "reflex";
-      rev = "cc62c11a6cde31412582758c236919d4bb766ada";
-      sha256 = "1j4vw0636bkl46lj8ry16i04vgpivjc6bs3ls54ppp1wfp63q7w4";
-    };
-  });
-
-  # reflex-dom 0.2, made compatible with the newest GHCJS.
-  reflex-dom = overrideCabal super.reflex-dom (drv: {
-    src = pkgs.fetchFromGitHub {
-      owner = "ryantrinkle";
-      repo = "reflex-dom";
-      rev = "639d9ca13c2def075e83344c9afca6eafaf24219";
-      sha256 = "0166ihbh3dbfjiym9w561svpgvj0x4i8i8ws70xaafi0cmpsxrar";
-    };
-    libraryHaskellDepends =
-      removeLibraryHaskellDepends [
-        "glib" "gtk3" "webkitgtk3" "webkitgtk3-javascriptcore" "raw-strings-qq" "unix"
-      ] drv.libraryHaskellDepends;
-  });
-
-  transformers-compat = overrideCabal super.transformers-compat (drv: {
-    configureFlags = [];
-  });
-
-  # triggers an internal pattern match failure in haddock
-  # https://github.com/haskell/haddock/issues/553
-  wai = dontHaddock super.wai;
-
-  base-orphans = dontCheck super.base-orphans;
-  distributive = dontCheck super.distributive;
-
-  # https://github.com/glguy/th-abstraction/issues/53
-  th-abstraction = dontCheck super.th-abstraction;
-  # https://github.com/dreixel/syb/issues/21
-  syb = dontCheck super.syb;
-  # https://github.com/ghcjs/ghcjs/issues/677
-  hspec-core = dontCheck super.hspec-core;
-}

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

···
   # gi-gdkx11-4.x requires gtk-4.x, which is still under development and
   # not yet available in Nixpkgs
   - gi-gdkx11 < 4
+  - hlint < 3.3 # We don‘t have ghc-lib-parser 9.0.X yet.
+  - ghcide < 1.1 # To stay hls 1.0 compatible
+  - hls-retrie-plugin < 1.0.0.1 # To stay hls 1.0 compatible
 
-  # Stackage Nightly 2021-03-12
+  # Stackage Nightly 2021-03-17
   - abstract-deque ==0.3
   - abstract-par ==0.3.3
   - AC-Angle ==1.0
···
   - aeson-attoparsec ==0.0.0
   - aeson-better-errors ==0.9.1.0
   - aeson-casing ==0.2.0.0
-  - aeson-combinators ==0.0.4.1
+  - aeson-combinators ==0.0.5.0
   - aeson-commit ==1.3
   - aeson-compat ==0.3.9
   - aeson-default ==0.9.1.0
···
   - amazonka-waf ==1.6.1
   - amazonka-workspaces ==1.6.1
   - amazonka-xray ==1.6.1
-  - amqp ==0.21.0
+  - amqp ==0.22.0
   - amqp-utils ==0.6.1.0
   - annotated-wl-pprint ==0.7.0
-  - ansi-terminal ==0.10.3
+  - ansi-terminal ==0.11
   - ansi-wl-pprint ==0.6.9
   - ANum ==0.2.0.2
   - apecs ==0.9.2
···
   - approximate-equality ==1.1.0.2
   - app-settings ==0.2.0.12
   - arbor-lru-cache ==0.1.1.1
-  - arbor-postgres ==0.0.5
   - arithmoi ==0.11.0.1
   - array-memoize ==0.6.0
   - arrow-extras ==0.1.0.1
···
   - bank-holidays-england ==0.2.0.6
   - barbies ==2.0.2.0
   - base16 ==0.3.0.1
-  - base16-bytestring ==0.1.1.7
+  - base16-bytestring ==1.0.1.0
   - base16-lens ==0.1.3.2
   - base32 ==0.2.0.0
   - base32-lens ==0.1.1.1
···
   - bugzilla-redhat ==0.3.1
   - burrito ==1.2.0.1
   - butcher ==1.3.3.2
+  - buttplug-hs-core ==0.1.0.0
   - bv ==0.5
   - bv-little ==1.1.1
   - byteable ==0.1.1
···
   - cardano-coin-selection ==1.0.1
   - carray ==0.1.6.8
   - casa-client ==0.0.1
-  - casa-types ==0.0.1
+  - casa-types ==0.0.2
   - cased ==0.1.0.0
   - case-insensitive ==1.2.1.0
   - cases ==0.1.4
···
   - cipher-rc4 ==0.1.4
   - circle-packing ==0.1.0.6
   - circular ==0.3.1.1
-  - citeproc ==0.3.0.8
+  - citeproc ==0.3.0.9
   - clash-ghc ==1.2.5
   - clash-lib ==1.2.5
   - clash-prelude ==1.2.5
···
   - cmark-lucid ==0.1.0.0
   - cmdargs ==0.10.21
   - codec-beam ==0.2.0
-  - codec-rpm ==0.2.2
   - code-page ==0.2.1
-  - co-log ==0.4.0.1
   - co-log-concurrent ==0.5.0.0
   - co-log-core ==0.2.1.1
-  - Color ==0.3.0
+  - Color ==0.3.1
   - colorful-monoids ==0.2.1.3
   - colorize-haskell ==1.0.1
   - colour ==2.3.5
-  - colourista ==0.1.0.0
   - combinatorial ==0.1.0.1
-  - comfort-array ==0.4
+  - comfort-array ==0.4.1
   - comfort-graph ==0.0.3.1
   - commonmark ==0.1.1.4
   - commonmark-extensions ==0.2.0.4
···
   - compensated ==0.8.3
   - compiler-warnings ==0.1.0
   - composable-associations ==0.1.0.0
-  - composable-associations-aeson ==0.1.0.0
+  - composable-associations-aeson ==0.1.0.1
   - composite-aeson ==0.7.4.0
   - composite-aeson-path ==0.7.4.0
   - composite-aeson-refined ==0.7.4.0
···
   - composition ==1.0.2.1
   - composition-extra ==2.0.0
   - concise ==0.1.0.1
-  - concurrency ==1.11.0.0
+  - concurrency ==1.11.0.1
   - concurrent-extra ==0.7.0.12
   - concurrent-output ==1.10.12
   - concurrent-split ==0.0.1.1
···
   - conduit-parse ==0.2.1.0
   - conduit-zstd ==0.0.2.0
   - conferer ==1.1.0.0
-  - conferer-aeson ==1.1.0.0
+  - conferer-aeson ==1.1.0.1
   - conferer-hspec ==1.1.0.0
   - conferer-warp ==1.1.0.0
   - ConfigFile ==1.1.4
···
   - core-text ==0.3.0.0
   - countable ==1.0
   - country ==0.2.1
-  - cpio-conduit ==0.7.0
   - cpphs ==1.20.9.1
   - cprng-aes ==0.6.1
   - cpu ==0.1.2
···
   - cryptohash-sha1 ==0.11.100.1
   - cryptohash-sha256 ==0.11.102.0
   - cryptohash-sha512 ==0.11.100.1
-  - cryptonite ==0.27
+  - cryptonite ==0.28
   - cryptonite-conduit ==0.2.2
   - cryptonite-openssl ==0.7
   - crypto-numbers ==0.2.7
···
   - data-forest ==0.1.0.8
   - data-has ==0.4.0.0
   - data-hash ==0.2.0.1
-  - data-interval ==2.0.1
+  - data-interval ==2.1.0
   - data-inttrie ==0.1.4
   - data-lens-light ==0.1.2.2
   - data-memocombinators ==0.5.1
···
   - debian-build ==0.10.2.0
   - debug-trace-var ==0.2.0
   - dec ==0.0.4
-  - Decimal ==0.5.1
+  - Decimal ==0.5.2
   - declarative ==0.5.4
   - deepseq-generics ==0.2.0.0
   - deepseq-instances ==0.1.0.1
   - deferred-folds ==0.9.17
-  - dejafu ==2.4.0.1
+  - dejafu ==2.4.0.2
   - dense-linear-algebra ==0.1.0.0
   - depq ==0.4.1.0
   - deque ==0.4.3
···
   - dlist-nonempty ==0.1.1
   - dns ==4.0.1
   - dockerfile ==0.2.0
-  - doclayout ==0.3
+  - doclayout ==0.3.0.2
   - doctemplates ==0.9
   - doctest ==0.16.3
   - doctest-discover ==0.2.0.0
   - doctest-driver-gen ==0.3.0.3
   - doctest-exitcode-stdio ==0.0
+  - doctest-extract ==0.1
   - doctest-lib ==0.1
   - doldol ==0.4.1.2
   - do-list ==1.0.1
···
   - dual ==0.1.1.1
   - dublincore-xml-conduit ==0.1.0.2
   - dunai ==0.7.0
-  - duration ==0.1.0.0
+  - duration ==0.2.0.0
   - dvorak ==0.1.0.0
   - dynamic-state ==0.3.1
   - dyre ==0.8.12
···
   - executable-path ==0.0.3.1
   - exit-codes ==1.0.0
   - exomizer ==1.0.0
-  - experimenter ==0.1.0.4
+  - experimenter ==0.1.0.10
   - expiring-cache-map ==0.0.6.1
   - explicit-exception ==0.1.10
   - exp-pairs ==0.2.1.0
···
   - fixed-length ==0.2.2
   - fixed-vector ==1.2.0.0
   - fixed-vector-hetero ==0.6.0.0
+  - fix-whitespace ==0.0.5
   - flac ==0.2.0
   - flac-picture ==0.1.2
   - flags-applicative ==0.1.0.2
···
   - ghc-byteorder ==4.11.0.0.10
   - ghc-check ==0.5.0.3
   - ghc-core ==0.5.6
-  - ghc-events ==0.15.1
+  - ghc-events ==0.16.0
   - ghc-exactprint ==0.6.4
   - ghcid ==0.8.7
   - ghci-hexcalc ==0.1.1.0
···
   - ghc-typelits-extra ==0.4.2
   - ghc-typelits-knownnat ==0.7.5
   - ghc-typelits-natnormalise ==0.7.4
-  - ghc-typelits-presburger ==0.5.2.0
+  - ghc-typelits-presburger ==0.6.0.0
   - ghost-buster ==0.1.1.0
   - gi-atk ==2.0.22
   - gi-cairo ==1.0.24
···
   - gingersnap ==0.3.1.0
   - gi-pango ==1.0.23
   - githash ==0.1.5.0
-  - github ==0.26
-  - github-release ==1.3.6
+  - github-release ==1.3.7
   - github-rest ==1.0.3
   - github-types ==0.2.1
   - github-webhooks ==0.15.0
···
   - graphite ==0.10.0.1
   - graphql-client ==1.1.0
   - graphs ==0.7.1
+  - graphula ==2.0.0.3
   - graphviz ==2999.20.1.0
   - graph-wrapper ==0.2.6.0
   - gravatar ==0.8.0
···
   - hackage-db ==2.1.0
   - hackage-security ==0.6.0.1
   - haddock-library ==1.9.0
-  - hadolint ==1.23.0
   - hadoop-streaming ==0.2.0.3
   - hakyll-convert ==0.3.0.4
   - half ==0.3.1
···
   - hdaemonize ==0.5.6
   - HDBC ==2.4.0.3
   - HDBC-session ==0.1.2.0
-  - headroom ==0.4.0.0
+  - headroom ==0.4.1.0
   - heap ==1.0.4
   - heaps ==0.3.6.1
   - hebrew-time ==0.1.2
-  - hedgehog ==1.0.4
+  - hedgehog ==1.0.5
   - hedgehog-corpus ==0.2.0
   - hedgehog-fakedata ==0.0.1.4
   - hedgehog-fn ==1.0
···
   - hexml ==0.3.4
   - hexml-lens ==0.2.1
   - hexpat ==0.20.13
-  - hexstring ==0.11.1
   - hformat ==0.3.3.1
   - hfsevents ==0.1.6
   - hgrev ==0.2.6
   - hidapi ==0.1.5
-  - hie-bios ==0.7.4
+  - hie-bios ==0.7.5
   - hi-file-parser ==0.1.0.0
   - higher-leveldb ==0.6.0.0
   - highlighting-kate ==0.6.4
   - hinfo ==0.0.3.0
   - hinotify ==0.4.1
-  - hint ==0.9.0.3
+  - hint ==0.9.0.4
   - hjsmin ==0.2.0.4
   - hkd-default ==1.1.0.0
   - hkgr ==0.2.7
···
   - hsinstall ==2.6
   - HSlippyMap ==3.0.1
   - hslogger ==1.3.1.0
-  - hslua ==1.2.0
+  - hslua ==1.3.0.1
   - hslua-aeson ==1.0.3.1
   - hslua-module-doclayout ==0.2.0.1
+  - hslua-module-path ==0.1.0.1
   - hslua-module-system ==0.2.2.1
   - hslua-module-text ==0.3.0.1
   - HsOpenSSL ==0.11.5.1
···
   - hspec-parsec ==0
   - hspec-smallcheck ==0.5.2
   - hspec-tables ==0.0.1
-  - hspec-wai ==0.10.1
-  - hspec-wai-json ==0.10.1
+  - hspec-wai ==0.11.0
+  - hspec-wai-json ==0.11.0
   - hs-php-session ==0.0.9.3
-  - hsshellscript ==3.4.5
+  - hsshellscript ==3.5.0
+  - hs-tags ==0.1.5
   - HStringTemplate ==0.8.7
   - HSvm ==0.1.1.3.22
   - HsYAML ==0.2.1.0
···
   - html-entities ==1.1.4.3
   - html-entity-map ==0.1.0.0
   - htoml ==1.0.0.3
-  - http2 ==2.0.5
+  - http2 ==2.0.6
   - HTTP ==4000.3.15
-  - http-api-data ==0.4.1.1
+  - http-api-data ==0.4.2
   - http-client ==0.6.4.1
   - http-client-openssl ==0.3.2.0
   - http-client-overrides ==0.1.1.0
···
   - http-directory ==0.1.8
   - http-download ==0.2.0.0
   - httpd-shed ==0.4.1.1
-  - http-link-header ==1.0.3.1
+  - http-link-header ==1.2.0
   - http-media ==0.8.0.0
   - http-query ==0.1.0.1
   - http-reverse-proxy ==0.6.0
···
   - indexed-list-literals ==0.2.1.3
   - indexed-profunctors ==0.1
   - indexed-traversable ==0.1.1
+  - indexed-traversable-instances ==0.1
   - infer-license ==0.2.0
   - inflections ==0.4.0.6
-  - influxdb ==1.9.1
+  - influxdb ==1.9.1.1
   - ini ==0.4.1
   - inj ==1.0
   - inline-c ==0.9.1.4
···
   - ix-shapable ==0.1.0
   - jack ==0.7.1.4
   - jalaali ==1.0.0.0
-  - jira-wiki-markup ==1.3.3
+  - jira-wiki-markup ==1.3.4
   - jose ==0.8.4
-  - jose-jwt ==0.9.0
+  - jose-jwt ==0.9.1
   - js-chart ==2.9.4.1
   - js-dgtable ==0.5.2
   - js-flot ==0.8.3
···
   - kawhi ==0.3.0
   - kazura-queue ==0.1.0.4
   - kdt ==0.2.4
+  - keep-alive ==0.2.0.0
   - keycode ==0.2.2
   - keys ==3.12.3
   - ki ==0.2.0.1
···
   - kubernetes-webhook-haskell ==0.2.0.3
   - l10n ==0.1.0.1
   - labels ==0.3.3
+  - lackey ==1.0.14
   - LambdaHack ==0.9.5.0
   - lame ==0.2.0
   - language-avro ==0.1.3.1
···
   - lapack ==0.3.2
   - lapack-carray ==0.0.3
   - lapack-comfort-array ==0.0.0.1
-  - lapack-ffi ==0.0.2
+  - lapack-ffi ==0.0.3
   - lapack-ffi-tools ==0.1.2.1
   - largeword ==1.2.5
   - latex ==0.1.0.4
···
   - liboath-hs ==0.0.1.2
   - libyaml ==0.1.2
   - LibZip ==1.0.1
-  - life-sync ==1.1.1.0
   - lifted-async ==0.10.1.3
   - lifted-base ==0.2.3.12
   - lift-generics ==0.2
···
   - list-singleton ==1.0.0.5
   - list-t ==1.0.4
   - ListTree ==0.2.3
-  - little-logger ==0.3.1
   - little-rio ==0.2.2
   - llvm-hs ==9.0.1
   - llvm-hs-pure ==9.0.0
···
   - messagepack ==0.5.4
   - metrics ==0.4.1.1
   - mfsolve ==0.3.2.0
-  - microlens ==0.4.11.2
+  - microlens ==0.4.12.0
   - microlens-aeson ==2.3.1
   - microlens-contra ==0.1.0.2
-  - microlens-ghc ==0.4.12
+  - microlens-ghc ==0.4.13
   - microlens-mtl ==0.2.0.1
-  - microlens-platform ==0.4.1
+  - microlens-platform ==0.4.2
   - microlens-process ==0.2.0.2
   - microlens-th ==0.4.3.9
   - microspec ==0.2.1.3
···
   - mixed-types-num ==0.4.1
   - mltool ==0.2.0.1
   - mmap ==0.5.9
-  - mmark ==0.0.7.3
+  - mmark ==0.0.7.2
   - mmark-cli ==0.0.5.0
   - mmark-ext ==0.2.1.3
   - mmorph ==1.1.5
···
   - mwc-random ==0.14.0.0
   - mwc-random-monad ==0.7.3.1
   - mx-state-codes ==1.0.0.0
-  - mysql ==0.1.7.3
+  - mysql ==0.2
   - mysql-simple ==0.4.5
   - n2o ==0.11.1
   - nagios-check ==0.3.2
···
   - nix-paths ==1.0.1
   - nonce ==1.0.7
   - nondeterminism ==1.4
-  - non-empty ==0.3.2
+  - non-empty ==0.3.3
   - nonempty-containers ==0.3.4.1
   - nonemptymap ==0.0.6.0
   - non-empty-sequence ==0.2.0.4
   - nonempty-vector ==0.2.1.0
+  - nonempty-zipper ==1.0.0.1
   - non-negative ==0.1.2
   - not-gloss ==0.7.7.0
   - no-value ==1.0.0.0
···
   - nsis ==0.3.3
   - numbers ==3000.2.0.2
   - numeric-extras ==0.1
-  - numeric-prelude ==0.4.3.2
+  - numeric-prelude ==0.4.3.3
   - numhask ==0.6.0.2
   - NumInstances ==1.4
   - numtype-dk ==0.5.0.2
···
   - optics-vl ==0.2.1
   - optional-args ==1.0.2
   - options ==1.2.1.1
-  - optparse-applicative ==0.15.1.0
-  - optparse-generic ==1.3.1
+  - optparse-applicative ==0.16.1.0
+  - optparse-generic ==1.4.4
   - optparse-simple ==0.1.1.3
   - optparse-text ==0.1.1.0
   - ordered-containers ==0.2.2
···
   - pager ==0.1.1.0
   - pagination ==0.2.2
   - pagure-cli ==0.2
-  - pandoc ==2.11.4
-  - pandoc-plot ==1.1.0
+  - pandoc ==2.12
+  - pandoc-plot ==1.1.1
   - pandoc-types ==1.22
   - pantry ==0.5.1.4
   - parallel ==3.2.2.0
···
   - partial-handler ==1.0.3
   - partial-isomorphisms ==0.2.2.1
   - partial-semigroup ==0.5.1.8
-  - password ==2.1.1.0
-  - password-instances ==2.0.0.2
+  - password ==3.0.0.0
+  - password-instances ==3.0.0.0
+  - password-types ==1.0.0.0
   - path ==0.7.0
   - path-binary-instance ==0.1.0.1
   - path-extensions ==0.1.1.0
···
   - promises ==0.3
   - prompt ==0.1.1.2
   - prospect ==0.1.0.0
-  - proto3-wire ==1.1.0
+  - proto3-wire ==1.2.0
   - protobuf ==0.2.1.3
   - protobuf-simple ==0.1.1.0
   - protocol-buffers ==2.4.17
···
   - protocol-radius ==0.0.1.1
   - protocol-radius-test ==0.1.0.1
   - proto-lens ==0.7.0.0
-  - proto-lens-optparse ==0.1.1.7
   - proto-lens-protobuf-types ==0.7.0.0
   - proto-lens-protoc ==0.7.0.0
   - proto-lens-runtime ==0.7.0.0
···
   - rank2classes ==1.4.1
   - Rasterific ==0.7.5.3
   - rasterific-svg ==0.3.3.2
-  - ratel ==1.0.13
+  - ratel ==1.0.14
   - rate-limit ==1.4.2
-  - ratel-wai ==1.1.4
+  - ratel-wai ==1.1.5
   - rattle ==0.2
+  - rattletrap ==11.0.0
   - Rattus ==0.5
   - rawfilepath ==0.2.4
   - rawstring-qm ==0.2.3.0
···
   - regex-compat ==0.95.2.1
   - regex-compat-tdfa ==0.95.1.4
   - regex-pcre ==0.95.0.0
-  - regex-pcre-builtin ==0.95.1.3.8.43
+  - regex-pcre-builtin ==0.95.2.3.8.43
   - regex-posix ==0.96.0.0
   - regex-tdfa ==1.3.1.0
   - regex-with-pcre ==1.1.0.0
···
   - req ==3.9.0
   - req-conduit ==1.0.0
   - rerebase ==1.6.1
+  - rescue ==0.4.2.1
   - resistor-cube ==0.0.1.2
   - resolv ==0.1.2.0
   - resource-pool ==0.2.3.2
···
   - selda-postgresql ==0.1.8.1
   - selda-sqlite ==0.1.7.1
   - selections ==0.3.0.0
-  - selective ==0.4.1.1
+  - selective ==0.4.2
   - semialign ==1.1.0.1
   - semialign-indexed ==1.1
   - semialign-optics ==1.1
···
   - servant-exceptions ==0.2.1
   - servant-exceptions-server ==0.2.1
   - servant-foreign ==0.15.3
-  - servant-github-webhook ==0.4.2.0
   - servant-http-streams ==0.18.2
   - servant-machines ==0.15.1
   - servant-multipart ==0.12
···
   - singleton-bool ==0.1.5
   - singleton-nats ==0.4.5
   - singletons ==2.7
-  - singletons-presburger ==0.5.0.0
+  - singletons-presburger ==0.6.0.0
   - siphash ==1.0.3
   - sitemap-gen ==0.1.0.0
   - sized ==1.0.0.0
   - skein ==1.0.9.4
   - skews ==0.1.0.3
   - skip-var ==0.1.1.0
-  - skylighting ==0.10.4
-  - skylighting-core ==0.10.4
+  - skylighting ==0.10.4.1
+  - skylighting-core ==0.10.4.1
   - slack-api ==0.12
   - slack-progressbar ==0.1.0.1
   - slist ==0.1.1.0
···
   - storable-record ==0.0.5
   - storable-tuple ==0.0.3.3
   - storablevector ==0.2.13.1
-  - store ==0.7.9
+  - store ==0.7.10
   - store-core ==0.4.4.4
   - store-streaming ==0.2.0.3
   - stratosphere ==0.59.1
···
   - streaming-attoparsec ==1.0.0.1
   - streaming-bytestring ==0.2.0
   - streaming-commons ==0.2.2.1
+  - streamly ==0.7.3
   - streams ==3.3
   - strict ==0.4.0.1
   - strict-concurrency ==0.2.4.3
···
   - stripe-haskell ==2.6.2
   - stripe-http-client ==2.6.2
   - stripe-tests ==2.6.2
-  - strive ==5.0.13
+  - strive ==5.0.14
   - structs ==0.1.5
   - structured ==0.1.0.1
-  - structured-cli ==2.6.0.0
-  - subcategories ==0.1.0.0
+  - structured-cli ==2.7.0.1
+  - subcategories ==0.1.1.0
   - sum-type-boilerplate ==0.1.1
   - sundown ==0.6
   - superbuffer ==0.3.1.1
···
   - tar ==0.5.1.1
   - tar-conduit ==0.3.2
   - tardis ==0.4.3.0
-  - tasty ==1.2.3
-  - tasty-ant-xml ==1.1.7
+  - tasty ==1.4.1
+  - tasty-ant-xml ==1.1.8
   - tasty-bench ==0.2.2
   - tasty-dejafu ==2.0.0.7
   - tasty-discover ==4.2.2
   - tasty-expected-failure ==0.12.3
   - tasty-focus ==1.0.1
-  - tasty-golden ==2.3.3.2
+  - tasty-golden ==2.3.4
   - tasty-hedgehog ==1.0.1.0
   - tasty-hspec ==1.1.6
   - tasty-hunit ==0.10.0.3
···
   - tasty-program ==1.0.5
   - tasty-quickcheck ==0.10.1.2
   - tasty-rerun ==1.1.18
-  - tasty-silver ==3.1.15
+  - tasty-silver ==3.2.1
   - tasty-smallcheck ==0.8.2
   - tasty-test-reporter ==0.1.1.4
   - tasty-th ==0.1.7
···
   - test-framework-smallcheck ==0.2
   - test-fun ==0.1.0.0
   - testing-type-modifiers ==0.1.0.1
-  - texmath ==0.12.1.1
+  - texmath ==0.12.2
   - text-ansi ==0.1.1
   - text-binary ==0.2.1.1
   - text-builder ==0.6.6.1
···
   - text-latin1 ==0.3.1
   - text-ldap ==0.1.1.13
   - textlocal ==0.1.0.5
-  - text-manipulate ==0.2.0.1
+  - text-manipulate ==0.3.0.0
   - text-metrics ==0.3.0
   - text-postgresql ==0.0.3.1
   - text-printer ==0.5.0.1
···
   - text-show ==3.9
   - text-show-instances ==3.8.4
   - text-zipper ==0.11
-  - tfp ==1.0.1.1
+  - tfp ==1.0.2
   - tf-random ==0.5
   - th-abstraction ==0.4.2.0
   - th-bang-compat ==0.0.1.0
-  - th-compat ==0.1.1
+  - th-compat ==0.1.2
   - th-constraint-compat ==0.0.1.0
   - th-data-compat ==0.1.0.0
   - th-desugar ==1.11
···
   - these-lens ==1.0.1.2
   - these-optics ==1.0.1.2
   - these-skinny ==0.7.4
-  - th-expand-syns ==0.4.6.0
+  - th-expand-syns ==0.4.8.0
   - th-extras ==0.0.0.4
   - th-lift ==0.8.2
   - th-lift-instances ==0.1.18
···
   - topograph ==1.0.0.1
   - torsor ==0.1
   - tostring ==0.2.1.1
-  - tracing ==0.0.5.2
-  - tracing-control ==0.0.6
   - transaction ==0.1.1.3
   - transformers-base ==0.4.5.2
   - transformers-bifunctors ==0.1
   - transformers-compat ==0.6.6
   - transformers-fix ==1.0
   - traverse-with-class ==1.0.1.0
-  - tree-diff ==0.1
+  - tree-diff ==0.2
   - tree-fun ==0.8.1.0
   - tree-view ==0.5.1
   - trifecta ==2.1.1
···
   - tuples-homogenous-h98 ==0.1.1.0
   - tuple-sop ==0.3.1.0
   - tuple-th ==0.2.5
-  - turtle ==1.5.20
+  - turtle ==1.5.21
   - typecheck-plugin-nat-simple ==0.1.0.2
   - TypeCompose ==0.9.14
   - typed-process ==0.2.6.0
···
   - unicode ==0.0.1.1
   - unicode-show ==0.1.0.4
   - unicode-transforms ==0.3.7.1
+  - unification-fd ==0.11.1
   - union-find ==0.2
   - unipatterns ==0.0.0.0
   - uniplate ==1.6.13
···
   - utf8-light ==0.4.2
   - utf8-string ==1.0.2
   - util ==0.1.17.1
-  - utility-ht ==0.0.15
+  - utility-ht ==0.0.16
   - uuid ==1.3.14
   - uuid-types ==1.0.4
   - validation ==1.1.1
-  - validation-selective ==0.1.0.0
+  - validation-selective ==0.1.0.1
   - validity ==0.11.0.0
   - validity-aeson ==0.2.0.4
   - validity-bytestring ==0.4.1.1
···
   - wai-feature-flags ==0.1.0.1
   - wai-handler-launch ==3.0.3.1
   - wai-logger ==2.3.6
-  - wai-middleware-auth ==0.2.3.1
   - wai-middleware-caching ==0.1.0.2
   - wai-middleware-clacks ==0.1.0.1
   - wai-middleware-static ==0.9.0
···
   - Win32-notify ==0.3.0.3
   - windns ==0.1.0.1
   - witch ==0.0.0.5
-  - witherable-class ==0
+  - witherable ==0.4.1
   - within ==0.2.0.1
   - with-location ==0.1.0
   - with-utf8 ==1.0.2.2
···
   - yesod-gitrev ==0.2.1
   - yesod-markdown ==0.12.6.6
   - yesod-newsfeed ==1.7.0.0
-  - yesod-page-cursor ==2.0.0.4
   - yesod-paginator ==1.1.1.0
   - yesod-persistent ==1.6.0.5
   - yesod-sitemap ==1.6.0
···
   - Cabal == 2.2.*                      # required for jailbreak-cabal etc.
   - Cabal == 2.4.*                      # required for cabal-install etc.
   - Cabal == 3.2.*                      # required for cabal-install etc.
+  - base16-bytestring < 1               # required for cabal-install etc.
   - dhall == 1.29.0                     # required for ats-pkg
   - dhall == 1.37.1                     # required for spago 0.19.0.
   - Diff < 0.4                          # required by liquidhaskell-0.8.10.2: https://github.com/ucsd-progsys/liquidhaskell/issues/1729
···
   alsa-mixer:                                   [ x86_64-darwin ]
   alsa-pcm:                                     [ x86_64-darwin ]
   alsa-seq:                                     [ x86_64-darwin ]
-  AWin32Console:                                [ i686-linux, x86_64-linux, x86_64-darwin ]
-  barbly:                                       [ i686-linux, x86_64-linux ]
+  AWin32Console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  barbly:                                       [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ]
   bindings-directfb:                            [ x86_64-darwin ]
-  d3d11binding:                                 [ i686-linux, x86_64-linux, x86_64-darwin ]
-  DirectSound:                                  [ i686-linux, x86_64-linux, x86_64-darwin ]
-  dx9base:                                      [ i686-linux, x86_64-linux, x86_64-darwin ]
-  dx9d3d:                                       [ i686-linux, x86_64-linux, x86_64-darwin ]
-  dx9d3dx:                                      [ i686-linux, x86_64-linux, x86_64-darwin ]
+  d3d11binding:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  DirectSound:                                  [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  dx9base:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  dx9d3d:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  dx9d3dx:                                      [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
   freenect:                                     [ x86_64-darwin ]
   FTGL:                                         [ x86_64-darwin ]
   gi-ostree:                                    [ x86_64-darwin ]
-  gtk-mac-integration:                          [ i686-linux, x86_64-linux ]
+  gtk-mac-integration:                          [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ]
   hcwiid:                                       [ x86_64-darwin ]
   HFuse:                                        [ x86_64-darwin ]
-  hommage-ds:                                   [ i686-linux, x86_64-linux, x86_64-darwin ]
+  hommage-ds:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
   lio-fs:                                       [ x86_64-darwin ]
   midi-alsa:                                    [ x86_64-darwin ]
   pam:                                          [ x86_64-darwin ]
   PortMidi:                                     [ x86_64-darwin ]
   Raincat:                                      [ x86_64-darwin ]
-  reactivity:                                   [ i686-linux, x86_64-linux, x86_64-darwin ]
+  reactivity:                                   [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
   rtlsdr:                                       [ x86_64-darwin ]
   rubberband:                                   [ x86_64-darwin ]
   sdl2-mixer:                                   [ x86_64-darwin ]
···
   tokyotyrant-haskell:                          [ x86_64-darwin ]
   vulkan:                                       [ i686-linux, armv7l-linux ]
   VulkanMemoryAllocator:                        [ i686-linux, armv7l-linux ]
-  Win32-console:                                [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-dhcp-server:                            [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-errors:                                 [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-extras:                                 [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-junction-point:                         [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-notify:                                 [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-security:                               [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-services-wrapper:                       [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32-services:                               [ i686-linux, x86_64-linux, x86_64-darwin ]
-  Win32:                                        [ i686-linux, x86_64-linux, x86_64-darwin ]
+  Win32-console:                                [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-dhcp-server:                            [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-errors:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-extras:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-junction-point:                         [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-notify:                                 [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-security:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-services-wrapper:                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32-services:                               [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
+  Win32:                                        [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
   xattr:                                        [ x86_64-darwin ]
-  XInput:                                       [ i686-linux, x86_64-linux, x86_64-darwin ]
+  XInput:                                       [ i686-linux, x86_64-linux, x86_64-darwin, aarch64-linux, armv7l-linux ]
   xmobar:                                       [ x86_64-darwin ]
 
 dont-distribute-packages:
···
   - asic
   - asil
   - asn
+  - ASN1
   - asn1-codec
   - asn1-data
   - assert
···
   - Chart-tests
   - chart-unit
   - charter
-  - chatter
   - chatty-text
   - chatwork
   - cheapskate-terminal
···
   - fractals
   - fraction
   - frag
+  - frame-markdown
   - Frames-beam
   - Frames-dsv
   - Frames-map-reduce
···
   - ftree
   - ftshell
   - full-sessions
-  - fullstop
   - funbot
   - funbot-client
   - funbot-git-hook
···
   - hahp
   - haiji
   - hailgun-send
+  - hails-bin
   - hairy
   - hakaru
   - hakismet
···
   - hakyll-contrib-links
   - hakyll-dhall
   - hakyll-dir-list
+  - hakyll-elm
   - hakyll-favicon
   - hakyll-filestore
   - hakyll-images
···
   - haskell-reflect
   - haskell-rules
   - haskell-spacegoo
-  - haskell-src
   - haskell-src-exts-observe
   - haskell-src-exts-prisms
   - haskell-src-exts-qq
···
   - haskellscript
   - HaskellTorrent
   - HaskellTutorials
+  - haskelm
   - haskelzinc
   - haskeme
   - haskey
···
   - hopencl
   - HOpenCV
   - hopfield
-  - hoppy-docs
-  - hoppy-generator
-  - hoppy-runtime
-  - hoppy-std
   - hops
   - hoq
   - horizon
···
   - http-wget
   - http2-client-grpc
   - http2-grpc-proto-lens
+  - http2-grpc-proto3-wire
   - https-everywhere-rules
   - https-everywhere-rules-raw
   - httpspec
···
   - hw-kafka-avro
   - hw-prim-bits
   - hw-simd
+  - hw-simd-cli
   - hw-uri
   - hwall-auth-iitk
   - hweblib
···
   - proto-lens-combinators
   - proto-lens-descriptors
   - proto3-suite
+  - proto3-wire
   - protobuf-native
   - protocol
   - protocol-buffers-descriptor-fork
···
   - qr-imager
   - qr-repa
   - qsem
-  - qtah-cpp-qt5
-  - qtah-examples
-  - qtah-generator
-  - qtah-qt5
   - QuadEdge
   - QuadTree
   - quantfin
···
   - sha1
   - shade
   - shadower
-  - shake-bench
   - shake-bindist
   - shake-cabal-build
   - shake-dhall
···
   - Shpadoinkle-examples
   - Shpadoinkle-html
   - Shpadoinkle-router
+  - Shpadoinkle-template
   - Shpadoinkle-widgets
   - shpider
   - shuffle
···
   - snap-auth-cli
   - snap-blaze-clay
   - snap-configuration-utilities
+  - snap-elm
   - snap-error-collector
   - snap-extras
   - snap-routes
···
   - snaplet-hdbc
   - snaplet-hslogger
   - snaplet-influxdb
+  - snaplet-lss
   - snaplet-mandrill
   - snaplet-mongoDB
   - snaplet-mongodb-minimalistic
···
   - wai-middleware-route
   - wai-middleware-static-caching
   - wai-middleware-travisci
+  - wai-middleware-validation
   - wai-rate-limit-redis
   - wai-request-spec
   - wai-responsible

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

···
          attoparsec base bytestring linear packer
        ];
        description = "3D model parsers";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "ASN.1 support for Haskell";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "AVar" = callPackage
···
        libraryHaskellDepends = [ base regex-compat Win32 ];
        description = "A binding to a part of the ANSI escape code for the console";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "AbortT-monadstf" = callPackage
···
          PrimitiveArray vector
        ];
        description = "Collection of alignment algorithms";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers mtl poly-rec requirements tagged template-haskell
        ];
        description = "Strongly typed Attribute Grammars implemented using type-level programming";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "AttoBencode" = callPackage
···
        pname = "BNFC-meta";
        version = "0.6.1";
        sha256 = "0snackflcjxza4iqbd85fdsmylwr3bj71nsfrs2s2idc3nlxc7ia";
-       revision = "1";
-       editedCabalFile = "1lj92qxjf7gbgifhz1p6jw20079x6772gkbhvpd8ba4956dvzna3";
+       revision = "2";
+       editedCabalFile = "1xg96a83jhz5jiw16yrgm3x5k7fz7zmz6cvggnfmjvw7v7bl69ph";
        libraryHaskellDepends = [
          alex-meta array base fail happy-meta haskell-src-meta syb
          template-haskell
        ];
        description = "Deriving Parsers and Quasi-Quoters from BNF Grammars";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "Baggins" = callPackage
···
        editedCabalFile = "16206xd8lm8fkvpxbm19h403264xyjki07s9lam3pgq985xbqk35";
        libraryHaskellDepends = [ base cairo containers mtl ];
        description = "Tools for self-assembly";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring cassava deepseq directory statistics time vector
        ];
        description = "Benchmark functions with history";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          filepath parsec ParsecTools StockholmAlignment SVGFonts text vector
        ];
        description = "Libary for Hidden Markov Models in HMMER3 format";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          vector-read-instances zlib
        ];
        description = "Base library for bioinformatics";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-silver tasty-th text
        ];
        description = "BLAST-related tools";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0m7n3c2ly6kly146xrxzx41g3pv0cylrmzpdgv5c54x9gvb1hg7w";
        libraryHaskellDepends = [ base bytestring iteratee ];
        description = "Vienna / DotBracket / ExtSS parsers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          directory either-unwrap text vector word8
        ];
        description = "Ensembl related datastructures and functions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base BiobaseXNA bytestring containers filemanip iteratee tuple
        ];
        description = "Importer for FR3D resources";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          http-conduit hxt mtl network Taxonomy text transformers
        ];
        description = "Libary to interface with the Bioinformatics HTTP services - Entrez Ensembl";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          either-unwrap hxt text
        ];
        description = "Tools to query Bioinformatics HTTP services e.g. Entrez, Ensembl.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base criterion lens text transformers
        ];
        description = "Infernal data structures and tools";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0mwyyb7n232wgjipn9jsbqpcbxqms07adi5a6v14qaiynsjz4n1r";
        libraryHaskellDepends = [ base bytestring containers iteratee ];
        description = "Multiple Alignment Format";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ cmdargs ];
        description = "RNA folding training data";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          filepath lens primitive PrimitiveArray repa split vector
        ];
        description = "Import Turner RNA parameters";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base BiobaseTurner BiobaseXNA primitive PrimitiveArray vector
        ];
        description = "Import Vienna energy parameters";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          HTTP http-conduit hxt mtl network transformers zip-archive
        ];
        description = "Libary to interface with the NCBI blast REST interface";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ base cmdargs ];
        description = "A tool for posting Haskelly articles to blogs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers criterion MissingH network-uri parsec
        ];
        description = "A markdown-like markup language designed for blog posts";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          QuickCheck test-framework test-framework-quickcheck2
        ];
        description = "Encode/Decode values to/from CBOR";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ cmdargs ];
        description = "Infernal covariance model comparison";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base hspec hspec-discover parsec text ];
        testToolDepends = [ hspec-discover ];
        description = "Libary for parsing Clustal tools output";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "Color";
-       version = "0.3.0";
-       sha256 = "18aissrpllxll01k203i2agfff89ffah465zvb0yx0lvs8jh2xr7";
+       version = "0.3.1";
+       sha256 = "1gg15kb6za69w0b3x8pzrqbrh9b8g7g0zwj2a9ajf0wgp8kylp5b";
        libraryHaskellDepends = [ base data-default-class deepseq vector ];
        testHaskellDepends = [
          base colour doctest hspec HUnit JuicyPixels massiv massiv-test
···
          transformers-compat utf8-string xml-conduit xml-hamlet
        ];
        description = "RFC 4918 WebDAV support";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "DBFunctor" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base MuCheck ];
        description = "Distributed Mutation Analysis framework for MuCheck";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          utf8-string
        ];
        description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "Decimal";
-       version = "0.5.1";
-       sha256 = "0k7kh05mr2f54w1lpgq1nln0h8k6s6h99dyp5jzsb9cfbb3aap2p";
+       version = "0.5.2";
+       sha256 = "19w7i9f0lbiyzwa0v3bm95233vi7f1688f0xms6cnjsf88h04ym3";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq HUnit QuickCheck test-framework test-framework-hunit
···
        ];
        testHaskellDepends = [ base hspec lens mtl text ];
        description = "A client library for the DigitalOcean API";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ dsound ];
        description = "Partial binding to the Microsoft DirectSound API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {dsound = null;};
 
   "DisTract" = callPackage
···
        ];
        testHaskellDepends = [ base doctest ];
        description = "Discussion support system";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          PrimitiveArray repa split vector
        ];
        description = "Frameshift-aware alignment of protein sequences with DNA sequences";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          array base criterion QuickCheck random vector
        ];
        description = "Dynamic time warping of sequences";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          Taxonomy text transformers
        ];
        description = "Libary to interface with the NCBI Entrez REST service";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers ghc mtl operational random SafeSemaphore time unix
        ];
        description = "A general data-flow framework";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          array base containers deepseq Etage fgl mtl parallel random time
        ];
        description = "Data-flow based graph algorithms";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base inline-c ];
        testHaskellDepends = [ base hspec inline-c ];
        description = "Haskell Foreign Accelerate Interface";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "FComp" = callPackage
···
          template-haskell time uu-parsinglib
        ];
        description = "Compose music";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base ];
        librarySystemDepends = [ fmodex64 ];
        description = "The Haskell FModEx raw API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {fmodex64 = null;};
···
        librarySystemDepends = [ ftgl ];
        description = "Portable TrueType font rendering for OpenGL using the Freetype2 library";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) ftgl;};
 
   "FTGL-bytestring" = callPackage
···
        sha256 = "13n80rplyl73ahk8cxgvs9gf655l063sd55spx0zvhw774vvxwv4";
        libraryHaskellDepends = [ base OpenGLRaw ];
        description = "Utilities for working with OpenGL matrices";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base QuickCheck tasty tasty-quickcheck tasty-th vector
        ];
        description = "Hox gene clustering";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-th
        ];
        description = "MCFGs for Genus-1 RNA Pseudoknots";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base dataenc download-curl utf8-string xml
        ];
        description = "Interface to Google Suggest API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "GoogleTranslate" = callPackage
···
          AttoJson base bytestring dataenc download-curl
        ];
        description = "Interface to Google Translate API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base ];
        description = "Grammar products and higher-dimensional grammars";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ array base mtl ];
        description = "Graph500 benchmark-related definitions and data set generator";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          array base containers Graph500 mtl stm time
        ];
        description = "GraphHammer Haskell graph analyses framework inspired by STINGER";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          array base containers Graph500 GraphHammer mtl
        ];
        description = "Test harness for TriangleCount analysis";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "09h6wfalziw39c2sghj8qw82vyvnl01qlsam6ngkfkdirgj5sg5h";
        libraryHaskellDepends = [ base c-storable-deriving ];
        description = "A Queue with a random (weighted) pick function";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        '';
        description = "HFuse is a binding for the Linux FUSE library";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) fuse;};
 
   "HGE2D" = callPackage
···
        executableHaskellDepends = [ base ];
        executablePkgconfigDepends = [ opencv ];
        description = "A binding for the OpenCV computer vision library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) opencv;};
···
          HROOT-io HROOT-math HROOT-tree template-haskell
        ];
        description = "Haskell binding to the ROOT data analysis framework";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base fficxx fficxx-runtime template-haskell
        ];
        description = "Haskell binding to ROOT Core modules";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base fficxx fficxx-runtime HROOT-core HROOT-hist template-haskell
        ];
        description = "Haskell binding to ROOT Graf modules";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base fficxx fficxx-runtime HROOT-core template-haskell
        ];
        description = "Haskell binding to ROOT Hist modules";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base fficxx fficxx-runtime HROOT-core template-haskell
        ];
        description = "Haskell binding to ROOT IO modules";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base fficxx fficxx-runtime HROOT-core template-haskell
        ];
        description = "Haskell binding to ROOT Math modules";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base fficxx fficxx-runtime HROOT-core template-haskell
        ];
        description = "Haskell binding to ROOT Tree modules";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers
        ];
        description = "The Haskell Test Framework";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0q7fq5z0wrk2qg9n715033yp25dpl73g6iqkbvxbg2ahp9caq458";
        libraryHaskellDepends = [ base bytestring serialport stm ];
        description = "An Haskell library to drive the french Minitel through a serial port";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base Cabal containers HUnit tuple vector ];
        description = "Aggression analysis for Tweets on Twitter";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        executableHaskellDepends = [ base random transformers ];
        testHaskellDepends = [ base hspec transformers ];
        description = "The classic game of Hangman";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          process sox template-haskell uu-parsinglib vector
        ];
        description = "Harmony Analysis and Retrieval of Music";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          uu-parsinglib
        ];
        description = "Parsing and unambiguously representing musical chords";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "HasBigDecimal" = callPackage
···
        librarySystemDepends = [ CacBDD ];
        testHaskellDepends = [ base hspec QuickCheck ];
        description = "Haskell bindings for CacBDD";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {CacBDD = null;};
···
          base haskell98 hmatrix hmatrix-special mtl parsec random
        ];
        description = "A Haskell library for inference using Gaussian processes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers directory ghc-prim HList tagged
        ];
        description = "HaskRel, Haskell as a DBMS with support for the relational algebra";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.publicDomain;
      }) {inherit (pkgs) openssl;};
 
+  "HsOpenSSL_0_11_6" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, network, openssl, time }:
+     mkDerivation {
+       pname = "HsOpenSSL";
+       version = "0.11.6";
+       sha256 = "1gkx6kk03ziz9wk6iwxcdpf1ig8a9whwv3yjbzmqrwkp7fh1wdrw";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [ base bytestring network time ];
+       librarySystemDepends = [ openssl ];
+       testHaskellDepends = [ base bytestring ];
+       description = "Partial OpenSSL binding for Haskell";
+       license = lib.licenses.publicDomain;
+       hydraPlatforms = lib.platforms.none;
+     }) {inherit (pkgs) openssl;};
+
   "HsOpenSSL-x509-system" = callPackage
     ({ mkDerivation, base, bytestring, HsOpenSSL, unix }:
      mkDerivation {
···
          text
        ];
        description = "Pure Haskell YAML 1.2 processor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "HsYAML-aeson" = callPackage
···
        ];
        benchmarkHaskellDepends = [ array base criterion Munkres random ];
        description = "A Linear Sum Assignment Problem (LSAP) solver";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Hydrogen" = callPackage
···
        libraryHaskellDepends = [ array base QuickCheck ];
        testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
        description = "Code for the Haskell course taught at the University of Seville";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "06px87hc6gz7n372lvpbq0g2v2s0aghd3k5a1ajgn5hbxirhnpwb";
        libraryHaskellDepends = [ base mtl template-haskell ];
        description = "A library for writing Imperative style haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base doctest ];
        description = "DSL for IRC bots";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0ivqfk1rac1hv5j6nlsbpcm5yjqwpic34mdq9gf2m63lygqkbwqp";
        libraryHaskellDepends = [ base hosc ];
        description = "control JackMiniMix";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "JuicyPixels-blurhash";
        version = "0.1.0.3";
        sha256 = "0kgl2j7990p8q5yrkn0wgaszc9fzva1pc3277j11k1lbjsymz360";
-       revision = "3";
-       editedCabalFile = "1mspqkmvn5j6xs3cb882szbnrzaxf0p2nyyxkfqfnbma204cs2fi";
+       revision = "4";
+       editedCabalFile = "0jxrcv4x3xr3v4lka0z5b13ywdic5f1dh19ivshrvad3xnv7kx0g";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          pipes-parse
        ];
        description = "Library for RedPitaya";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base directory filepath unix ];
        description = "A simple sandboxing tool for Haskell packages";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base directory random SDL SDL-ttf ];
        description = "A Snake II clone written using SDL";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base binary bytestring HTF mtl ];
        testHaskellDepends = [ base binary bytestring HTF mtl ];
        description = "Algorithmic Doom map generation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers mtl ];
        testHaskellDepends = [ base containers mtl ];
        description = "Generate MASM code from haskell";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0yh84vybrxs6bv3z4qx4n9m4xwsb4kw21l35s5v4gg8yllgbb79r";
        libraryHaskellDepends = [ base bytestring hidapi mtl ];
        description = "Haskell interface for controlling the mBot educational robot";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ cmdargs split ];
        description = "Folding algorithm based on nucleotide cyclic motifs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty tasty-hunit tasty-quickcheck tasty-th
        ];
        description = "A GLPK backend to the MIP library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) glpk;};
···
        sha256 = "1yz7dgmhlkqmf3fc2y32j9lr01zfjjqy9pnnj3bh03b9khblw0pn";
        libraryHaskellDepends = [ base ];
        description = "Mapping";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1n90lfrvfr1ni7ninlxbs4wk0m7mibdpi9sy26ifih51nmk8nziq";
        libraryHaskellDepends = [ base numeric-prelude ];
        description = "Modular arithmetic via Numeric-Prelude";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "Moe" = callPackage
···
        sha256 = "1dglyak17db7q9nd6s255w2zh8lh192vidyjvgvh53vbybymb20z";
        libraryHaskellDepends = [ base containers split ];
        description = "Morse code";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "MuCheck" = callPackage
···
          temporary time
        ];
        description = "Automated Mutation Testing";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base HUnit MuCheck ];
        executableHaskellDepends = [ base HUnit MuCheck ];
        description = "Automated Mutation Testing for HUnit tests";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base hspec hspec-core MuCheck ];
        executableHaskellDepends = [ base hspec hspec-core MuCheck ];
        description = "Automated Mutation Testing for Hspec tests";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base MuCheck QuickCheck ];
        executableHaskellDepends = [ base MuCheck QuickCheck ];
        description = "Automated Mutation Testing for QuickCheck tests";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base MuCheck smallcheck ];
        executableHaskellDepends = [ base MuCheck smallcheck ];
        description = "Automated Mutation Testing for SmallCheck tests";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers unliftio-core vector xml-conduit xml-types
        ];
        description = "interface to MusicBrainz XML2 and JSON web services";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "MusicBrainz-libdiscid" = callPackage
···
          base QuickCheck tasty tasty-quickcheck tasty-th vector
        ];
        description = "Most likely order of mutation events in RNA";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-hunit test-framework-quickcheck2 time
        ];
        description = "A Haskell interface to Lego Mindstorms NXT";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {bluetooth = null;};
···
        editedCabalFile = "01ma6068mnwn9f7jpa5g8kkl7lyhl5wnpw9ad44zz9gki1mrw37i";
        libraryHaskellDepends = [ base containers random ];
        description = "A name generator written in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "NanoProlog" = callPackage
···
        sha256 = "1sdlnjnlbk5b04zyhr7574g2ghcivzvkxnm2aak4h9bik00gb1lv";
        libraryHaskellDepends = [ base random vector ];
        description = "A port of John Skilling's nested sampling C code to Haskell";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "NetSNMP" = callPackage
···
        libraryHaskellDepends = [ base containers primes ];
        testHaskellDepends = [ base containers HUnit primes ];
        description = "A library for number theoretic computations, written in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          ADPfusion base ghc-prim mtl primitive PrimitiveArray vector
        ];
        description = "Nussinov78 using the ADPfusion library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring containers ];
        description = "A library for analysis of 3-D protein coordinates";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "PPrinter" = callPackage
···
          old-locale process random RSA SafeSemaphore time unix
        ];
        description = "A proven synchronization server for high performance computing";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "11vshnbxfl8p38aix4h2b0vms8j58agwxbmhd9pkxai764sl6j7g";
        libraryHaskellDepends = [ base parsec ];
        description = "Parsec combinators for more complex objects";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "ParserFunction" = callPackage
···
        libraryHaskellDepends = [ base cmdargs HTTP network network-uri ];
        executableHaskellDepends = [ base cmdargs ];
        description = "CLI for pasting to lpaste.net";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "PathTree" = callPackage
···
          string-conversions temporary text time
        ];
        description = "Personal Happstack Server Utils";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "047aw1pka7xsqnshbmirkxd80m92w96xfb0kpi1a22bx0kpgg58w";
        libraryHaskellDepends = [ base containers regex-tdfa ];
        description = "Pluralize English words";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Pollutocracy" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base bytestring network splice ];
        description = "high-performance distributed reverse / forward proxy & tunneling for TCP";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ alsaLib ];
        description = "A binding for PortMedia/PortMidi";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) alsaLib;};
 
   "PortMidi-simple" = callPackage
···
        executableHaskellDepends = [ base ];
        doHaddock = false;
        description = "A networked event handling framework for hooking into other programs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base network parsec Pup-Events-PQueue stm transformers
        ];
        description = "A networked event handling framework for hooking into other programs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Pup-Events-Demo" = callPackage
···
          Pup-Events-Server stm
        ];
        description = "A networked event handling framework for hooking into other programs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0sngiqxzj5kif452s2hn3x1kv257815c5v19dp4wqazbyc373iwx";
        libraryHaskellDepends = [ base stm ];
        description = "A networked event handling framework for hooking into other programs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Pup-Events-Server" = callPackage
···
          base network parsec Pup-Events-PQueue stm transformers
        ];
        description = "A networked event handling framework for hooking into other programs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base QuickCheck ];
        testHaskellDepends = [ base hspec QuickCheck ];
        description = "Generator of \"valid\" and \"invalid\" data in a type class";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          websockets-snap
        ];
        description = "Quick and easy data visualization with Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base binary bytestring ];
        testHaskellDepends = [ base binary bytestring hspec ];
        description = "RLP serialization as defined in Ethereum Yellow Paper";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base BiobaseTurner BiobaseVienna BiobaseXNA cmdargs
        ];
        description = "RNA secondary structure prediction";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          containers HsTools primitive PrimitiveArray RNAFold split vector
        ];
        description = "RNA secondary structure folding";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ bytestring cmdargs file-embed ];
        description = "Multi-target RNA sequence design";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ cmdargs ];
        description = "Draw RNA secondary structures";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text time vector ViennaRNAParser
        ];
        description = "Unsupervized construction of RNA family models";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ cmdargs split ];
        description = "RNA folding with non-canonical basepairs and base-triplets";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "A puzzle game written in Haskell with a cat in lead role";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {};
 
   "Random123" = callPackage
···
          base cmdargs cond containers directory
        ];
        description = "A utility for computing distributions of material to review among reviewers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-quickcheck2
        ];
        description = "Limits the size of a directory's contents";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryToolDepends = [ c2hsc ];
        description = "Declarative coördination language for streaming networks";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          pipes-bytestring pipes-parse split
        ];
        description = "A parser for SWMM 5 binary .OUT files";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "SableCC2Hs" = callPackage
···
          regex-compat sqlite-simple unix
        ];
        description = "Size limited temp filesystem based on fuse";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base cmdargs directory either-unwrap
        ];
        description = "Selects a representative subset of sequences from multiple sequence alignment";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base directory filepath hslogger mtl old-locale random time
        ];
        description = "Easy Loggingframework";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          filepath mtl parsec QuickCheck regex-tdfa
        ];
        description = "Shell script analysis tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Shellac" = callPackage
···
        broken = true;
      }) {};
 
+  "Shpadoinkle-streaming" = callPackage
+    ({ mkDerivation, base, lens, Shpadoinkle, streaming, text }:
+     mkDerivation {
+       pname = "Shpadoinkle-streaming";
+       version = "0.0.0.1";
+       sha256 = "1bvrkyj9l8asczfamw26x1hwj8bcxr7812zjm1m91jg4xzipayv2";
+       libraryHaskellDepends = [ base lens Shpadoinkle streaming text ];
+       description = "Integration of the streaming library with Shpadoinkle continuations";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "Shpadoinkle-template" = callPackage
+    ({ mkDerivation, base, file-embed, html-parse, Shpadoinkle
+     , Shpadoinkle-backend-static, template-haskell, text
+     }:
+     mkDerivation {
+       pname = "Shpadoinkle-template";
+       version = "0.0.0.1";
+       sha256 = "1iyxb0hnyfcb4fipwrvzr03g3rai5lc5k7sysrd691l0dsh2jill";
+       libraryHaskellDepends = [
+         base html-parse Shpadoinkle Shpadoinkle-backend-static
+         template-haskell text
+       ];
+       testHaskellDepends = [
+         base file-embed html-parse Shpadoinkle Shpadoinkle-backend-static
+         template-haskell text
+       ];
+       description = "Read standard file formats into Shpadoinkle with Template Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "Shpadoinkle-widgets" = callPackage
     ({ mkDerivation, aeson, base, compactable, containers
      , edit-distance, email-validate, hspec, jsaddle, mtl, QuickCheck
···
        libraryHaskellDepends = [ base split ];
        testHaskellDepends = [ base Cabal ];
        description = "Simple table generator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Sit" = callPackage
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Sonnex is an alternative to Soundex for french language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1h90i6crknxv23zryqi7mfzg65g1ydv62mza1hiri66jlmdahir6";
        libraryHaskellDepends = [ base statistics tuple vector ];
        description = "Collection of useful statistical methods";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "StockholmAlignment" = callPackage
···
          vector
        ];
        description = "Libary for Stockholm aligmnent format";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1wbixjgzad3s9jj16kl0gvwg82g3hqvkag9wr5j58w98a4qyqw8i";
        libraryHaskellDepends = [ base ];
        description = "String manipulation utilities";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "SuffixStructures" = callPackage
···
          aeson base bytestring either-unwrap fgl parsec text vector
        ];
        description = "Libary for parsing, processing and vizualization of taxonomy data";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          EntrezHTTP fgl hxt parsec process Taxonomy text vector
        ];
        description = "Tool for parsing, processing, comparing and visualizing taxonomy data";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          template-haskell text
        ];
        description = "Render general Haskell math to LaTeX. Or: math typesetting with high signal-to-noise–ratio.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          process text
        ];
        description = "Generates testcases from program-snippets";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "Theora" = callPackage
···
        sha256 = "0rpcv6kw351ykj36f83qdqygrhk4ylqlcgcswxl8gg1v33jaaqmz";
        libraryHaskellDepends = [ base ];
        description = "Mutable objects that reside in their own threads";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Thrift" = callPackage
···
        sha256 = "02plz1y7lmvp3jpl5srsnx2nkl6yhhfn6pqj00szs688cahk2dik";
        libraryHaskellDepends = [ base binary bytestring dataenc ];
        description = "TigerHash with C implementation";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "TimePiece" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base containers matrix random ];
        description = "Game for Lounge Marmelade";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base containers directory time ];
        description = "Command Line Typing speed tester";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "UISF" = callPackage
···
        ];
        testHaskellDepends = [ base hspec parsec ];
        description = "Libary for parsing ViennaRNA package output";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "Villefort" = callPackage
···
        ];
        description = "Bindings to the VulkanMemoryAllocator library";
        license = lib.licenses.bsd3;
-       platforms = [ "x86_64-darwin" "x86_64-linux" ];
+       platforms = [ "aarch64-linux" "x86_64-darwin" "x86_64-linux" ];
      }) {};
 
   "WAVE" = callPackage
···
        platforms = lib.platforms.none;
      }) {};
 
-  "Win32_2_11_1_0" = callPackage
+  "Win32_2_12_0_0" = callPackage
     ({ mkDerivation }:
      mkDerivation {
        pname = "Win32";
-       version = "2.11.1.0";
-       sha256 = "18rsfx3ca8r7y4ifxn1mggn8j6ppgkn698wsq0pwqb63riva09rk";
+       version = "2.12.0.0";
+       sha256 = "068k26s1vxwz94w7bkqs9xbkh0z2mp1mimyklarr8rh26v978qin";
        description = "A binding to Windows Win32 API";
        license = lib.licenses.bsd3;
        platforms = lib.platforms.none;
···
        libraryHaskellDepends = [ base Win32 ];
        description = "Binding to the Win32 console API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "Win32-dhcp-server" = callPackage
···
        libraryHaskellDepends = [ base text Win32 Win32-errors ];
        description = "Win32 DHCP Server Management API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "Win32-errors" = callPackage
···
        testHaskellDepends = [ base hspec QuickCheck Win32 ];
        description = "Alternative error handling for Win32 foreign calls";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "Win32-extras" = callPackage
···
        librarySystemDepends = [ imm32 msimg32 ];
        description = "Provides missing Win32 API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {imm32 = null; msimg32 = null;};
 
   "Win32-junction-point" = callPackage
···
        libraryHaskellDepends = [ base text Win32 Win32-errors ];
        description = "Support for manipulating NTFS junction points";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "Win32-notify" = callPackage
···
        libraryHaskellDepends = [ base containers directory Win32 ];
        description = "A binding to part of the Win32 library for file notification";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "Win32-security" = callPackage
···
        libraryHaskellDepends = [ base text Win32 Win32-errors ];
        description = "Haskell bindings to a security-related functions of the Windows API";
        license = lib.licenses.mit;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "Win32-services" = callPackage
···
        librarySystemDepends = [ Advapi32 ];
        description = "Windows service applications";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {Advapi32 = null;};
 
   "Win32-services-wrapper" = callPackage
···
        ];
        description = "Wrapper code for making a Win32 service";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "Win32-shortcut" = callPackage
···
          tasty-th text
        ];
        description = "Bigram word pair alignments";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ xinput ];
        description = "Bindings for the DirectX XInput library";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {inherit (pkgs.xorg) xinput;};
 
   "XML" = callPackage
···
        sha256 = "1vdgbmf27ghvyjzkcymsz9fgv9lcss41n5hiyqc58nzg0w18r0ik";
        libraryHaskellDepends = [ base parsec ];
        description = "A library to parse xml";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "XMMS" = callPackage
···
      }:
      mkDerivation {
        pname = "Z-Data";
-       version = "0.7.0.0";
-       sha256 = "1b4ycsq5g459ynp989kldq6r3ssawr64a2hp3dzy804pwrp8v62m";
-       revision = "1";
-       editedCabalFile = "057si6f4hz5kda3gyr2b8kni17dmv28z82b64qi142gjr3gx415i";
+       version = "0.7.1.0";
+       sha256 = "12ay07rfyprdbgf6ndh4ywcklfqnjdk1gdf0xli27a96i86i7x44";
        setupHaskellDepends = [ base Cabal ];
        libraryHaskellDepends = [
          base bytestring case-insensitive containers deepseq ghc-prim
···
      }:
      mkDerivation {
        pname = "Z-IO";
-       version = "0.7.0.0";
-       sha256 = "1yw0ym2iw1hi3jn2xrp1hwi6vbv69d0fpvvz3n2328v4i0ryjdjf";
+       version = "0.7.1.0";
+       sha256 = "18d2q9fg4ydqpnrzvpcx1arjv4yl2966aax68fz3izgmsbp95k0l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        libraryHaskellDepends = [ base ];
        executableHaskellDepends = [ base ];
        description = "Maybe gives you a cute girl";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "acme-default" = callPackage
···
        sha256 = "039pz5lw3p8iy1gaijvbc8296djxcziw70a0rnw0iz3iy29w1fmc";
        libraryHaskellDepends = [ base text ];
        description = "free your haskell from the tyranny of npm!";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          parsec-permutation strict text time
        ];
        description = "Convert adblock config files to privoxy format";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "addLicenseInfo" = callPackage
···
        sha256 = "0cp14n2l3scbsp7f6s4r19ngn2ympns03pm6s07hdkpavvgli1zg";
        libraryHaskellDepends = [ base ];
        description = "Modelling, rendering and quantitative analysis on attack defense trees";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "aeson-combinators" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, criterion
-     , deepseq, doctest, fail, hspec, scientific, text, time
-     , time-compat, unordered-containers, utf8-string, uuid-types
-     , vector, void
+     , deepseq, fail, hspec, scientific, text, time, time-compat
+     , unordered-containers, utf8-string, uuid-types, vector, void
      }:
      mkDerivation {
        pname = "aeson-combinators";
-       version = "0.0.4.1";
-       sha256 = "1nvw5n7kfqrrci76350zd3mqvssb775ka4044kxgw0bhdzy3gcpg";
+       version = "0.0.5.0";
+       sha256 = "1z5fbvpffx2lv3d2wk9g74hmkx1n1yjkwd3vy57f3pp5npja7f3a";
        libraryHaskellDepends = [
          aeson base bytestring containers fail scientific text time
          time-compat unordered-containers uuid-types vector void
        ];
        testHaskellDepends = [
-         aeson base bytestring doctest hspec text utf8-string
+         aeson base bytestring hspec text utf8-string
        ];
        benchmarkHaskellDepends = [
          aeson base bytestring criterion deepseq text
···
          monad-parallel mtl OpenGL sdl2 stm text uuid vector
        ];
        description = "A simple Game Engine using SDL";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          regex-compat syb temporary unix utf8-string zlib
        ];
        description = "Haskell compiler that produce binary through C language";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "alex-meta";
-       version = "0.3.0.12";
-       sha256 = "0s0yhkl0ymr50agqnsbscw8926jk4044n6scw086ylhcijx3qmxa";
+       version = "0.3.0.13";
+       sha256 = "0lbralcid373p25m4qhrhrjak87p8wp4as3304sj6ba6xka89q3v";
        libraryHaskellDepends = [
          array base containers haskell-src-meta QuickCheck template-haskell
        ];
···
          tf-random transformers
        ];
        description = "Algorithmic automation for various DAWs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ alsaLib ];
        description = "Binding to the ALSA Library API (Exceptions)";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) alsaLib;};
 
   "alsa-gui" = callPackage
···
        libraryToolDepends = [ c2hs ];
        description = "Bindings to the ALSA simple mixer API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) alsaLib;};
 
   "alsa-pcm" = callPackage
···
        libraryPkgconfigDepends = [ alsaLib ];
        description = "Binding to the ALSA Library API (PCM audio)";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) alsaLib;};
 
   "alsa-pcm-tests" = callPackage
···
        libraryPkgconfigDepends = [ alsaLib ];
        description = "Binding to the ALSA Library API (MIDI sequencer)";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) alsaLib;};
 
   "alsa-seq-tests" = callPackage
···
      }:
      mkDerivation {
        pname = "amqp";
-       version = "0.21.0";
-       sha256 = "1sni1bl2rmc2fq2zla0h093acd7yisfdizd5wrxclammzav7x0gk";
+       version = "0.22.0";
+       sha256 = "1yr81pwmjnap5bir9nrmpwakg4rz4fwcjzbkdr8azqbp9x0hr9k2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          utf8-string x509-system
        ];
        description = "AMQP toolset for the command line";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "amqp-worker" = callPackage
···
          system-fileio system-filepath text
        ];
        description = "Simple literate programming preprocessor";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "anansi-hscolour" = callPackage
···
          anansi base bytestring containers hscolour monads-tf text
        ];
        description = "Colorized looms for Anansi";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "anansi-pandoc" = callPackage
···
          anansi base bytestring containers monads-tf pandoc text
        ];
        description = "Looms which use Pandoc to parse and produce a variety of formats";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1wn0kap7bw6sp9yi1awcmxh11s5ra4b44qbf97plsvrmpfz15cc5";
        libraryHaskellDepends = [ base process ];
        description = "Android methods exposed to Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        benchmarkHaskellDepends = [ base criterion ];
        description = "A small, general-purpose programming language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ ansi-terminal-game base hspec parsec ];
        description = "text-file based ASCII animator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, colour }:
      mkDerivation {
        pname = "ansi-terminal";
-       version = "0.10.3";
-       sha256 = "0z5m6ljmdyjyzq0s08rjjdzdj1ry4fz2ni7xlxd86addvwr2wbps";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [ base colour ];
-       description = "Simple ANSI terminal support, with Windows compatibility";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ansi-terminal_0_11" = callPackage
-    ({ mkDerivation, base, colour }:
-     mkDerivation {
-       pname = "ansi-terminal";
        version = "0.11";
        sha256 = "14rp62c7y79n9dmmi7m0l9n3mcq6dh331b4yyyrivm5da6g1nqf6";
        isLibrary = true;
···
        libraryHaskellDepends = [ base colour ];
        description = "Simple ANSI terminal support, with Windows compatibility";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ansi-terminal-game" = callPackage
···
          unidecode
        ];
        description = "sdl-like functions for terminal applications, based on ansi-terminal";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          time time-locale-compat yesod yesod-auth
        ];
        description = "A web interface to Antisplice dungeons";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          ironforge mtl network plugins time transformers
        ];
        description = "This is an IRC bot for Mafia and Resistance";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers
        ];
        description = "An engine for text-based dungeons";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          xdg-basedir
        ];
        description = "Server and community browser for the game Tremulous";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "api-tools" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, alex, array, attoparsec, base
-     , base16-bytestring, base64-bytestring, bytestring, Cabal
-     , case-insensitive, cborg, containers, deepseq, happy, lens
-     , QuickCheck, regex-compat-tdfa, safe, safecopy, scientific
+     , base16-bytestring, base64-bytestring, bytestring
+     , case-insensitive, cborg, containers, criterion, deepseq, happy
+     , lens, QuickCheck, regex-compat-tdfa, safe, safecopy, scientific
      , serialise, tasty, tasty-hunit, tasty-quickcheck, template-haskell
      , text, time, unordered-containers, vector
      }:
      mkDerivation {
        pname = "api-tools";
-       version = "0.8.0.2";
-       sha256 = "0q10vqaf4y3zwa2nrwllxi8ac8ch6jjr4r3s5g6gy51bp04ggzv9";
+       version = "0.9.0.0";
+       sha256 = "04496r4l598i2m14gj1wpz8a976as0gkbw0745h85ap8hy23vfjx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-pretty array attoparsec base base16-bytestring
-         base64-bytestring bytestring Cabal case-insensitive cborg
-         containers deepseq lens QuickCheck regex-compat-tdfa safe safecopy
-         scientific serialise template-haskell text time
-         unordered-containers vector
+         base64-bytestring bytestring case-insensitive cborg containers
+         deepseq lens QuickCheck regex-compat-tdfa safe safecopy scientific
+         serialise template-haskell text time unordered-containers vector
        ];
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [
          aeson aeson-pretty base bytestring deepseq QuickCheck serialise
        ];
        testHaskellDepends = [
-         aeson aeson-pretty base base64-bytestring bytestring Cabal cborg
+         aeson aeson-pretty base base64-bytestring bytestring cborg
          containers QuickCheck safecopy serialise tasty tasty-hunit
          tasty-quickcheck template-haskell text time unordered-containers
        ];
+       benchmarkHaskellDepends = [ base criterion text time ];
        description = "DSL for generating API boilerplate and docs";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
          base mtl QuickCheck test-framework test-framework-quickcheck2
        ];
        description = "An applicative parser combinator library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers unix utf8-string
        ];
        description = "Automatic Rule-Based Time Tracker";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "arcgrid" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base directory wx ];
        description = "An interpreter for the Argh! programming language in wxHaskell";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bimap containers glib gtk HDBC indents mtl parsec
        ];
        description = "A computer assisted argumentation transcription and editing software";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-quickcheck2 test-framework-th
        ];
        description = "A simple interpreter for arrayForth, the language used on GreenArrays chips";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base random random-shuffle terminfo time
        ];
        description = "ASCII animations for the holidays!";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "ascii-predicates" = callPackage
···
          split zlib
        ];
        description = "Process Ascii Vectors for Advantest 93k";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        editedCabalFile = "0vh6k6397f3y03y28shx0gf0lvdlb6pdcdhd1j8r1svhjbyphfdp";
        libraryHaskellDepends = [ array base containers ghc-prim ];
        description = "serialisation for Haskell values with sharing support";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "aterm-utils" = callPackage
···
        sha256 = "1jf9065pqmdfshkd0cqiamhivs9an4slqx82n7yj0kkhdxw5lyq4";
        libraryHaskellDepends = [ attoparsec base bytestring ];
        description = "An ARFF file parser using Attoparsec";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "attoparsec-base64" = callPackage
···
          QuickCheck
        ];
        description = "Variable-length integer decoding for Attoparsec";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "attosplit" = callPackage
···
          base bytestring colour ghc-prim gloss JuicyPixels random vector
        ];
        description = "Generates and displays patterns from next nearest neighbors cellular automata";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "avers";
        version = "0.0.17.1";
        sha256 = "1x96fvx0z7z75c39qcggw70qvqnw7kzjf0qqxb3jwg3b0fmdhi8v";
-       revision = "39";
-       editedCabalFile = "1y77mk83yap8yx5wlybpr06wwy3qvmq0svqc4c6dfyvjd9wjvsdv";
+       revision = "40";
+       editedCabalFile = "0wsr91a87kikvibl18knwkglawl9m96scdyd539zpgh6djbzmsqf";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring clock containers cryptonite
          filepath inflections memory MonadRandom mtl network network-uri
···
          rethinkdb-client-driver text
        ];
        description = "Server-side implementation of the Avers storage model";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "aviation-cessna172-diagrams" = callPackage
     ({ mkDerivation, aviation-cessna172-weight-balance, aviation-units
      , aviation-weight-balance, base, colour, diagrams-cairo
-     , diagrams-core, diagrams-lib, directory, doctest, filepath
-     , hgeometry, lens, mtl, parsec, plots, QuickCheck, quickcheck-text
-     , template-haskell
+     , diagrams-core, diagrams-lib, hgeometry, hgeometry-combinatorial
+     , lens, mtl, plots
      }:
      mkDerivation {
        pname = "aviation-cessna172-diagrams";
-       version = "0.0.2";
-       sha256 = "05z4z953x16d3flvvh9x1q1cskm0ff802jg1digjhg5n0rqmd7fa";
+       version = "0.0.3";
+       sha256 = "1hkb32dsxqrhk788vkb669n9kkan951m4slk2x77zmf52cmk8ljw";
        libraryHaskellDepends = [
          aviation-cessna172-weight-balance aviation-units
          aviation-weight-balance base colour diagrams-cairo diagrams-core
-         diagrams-lib hgeometry lens mtl plots
-       ];
-       testHaskellDepends = [
-         base directory doctest filepath parsec QuickCheck quickcheck-text
-         template-haskell
+         diagrams-lib hgeometry hgeometry-combinatorial lens mtl plots
        ];
        description = "Diagrams for the Cessna 172 aircraft in aviation";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {aviation-cessna172-weight-balance = null; 
-         aviation-units = null; aviation-weight-balance = null;};
+     }) {};
+
+  "aviation-cessna172-weight-balance" = callPackage
+    ({ mkDerivation, aviation-units, aviation-weight-balance, base
+     , lens
+     }:
+     mkDerivation {
+       pname = "aviation-cessna172-weight-balance";
+       version = "0.0.2";
+       sha256 = "1lnj3dr7jkc3c3rvg6knwapjvk7cnxf3901df4xn7mqwg996sdgj";
+       libraryHaskellDepends = [
+         aviation-units aviation-weight-balance base lens
+       ];
+       description = "Weight and Balance for the Cessna 172 aircraft in aviation";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "aviation-units" = callPackage
+    ({ mkDerivation, base, lens }:
+     mkDerivation {
+       pname = "aviation-units";
+       version = "0.0.2";
+       sha256 = "14m3sbic6zppg8hn1i7b6rd40bw731hz6mr393h897jjlvxygcc2";
+       libraryHaskellDepends = [ base lens ];
+       description = "Units of measurements used in aviation";
+       license = lib.licenses.bsd3;
+     }) {};
+
+  "aviation-weight-balance" = callPackage
+    ({ mkDerivation, aviation-units, base, lens }:
+     mkDerivation {
+       pname = "aviation-weight-balance";
+       version = "0.0.2";
+       sha256 = "1pqkqxdhl1a3pbrmjxz9vl3wjp90kic9vi6bjjr2q9i6six1xbjw";
+       libraryHaskellDepends = [ aviation-units base lens ];
+       description = "Weight and Balance structures used in aviation";
+       license = lib.licenses.bsd3;
+     }) {};
 
   "avl-static" = callPackage
     ({ mkDerivation, base, QuickCheck, test-framework
···
        pname = "avro";
        version = "0.5.2.0";
        sha256 = "1apvqny4dikx5b7yqxs8a4hsxipl5xvz2i3c5bna1faiagxav1i1";
+       revision = "1";
+       editedCabalFile = "0081mnhn26824rbdsz1n74i9m21yfkh6y4g3v7ksh933dxagyiij";
        libraryHaskellDepends = [
          aeson array base base16-bytestring bifunctors binary bytestring
          containers data-binary-ieee754 deepseq fail HasBigDecimal hashable
···
        sha256 = "0mvfirb41jnjvq4mpky0xpdrh238hjwslfqg82ksnam001sxnpng";
        libraryHaskellDepends = [ base ];
        description = "A prelude which I can be happy with. Based on base-prelude.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          aeson attoparsec awesomium-raw base containers text vector
        ];
        description = "High-level Awesomium bindings";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "175hgqix2j26579g0rrryl86w7qvla95nvf4lwfxsxxwqgcq3zpd";
        libraryHaskellDepends = [ awesomium awesomium-raw base GLUT ];
        description = "Utilities for using Awesomium with GLUT";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ awesomium ];
        libraryToolDepends = [ c2hs ];
        description = "Low-level Awesomium bindings";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {awesomium = null;};
···
        pname = "aws-lambda-runtime";
        version = "0.0.0.1";
        sha256 = "1yzqqlgi7yb9b5imh6zfmwbc097bj7r0zi8mkk82c81cv5rcjy08";
+       revision = "1";
+       editedCabalFile = "0gmf698hlxcg241zshn7rl3c2yqkk668inz43xjvahjj4rzqrnjy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base Diff directory filepath hspec options process unix
        ];
        description = "A simple DevOps tool which will never \"reach\" enterprice level";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ babl ];
        libraryPkgconfigDepends = [ babl ];
        description = "Haskell bindings to BABL library";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {inherit (pkgs) babl;};
 
   "babylon" = callPackage
···
        ];
        description = "Create status bar menus for macOS from executables";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "x86_64-darwin" ];
+       platforms = [ "x86_64-darwin" ];
      }) {};
 
   "barchart" = callPackage
···
        sha256 = "0d0i8ndh2j42qf8ns9wprkjiffy3hyybgvs9nbf67yd50di6p263";
        libraryHaskellDepends = [ base ];
        description = "The IO functions included in base delimited into small, composable classes";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "base16-bytestring" = callPackage
+  "base16-bytestring_0_1_1_7" = callPackage
     ({ mkDerivation, base, bytestring, ghc-prim }:
      mkDerivation {
        pname = "base16-bytestring";
···
        testHaskellDepends = [ base bytestring ];
        description = "Fast base16 (hex) encoding and decoding for ByteStrings";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
-  "base16-bytestring_1_0_1_0" = callPackage
+  "base16-bytestring" = callPackage
     ({ mkDerivation, base, bytestring, criterion, deepseq, HUnit
      , QuickCheck, test-framework, test-framework-hunit
      , test-framework-quickcheck2
···
        benchmarkHaskellDepends = [ base bytestring criterion deepseq ];
        description = "RFC 4648-compliant Base16 encodings for ByteStrings";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "base16-lens" = callPackage
···
        libraryHaskellDepends = [ base parsec ];
        testHaskellDepends = [ base hspec parsec ];
        description = "Ability to read, write, and modify BBDB files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "bbi" = callPackage
···
          persistent-sqlite persistent-template resourcet text time unix
        ];
        description = "Tools for managing a content store of software packages";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) ostree;};
···
          string-conversions string-qq temporary text time wai warp
        ];
        description = "BDCS API Server";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libgit2-glib;};
···
          utf8-string xhtml
        ];
        description = "Bein is a provenance and workflow management system for bioinformatics";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1zwk05lf76xcdbqrbaid3whmn04injrg7dnlji2v2i5li0pnpr3c";
        libraryHaskellDepends = [ base process random time ];
        description = "Test the time it takes to run a haskell function";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "benchpress" = callPackage
···
          uu-parsinglib
        ];
        description = "A parser for the Billboard chord dataset";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1rb4fpx5hlq661md7nrpgpmi7jjdq3r1ky6q9vxl6f72h085acvl";
        libraryHaskellDepends = [ base binary ghc-prim ];
        description = "Automatic deriving of Binary using GHC.Generics";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ bfd opcodes ];
        libraryToolDepends = [ alex happy ];
        description = "Bindings for libbfd, a library of the GNU `binutils'";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {bfd = null; opcodes = null;};
···
        libraryHaskellDepends = [ bindings-DSL ];
        librarySystemDepends = [ dttools ];
        description = "Bindings to the CCTools WorkQueue C library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {dttools = null;};
···
        librarySystemDepends = [ codec2 ];
        executableHaskellDepends = [ base binary bytestring split ];
        description = "Very low-level FFI bindings for Codec2";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {inherit (pkgs) codec2;};
 
   "bindings-common" = callPackage
···
        libraryPkgconfigDepends = [ directfb ];
        description = "Low level bindings to DirectFB";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) directfb;};
 
   "bindings-eskit" = callPackage
···
        libraryHaskellDepends = [ base bindings-DSL bindings-glib ];
        libraryPkgconfigDepends = [ gts ];
        description = "Low level bindings supporting GTS, the GNU Triangulated Surface Library";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {inherit (pkgs) gts;};
 
   "bindings-hamlib" = callPackage
···
        librarySystemDepends = [ hamlib ];
        executableHaskellDepends = [ base ];
        description = "Hamlib bindings for Haskell";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) hamlib;};
···
        librarySystemDepends = [ lxc ];
        description = "Direct Haskell bindings to LXC (Linux containers) C API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) lxc;};
 
   "bindings-mmap" = callPackage
···
          base bytestring hspec HUnit QuickCheck quickcheck-io
        ];
        description = "bindings to nettle crypto library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) nettle;};
 
   "bindings-parport" = callPackage
···
        libraryHaskellDepends = [ base bindings-DSL ];
        librarySystemDepends = [ potrace ];
        description = "Low-level bindings to the potrace bitmap tracing library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {inherit (pkgs) potrace;};
 
   "bindings-ppdev" = callPackage
···
          base cmdargs containers directory filepath process text unix
        ];
        description = "Wrapping saga_cmd";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "bindings-sane" = callPackage
···
        libraryHaskellDepends = [ base bindings-DSL ];
        libraryPkgconfigDepends = [ sane-backends ];
        description = "FFI bindings to libsane";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {inherit (pkgs) sane-backends;};
 
   "bindings-sc3" = callPackage
···
        editedCabalFile = "0mq2h1j1xd52irb35y9j0znxzpk661w3dl4d5a011sln4jd3f663";
        libraryHaskellDepends = [ base binary bytestring rank1dynamic ];
        description = "A variation of Data.Dynamic.Dynamic with a Binary instance";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "binsm";
-       version = "0.1.1";
-       sha256 = "1wiqslvf21xm15rf161lzffk5zzivbxs9sa9v7d257cx4d9qvy15";
+       version = "0.1.2";
+       sha256 = "1nhdzy3hqqin67i25kgrrcny99lrdr9i6xddr8gjm6b32kqhakhw";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        libraryHaskellDepends = [ array base binary biocore bytestring ];
        executableHaskellDepends = [ array base cmdargs mtl ];
        description = "Library and executables for working with SFF files";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          lens optparse-generic sparse-linear-algebra text text-show vector
        ];
        description = "Plot a colorful tree";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base configurator directory filepath mtl selda selda-sqlite text
        ];
        description = "A small tool that clears qutebrowser cookies";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "bisect-binary" = callPackage
···
        pname = "bits-extra";
        version = "0.0.2.0";
        sha256 = "1c54008kinzcx93kc8vcp7wq7la662m8nk82ax76i9b0gvbkk21f";
+       revision = "1";
+       editedCabalFile = "1ri4z6zj20qsyyzsrl89sjcm4ir2w6538i6l36a6ffz7f0h0ahng";
        libraryHaskellDepends = [ base ghc-prim vector ];
        testHaskellDepends = [
          base doctest doctest-discover ghc-prim hedgehog hspec hw-hedgehog
···
        ];
        testHaskellDepends = [ base QuickCheck ];
        description = "The pirate bay client";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "blacktip" = callPackage
···
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "Password entry tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "blink1" = callPackage
···
          text
        ];
        description = "BLOSUM generator";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base blubber-server bytestring cereal containers gloss network unix
        ];
        description = "The blubber client; connects to the blubber server";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          process random scotty text transformers unix
        ];
        description = "The blubber server, serves blubber clients";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "board-games";
        version = "0.3";
        sha256 = "1ylwibyl0j1v0bdrpfnjhdm431npagavxzgi2l5sp0scgpkcyyx7";
+       revision = "1";
+       editedCabalFile = "0rb5bqjg6r8p2v2wfdhivsbgbn55acdjsj6hcy6bv5w50qmg1l6c";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        sha256 = "1vqn1igmsgq6nry9bpz5vhggbm3j8kc3p6d6wy16nf94z10nq3qs";
        libraryHaskellDepends = [ base bytestring HUnit ];
        description = "convert numbers to binary coded lists";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "boolean-normal-forms" = callPackage
···
          base containers descrilo directory filepath simtreelo
        ];
        description = "A bookmarks manager with an HTML generator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "boombox" = callPackage
···
      }) {};
 
   "boomerang" = callPackage
-    ({ mkDerivation, base, mtl, semigroups, template-haskell, text }:
+    ({ mkDerivation, base, mtl, semigroups, template-haskell, text
+     , th-abstraction
+     }:
      mkDerivation {
        pname = "boomerang";
-       version = "1.4.6";
-       sha256 = "09angcdqf75f03rh7m02rsqz5rr304dw4c5cszj9alpq4qxlsyqc";
+       version = "1.4.7";
+       sha256 = "0ngrzwvzils6pqdgbc7hj4l41r19j2n82z78fqh312lnc1nni94i";
        libraryHaskellDepends = [
-         base mtl semigroups template-haskell text
+         base mtl semigroups template-haskell text th-abstraction
        ];
        description = "Library for invertible parsing and printing";
        license = lib.licenses.bsd3;
···
          base containers GLUT hosc hsc3 random
        ];
        description = "audio-visual pseudo-physical simulation of colliding circles";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          warp-tls
        ];
        description = "a url shortener";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yaml
        ];
        description = "Haskell source code formatter";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "broadcast-chan" = callPackage
···
          base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
        ];
        description = "Brotli (RFC7932) compression and decompression";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) brotli;};
···
        testHaskellDepends = [ base ];
        benchmarkHaskellDepends = [ base criterion ];
        description = "Burst detection algorithms";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring gl-capture GLUT OpenGLRaw repa repa-devil
        ];
        description = "butterfly tilings";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
 
+  "buttplug-hs-core" = callPackage
+    ({ mkDerivation, aeson, aeson-casing, aeson-pretty, async, base
+     , bytestring, connection, containers, generic-random, hspec
+     , network, QuickCheck, quickcheck-instances, raw-strings-qq, text
+     , unordered-containers, websockets, wuss
+     }:
+     mkDerivation {
+       pname = "buttplug-hs-core";
+       version = "0.1.0.0";
+       sha256 = "0ayii1hq6p4qnjvyfpv2776ikjh0q4ymxm0lk8q73vk1j6kq1j3y";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-casing base bytestring connection containers network
+         text unordered-containers websockets wuss
+       ];
+       executableHaskellDepends = [
+         aeson aeson-casing async base bytestring connection containers
+         network text unordered-containers websockets wuss
+       ];
+       testHaskellDepends = [
+         aeson aeson-casing aeson-pretty base bytestring connection
+         containers generic-random hspec network QuickCheck
+         quickcheck-instances raw-strings-qq text unordered-containers
+         websockets wuss
+       ];
+       description = "Client library for buttplug.io";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "bv" = callPackage
     ({ mkDerivation, base, ghc-prim, integer-gmp }:
      mkDerivation {
···
          attoparsec attoparsec-varword base bytestring hspec QuickCheck
        ];
        description = "Variable-length integer encoding";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base HUnit test-framework test-framework-hunit test-framework-th
        ];
        description = "Translate C code into ATS";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers
        ];
        description = "C->Haskell FFI tool that gives some cross-language type safety";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "c2hs-extra" = callPackage
···
        sha256 = "0hyjb8y4zf7qccyzsms98sd0kgz83q1aqfhgx2f3dq1nprhbg9ld";
        libraryHaskellDepends = [ base Cabal filepath ];
        description = "Cabal support for creating AppImage applications";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "cabal-cache";
-       version = "1.0.2.1";
-       sha256 = "0n17ga3namkldd4mfjla58nlg0j7dyjcamap84bdwiglmrg0iwz4";
+       version = "1.0.3.0";
+       sha256 = "0xx0a53z7wj75p8dqypr6ys63cpw8acl49358f42xi5lgblvqnca";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "cabal-install-parsers";
        version = "0.4.1";
        sha256 = "1djw4l0z8nsaby2qcm08kvn2p1c35ynzdg25vc815dx2wpw38bh3";
+       revision = "1";
+       editedCabalFile = "1fhjz4hji57sg00nb8jchvm8b13wn9pknnycgcclvxa3s72rqsf5";
        libraryHaskellDepends = [
          aeson base base16-bytestring binary binary-instances bytestring
          Cabal containers cryptohash-sha256 deepseq directory filepath lukko
···
          simple-cabal simple-cmd simple-cmd-args time unix
        ];
        description = "RPM packaging tool for Haskell Cabal-based packages";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "cabal-scripts" = callPackage
···
      }:
      mkDerivation {
        pname = "cabal2nix";
-       version = "2.16.0";
-       sha256 = "0kxxn218r1r9fia72zv8xzb8yji5y2jbwzqz033ljvwbm3abxp2k";
+       version = "2.17.0";
+       sha256 = "0y91agkhgpzzaf9l7l1h7x516iryj8z2vk1in1h7pyjlxaiak6lm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        testHaskellDepends = [ base Cabal filepath tasty tasty-golden ];
        description = "Convert Cabal files into rpm spec files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
          base containers gtk parsec plot-gtk-ui QuickCheck
        ];
        description = "A calculator repl, with variables, functions & Mathematica like dynamic plots";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers cpphs lens mtl parsec transformers
        ];
        description = "a logic programming language based on the calculus of constructions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "capability" = callPackage
     ({ mkDerivation, base, constraints, containers, dlist, exceptions
      , generic-lens, hspec, lens, monad-control, monad-unlift, mtl
-     , mutable-containers, primitive, safe-exceptions, silently
-     , streaming, temporary, text, transformers, unliftio, unliftio-core
+     , mutable-containers, primitive, reflection, safe-exceptions
+     , silently, streaming, temporary, text, transformers, unliftio
+     , unliftio-core
      }:
      mkDerivation {
        pname = "capability";
-       version = "0.3.0.0";
-       sha256 = "1kha2y1x63af43psl708c0iib0ign4jrs2n4s2jl4a0pb7hlcdcz";
+       version = "0.4.0.0";
+       sha256 = "02dnvzfvn81k15qp41fqd3pk4izg8rfbj7d5f6ry0wfa8d8payq0";
        libraryHaskellDepends = [
          base constraints dlist exceptions generic-lens lens monad-control
-         monad-unlift mtl mutable-containers primitive safe-exceptions
-         streaming transformers unliftio unliftio-core
+         monad-unlift mtl mutable-containers primitive reflection
+         safe-exceptions streaming transformers unliftio unliftio-core
        ];
        testHaskellDepends = [
-         base containers hspec lens mtl silently streaming temporary text
-         unliftio
+         base containers dlist hspec lens mtl silently streaming temporary
+         text unliftio
        ];
        description = "Extensional capabilities and deriving combinators";
        license = lib.licenses.bsd3;
···
        broken = true;
      }) {};
 
+  "caps" = callPackage
+    ({ mkDerivation, base, mtl, tasty, tasty-hunit, template-haskell
+     , transformers, typerep-map
+     }:
+     mkDerivation {
+       pname = "caps";
+       version = "0.1";
+       sha256 = "0i6rzgfbl377g4z76rv48c6a1s4yy9h78bjmvkr2vhq5zv8zqzkk";
+       libraryHaskellDepends = [
+         base template-haskell transformers typerep-map
+       ];
+       testHaskellDepends = [ base mtl tasty tasty-hunit ];
+       description = "Monadic capabilities with late binding";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "car-pool" = callPackage
     ({ mkDerivation, base, blaze-html, containers, digestive-functors
      , digestive-functors-blaze, digestive-functors-happstack
···
          highlighting-kate mtl pandoc pango process text time
        ];
        description = "A presentation tool written with Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          time transformers tuple
        ];
        description = "Carte: A commandline pastebin server";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "casa-types";
-       version = "0.0.1";
-       sha256 = "0f8c4a43rh6zr5cwingxyjfpisipy4x4xc0lpasfjaj4vhjgwqkp";
-       revision = "1";
-       editedCabalFile = "101hhpwc7nhg2laywv2jnqa3jsjkvbvc30i6cs4srvdv2n87jlcb";
-       libraryHaskellDepends = [
-         aeson attoparsec base base16-bytestring bytestring hashable
-         path-pieces persistent text
-       ];
-       description = "Types for Casa";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "casa-types_0_0_2" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
-     , bytestring, hashable, path-pieces, persistent, text
-     }:
-     mkDerivation {
-       pname = "casa-types";
        version = "0.0.2";
        sha256 = "1c3qvph690pgnqmj132sn1zh878n3ljvmp913vvhwynfhyixs1v7";
        libraryHaskellDepends = [
···
        ];
        description = "Types for Casa";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "casadi-bindings" = callPackage
···
          test-framework-hunit test-framework-quickcheck2 vector
        ];
        description = "mid-level bindings to CasADi";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {casadi = null;};
···
        ];
        libraryPkgconfigDepends = [ casadi_control ];
        description = "low level bindings to casadi-control";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {casadi_control = null;};
···
        ];
        librarySystemDepends = [ casadi ];
        description = "autogenerated low level bindings to casadi";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {casadi = null;};
···
        libraryHaskellDepends = [ base containers vector ];
        librarySystemDepends = [ casadi ];
        description = "low level bindings to CasADi";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {casadi = null;};
···
        ];
        libraryPkgconfigDepends = [ casadi_ipopt_interface ];
        description = "low level bindings to casadi-ipopt_interface";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {casadi_ipopt_interface = null;};
···
        ];
        libraryPkgconfigDepends = [ casadi_snopt_interface ];
        description = "low level bindings to casadi-snopt_interface";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {casadi_snopt_interface = null;};
···
        ];
        librarySystemDepends = [ dttools ];
        description = "High-level interface to CCTools' WorkQueue library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {dttools = null;};
···
        sha256 = "04mlg1r2qvrwdzcfbf1aqs4bf9n2gc7cwv73fbhld2ji5naa6fwb";
        libraryHaskellDepends = [ base cereal ghc-prim ];
        description = "Automatic deriving of Serialize using GHC.Generics";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers utf8-string void
        ];
        description = "Parser for categorial grammars";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers utf8-string yaml
        ];
        description = "Command line tool";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers JuicyPixels ];
        testHaskellDepends = [ base containers hspec JuicyPixels ];
        description = "Library decoding chain codes from images";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "chainweb-mining-client" = callPackage
···
        ];
        description = "A library of simple NLP algorithms";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "chatty" = callPackage
···
          template-haskell text time transformers unix
        ];
        description = "Some monad transformers and typeclasses for text in- and output abstraction";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "chatty-text" = callPackage
···
        editedCabalFile = "11vpzarrbk0jlsnamrnf4xp3gzkgwrbs6x5mr9m5rr4lrw1f9q0v";
        libraryHaskellDepends = [ base chatty transformers ];
        description = "Provides some classes and types for dealing with text, using the fundaments of Chatty";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1pzg0bf73shwl91x4011khw62wgv33y5862gq110q8g913w4jrjw";
        libraryHaskellDepends = [ base mtl text transformers ];
        description = "Some utilities every serious chatty-based application may need";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "chatwork" = callPackage
···
          QuickCheck quickcheck-text temporary text
        ];
        description = "Generate checklists relevant to a given patch";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        executableHaskellDepends = [ base binary bytestring text ];
        testHaskellDepends = [ base binary bytestring HUnit text ];
        description = "Human-readable storage of text/binary objects";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          uuid wreq
        ];
        description = "Cielo API v3 Bindings for Haskell";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        executableHaskellDepends = [ base bytestring groom text ];
        testHaskellDepends = [ base hspec ];
        description = "Simple C-like programming language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "cinvoke" = callPackage
···
      }:
      mkDerivation {
        pname = "citeproc";
-       version = "0.3.0.8";
-       sha256 = "0njlb37cxnpikwz9k92d689j477fz9x7chl58s3ljsw9drcgpcvh";
+       version = "0.3.0.9";
+       sha256 = "0ky4j6nbn6yp3mny1m045n40jfvbr1iiylcf51hsi228y4m5za9s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          pandoc pandoc-types parsec tagsoup texmath utf8-string yaml
        ];
        description = "A Pandoc filter for processing bibliographic references with citeproc-hs";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          split
        ];
        description = "Simple CLI RPN calculator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base lifted-base monad-control parallel resourcet transformers
        ];
        description = "Fork of the monad-parallel package using monad-control";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryPkgconfigDepends = [ QtCore ];
        description = "timer functionality to clock IO commands";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {QtCore = null;};
···
        sha256 = "1h1n349sq2lpikpvzzarz74200b8k7dkdjpp4rpkx79xdlfc58pc";
        libraryHaskellDepends = [ base containers tree-fun ];
        description = "Calculate the clumpiness of leaf properties in a tree";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "cluss" = callPackage
···
          parsec StockholmAlignment template-haskell text vector
        ];
        description = "Detailed visualization of CMs, HMMs and their comparisions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          HUnit parsec pretty text
        ];
        description = "A library for manipulating RPM files";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring cassava containers lens optparse-generic split
        ];
        description = "Collapse the duplication output into clones and return their frequencies";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          linear linearmap-category manifolds semigroups vector-space
        ];
        description = "Instances of the manifold-classes for colour types";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "comfort-array" = callPackage
     ({ mkDerivation, base, ChasingBottoms, containers, deepseq
-     , guarded-allocation, non-empty, prelude-compat, primitive
-     , QuickCheck, semigroups, storable-record, tagged, transformers
-     , utility-ht
+     , doctest-exitcode-stdio, doctest-lib, guarded-allocation
+     , non-empty, prelude-compat, primitive, QuickCheck, semigroups
+     , storable-record, tagged, transformers, utility-ht
      }:
      mkDerivation {
        pname = "comfort-array";
-       version = "0.4";
-       sha256 = "0jvksvvslvg5wiqin5pd0q0q8a7snhfjh26a98mdakk8dziw1p1m";
+       version = "0.4.1";
+       sha256 = "11nsq6yc3sz259nn9vks49rxq5zzrfwqn9fvi10w3vbnq3wjg9i5";
        libraryHaskellDepends = [
          base containers deepseq guarded-allocation non-empty prelude-compat
          primitive QuickCheck semigroups storable-record tagged transformers
          utility-ht
        ];
        testHaskellDepends = [
-         base ChasingBottoms containers QuickCheck tagged
+         base ChasingBottoms containers doctest-exitcode-stdio doctest-lib
+         QuickCheck tagged
        ];
        description = "Arrays where the index type is a function of the shape type";
        license = lib.licenses.bsd3;
···
        sha256 = "0a1pp1jafra1agsx2jizdb33afzg02w6jh4a4pyw5w71kzqfrril";
        libraryHaskellDepends = [ base MissingH ];
        description = "Haskell functionality for quickly assembling simple compilers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "composable-associations-aeson";
-       version = "0.1.0.0";
-       sha256 = "0kragi8wfd30yxrndxka5p3bivj1qi8svljcdkqnji32dpnm9myv";
+       version = "0.1.0.1";
+       sha256 = "0fpjirwk9si1v8jsdrcxbwn3rqc058na9z5lhbnkha2zc6l8w8rw";
        libraryHaskellDepends = [
          aeson base composable-associations text unordered-containers
        ];
···
      }:
      mkDerivation {
        pname = "concurrency";
-       version = "1.11.0.0";
-       sha256 = "19a4za0c65gi2a5n882nyi26cgxrsry64rkd3qiqhvzf7m34cjxd";
+       version = "1.11.0.1";
+       sha256 = "0ds55wpkxlrw2x5ql34p9b05xlycnc4v7962f27a54nhrjfhb2ah";
        libraryHaskellDepends = [
          array atomic-primops base exceptions monad-control mtl stm
          transformers
···
        sha256 = "1jdslfnwyh7l10xhk9i0293p0qnw0xsd70d5xgpc6xlijhrsg8wp";
        libraryHaskellDepends = [ array base containers random stm time ];
        description = "a library for live coding and real-time musical applications";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1plml14h5d31jr3bvjjgaxcdqssxqfwwnbz9c5gvjlds6lla145p";
        doHaddock = false;
        description = "a library for displaying musical time in a terminal-based clock";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "conductive-hsc3" = callPackage
···
          hosc hsc3 random
        ];
        description = "a library with examples of using Conductive with hsc3";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "16bdsjv64fc3ydv230rja5q9rqzlr4vd9mh3jabiyahck44imrvi";
        libraryHaskellDepends = [ base conductive-base random ];
        description = "a library of functions which are useful for composing music";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "conferer";
        version = "1.1.0.0";
        sha256 = "1hkdrqxrac1mbzvd29f6ds4cbihdv0j0daai7yc282myv0varh09";
+       revision = "1";
+       editedCabalFile = "0xr6910zn9j07gwc9f9dmlgxiagirmpzjzb9vlaqc0qvpawgq201";
        libraryHaskellDepends = [
          base bytestring containers directory filepath text
        ];
···
      }:
      mkDerivation {
        pname = "conferer-aeson";
-       version = "1.1.0.0";
-       sha256 = "0kslxj2wcycygj07x7v06fcx2i47dwp96da9djws6mjdmr1a9i96";
-       revision = "1";
-       editedCabalFile = "1ic6nichx1c3s7fnr2q90hzm1qykg8rkqfwl2k5yhhwb1fdnhb6q";
+       version = "1.1.0.1";
+       sha256 = "1slz2gbnaca8ydl91rjhpjair90qnybcg6zkxdjrwr9jnxsp95s7";
        libraryHaskellDepends = [
          aeson base bytestring conferer directory text unordered-containers
          vector
···
          text time unordered-containers
        ];
        description = "Configuration management";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "config-parser" = callPackage
···
          base directory filepath unix vty-menu
        ];
        description = "A small program for swapping out dot files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testToolDepends = [ hspec-discover ];
        description = "parser for config files, shell variables, command line args";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, containers, doctest, hedgehog }:
      mkDerivation {
        pname = "connections";
-       version = "0.2.0";
-       sha256 = "1hvfqdjcj4mp2iyx0596710z4f8fm0jlgp819xf2s90rz1b360ya";
+       version = "0.3.0";
+       sha256 = "0ias6f5nzd83i2x6823ypzp598d8rgp74wmhd4gk7slcyszgpj6l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base containers ];
···
        sha256 = "07s4p41hjsalbaayxq2j973f3wnk8d7aybvl84fww7sz6mj7kvhw";
        libraryHaskellDepends = [ base ];
        description = "console user prompts";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "console-style" = callPackage
···
          base contravariant fail semigroups tagged trivial-constraint void
        ];
        description = "Constrained clones of the category-theory type classes, using ConstraintKinds";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          hspec memory mtl resourcet temporary
        ];
        description = "Store and retrieve data from an on-disk store";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          pipes-bytestring pipes-csv text vector
        ];
        description = "Convert the annotation of a gene to another in a delimited file using a variety of different databases";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base text ];
        testPkgconfigDepends = [ python3 ];
        description = "Bindings for libpython";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) python3;};
···
          base cmdargs directory process shelly text transformers unix
        ];
        description = "Code review tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          mersenne-random-pure64 mtl parallel
        ];
        description = "An offline renderer supporting ray tracing and photon mapping";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "cryptonite";
-       version = "0.27";
-       sha256 = "1c68wvn2b49gijq9day2bzi0axcbdz41ip3j0wdahdhcjfl4a9y8";
-       libraryHaskellDepends = [
-         base basement bytestring deepseq ghc-prim integer-gmp memory
-       ];
-       testHaskellDepends = [
-         base bytestring memory tasty tasty-hunit tasty-kat tasty-quickcheck
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring deepseq gauge memory random
-       ];
-       description = "Cryptography Primitives sink";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "cryptonite_0_28" = callPackage
-    ({ mkDerivation, base, basement, bytestring, deepseq, gauge
-     , ghc-prim, integer-gmp, memory, random, tasty, tasty-hunit
-     , tasty-kat, tasty-quickcheck
-     }:
-     mkDerivation {
-       pname = "cryptonite";
        version = "0.28";
        sha256 = "1nx568qv25dxhbii7lzf1hbv0dyz95z715mmxjnnrkgpwdm8ibbl";
        libraryHaskellDepends = [
···
        ];
        description = "Cryptography Primitives sink";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "cryptonite-conduit" = callPackage
···
          unordered-containers vector
        ];
        description = "Bindings for Cryptsy cryptocurrency exchange API";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ array base chatty-text chatty-utils ];
        executableHaskellDepends = [ array base chatty-text chatty-utils ];
        description = "A programming language for text modification";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          allocated-processor base HOpenCV vector-space
        ];
        description = "Functional Combinators for Computer Vision";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-quickcheck2 test-framework-smallcheck
        ];
        description = "A subfield of the complex numbers for exact calculation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "cypher" = callPackage
···
        executableHaskellDepends = [ base c-storable-deriving vect Win32 ];
        description = "A raw binding for the directX 11";
        license = lib.licenses.mit;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {D3DCompiler = null; d3d11 = null; d3dx11 = null; 
          d3dxof = null; dxgi = null; dxguid = null;};
 
···
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base directory unix ];
        description = "Start background daemons by double-forking";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "daemons" = callPackage
···
          test-framework-hunit unix
        ];
        description = "Daemons in Haskell made fun and easy";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "dag" = callPackage
···
          utf8-string
        ];
        description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base binary bytestring criterion transformers
        ];
        description = "Utility and parser for DarkPlaces demo files";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base bytestring hspec hspec-core ];
        description = "Darkplaces rcon client library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text
        ];
        description = "Darplaces rcon utility";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryToolDepends = [ alex ];
        testHaskellDepends = [ base bytestring hspec QuickCheck ];
        description = "Parser for darkplaces colorful text";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text transformers
        ];
        description = "Convert package Haddock to Dash docsets (IDE docs)";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-quickcheck2 vector
        ];
        description = "Space-efficient and privacy-preserving data dispersal algorithms";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "data-interval" = callPackage
     ({ mkDerivation, base, ChasingBottoms, containers, deepseq
-     , extended-reals, hashable, HUnit, lattices, QuickCheck, syb, tasty
-     , tasty-hunit, tasty-quickcheck, tasty-th
+     , extended-reals, hashable, HUnit, lattices, QuickCheck
+     , quickcheck-classes-base, syb, tasty, tasty-hunit
+     , tasty-quickcheck, tasty-th
      }:
      mkDerivation {
        pname = "data-interval";
-       version = "2.0.1";
-       sha256 = "0vz73vwbr484s0dxg9y0y1mfbni8aky3hyh93pmzb8zb67gy4cak";
+       version = "2.1.0";
+       sha256 = "0f4dgpqmp4y9fidlb3z5dlcmv0qb6pqbxbf57jjjz49r7g6adzlq";
        libraryHaskellDepends = [
          base containers deepseq extended-reals hashable lattices
        ];
        testHaskellDepends = [
          base ChasingBottoms containers deepseq hashable HUnit lattices
-         QuickCheck syb tasty tasty-hunit tasty-quickcheck tasty-th
+         QuickCheck quickcheck-classes-base syb tasty tasty-hunit
+         tasty-quickcheck tasty-th
        ];
        description = "Interval datatype, interval arithmetic and interval-based containers";
        license = lib.licenses.bsd3;
···
        sha256 = "0r3y66lxgk0sdg500xnz0fvg4dvzvx47imnw0qkici22b9d92kv8";
        libraryHaskellDepends = [ base ];
        description = "Utilities for working with sequences within lists";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "data-list-zigzag" = callPackage
···
          base containers dbus-core monads-tf text transformers
        ];
        description = "Monadic and object-oriented interfaces to DBus";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          network parsec text unix vector xml-types
        ];
        description = "Low-level D-Bus protocol implementation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1mw0qn7c6ag2w6gn6pwpjf979m3p5v3p9a1kal2x8g8ncx98dcn5";
        libraryHaskellDepends = [ base dates time ];
        description = "Discordian Date Types for Haskell";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          wai-websockets warp websockets
        ];
        description = "secure remote debugging";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Preprocessing decimal literals more or less as they are (instead of via fractions)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "dejafu";
-       version = "2.4.0.1";
-       sha256 = "0zysf0hjfdd5iypllbiyih312kl2hsfwiqf6030i7q432yc3f8vd";
+       version = "2.4.0.2";
+       sha256 = "1hwhyxjjwapk6jgsbs0vh033xbc9b8mr5iqd93vskvvljnb40v9h";
        libraryHaskellDepends = [
          base concurrency containers contravariant deepseq exceptions
          leancheck profunctors random transformers
···
        ];
        testHaskellDepends = [ base directory filepath hspec ];
        description = "A library for detecting file changes";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "08zhyn9xcmhrrnh7y2a1r7v4nmgm2af0d41ns0wjqais67rzsxsp";
        libraryHaskellDepends = [ base data-default ];
        description = "Generic instances for enumerating complex data types";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "00rk7m54igmrsi8j2fmql7c5wgyg7x5ws8397753470x5k2qv2ap";
        libraryHaskellDepends = [ base ];
        description = "Loads a list of items with fields";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "descript-lang" = callPackage
···
          transformers yaml
        ];
        description = "Library, interpreter, and CLI for Descript programming language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-hunit text
        ];
        description = "Convert between Dhall and YAML";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "dhcp-lease-parser" = callPackage
···
          test-framework-quickcheck2 transformers
        ];
        description = "Cryptographically secure n-sided dice via rejection sampling";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {};
 
   "dice2tex" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base ];
        description = "Convert a Diceware wordlist into a printer-ready LaTeX file";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base binary bytestring pretty safe time
        ];
        description = "A library for reading and writing DICOM files in the Explicit VR Little Endian transfer syntax";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ attoparsec base text ];
        testHaskellDepends = [ attoparsec base hspec text ];
        description = "A parser for diff file formats";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "diff3" = callPackage
···
          text-show vector
        ];
        description = "Finds out whether an entity comes from different distributions (statuses)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-hunit text
        ];
        description = "Run digestive-functors forms against JSON";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base FontyFruity JuicyPixels Rasterific vector
        ];
        description = "ASCII based Diagram drawing in Haskell (Idea based on ditaa)";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "dijkstra-simple" = callPackage
···
      }:
      mkDerivation {
        pname = "diohsc";
-       version = "0.1.3.1";
-       sha256 = "1k44bi5ri63qsps0vh24qc32bclp3nqp2qbs6ylxm9k0q76758iw";
+       version = "0.1.4";
+       sha256 = "09hxy5ac39iqps1bfd1xrwcz9rckywpi99fpx7ikr1lpnvnc5bfb";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
          unix x509 x509-store x509-validation
        ];
        description = "Gemini client";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "diophantine" = callPackage
···
        libraryHaskellDepends = [ array base ];
        libraryToolDepends = [ happy ];
        description = "A quadratic diophantine equation solving library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base directory ];
        description = "Deletes a directory and retains its contents in the parent directory";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0axz9k5j9yfk58icnycr93b6d5fqylgqlxi8v7w5sv1n28hrpvvj";
        libraryHaskellDepends = [ base containers ];
        description = "DisCoCat implementation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "discord-gateway" = callPackage
···
        libraryHaskellDepends = [ base Cabal directory filepath process ];
        doHaddock = false;
        description = "Generate/Upload cabal package to Hackage";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "distribution-nixpkgs";
-       version = "1.4.0";
-       sha256 = "1935lg05bfzwrvppi11r05nhwa1gkmvv0xqv1kqkbc87bk6pvp5g";
+       version = "1.5.0";
+       sha256 = "07z1dkyzz9sabxda48cy6y2pfyq14sz2m9bv6y6dajn15cy7m3pk";
        libraryHaskellDepends = [
          aeson base bytestring Cabal containers deepseq language-nix lens
          pretty process split
···
          base containers fasta optparse-applicative pipes semigroups
        ];
        description = "Quantify the diversity of a population";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          time unix xdg-userdirs
        ];
        description = "Fedora image download tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text
        ];
        description = "Checks Haddock comments for pitfalls and version changes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "doclayout";
-       version = "0.3";
-       sha256 = "1wmnwq28jcyd6c80srivsnd5znmyl9sgmwwnlk2crwiiwqadbal7";
+       version = "0.3.0.2";
+       sha256 = "1hfqagf5rmdjjx3xzx153d769b2vwarmyx7k7cwh872cgasndb3q";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base mtl safe text ];
        testHaskellDepends = [
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "doctest-extract" = callPackage
+    ({ mkDerivation, base, doctest-lib, non-empty, optparse-applicative
+     , pathtype, semigroups, transformers, utility-ht
+     }:
+     mkDerivation {
+       pname = "doctest-extract";
+       version = "0.1";
+       sha256 = "1ncrq67d6zcqw5al5m2g7q6ys8rxhsq8rrzbj1dlsyl4q63vyrms";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base doctest-lib non-empty optparse-applicative pathtype semigroups
+         transformers utility-ht
+       ];
+       description = "Alternative doctest implementation that extracts comments to modules";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "doctest-lib" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        sha256 = "0sqvxyj3aybqvjlrz2a93lnp1vbjiqikysm575wizri2rd3vfj1l";
        libraryHaskellDepends = [ base ];
        description = "A Haskell library for using Dozenal (Duodecimal - Base 12) numbers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testSystemDepends = [ dpkg ];
        testPkgconfigDepends = [ libdpkg ];
        description = "libdpkg bindings";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) dpkg; libdpkg = null;};
···
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers hspec QuickCheck ];
        description = "A port of asciimoo's drawille to haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1vv32n736ncjsy4psp8zlqmpp0r7mncjq65zwkhq5i99jx4chb1q";
        libraryHaskellDepends = [ base parsec ];
        description = "Haskell Doge Serialized Object Notation Parser";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "A computer “algebra” system that knows nothing about algebra, at the core";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "duration";
-       version = "0.1.0.0";
-       sha256 = "18qjn97njhra7brps58rl44vyc0hmfc83prgm519q7dyf3159cd0";
+       version = "0.2.0.0";
+       sha256 = "1cmgbnri3083gpr16j8yqj5jzbz0q5cxgnrpnbridyyznbp8csvj";
        libraryHaskellDepends = [ base parsec template-haskell time ];
        testHaskellDepends = [
          base doctest hspec parsec template-haskell time
···
        libraryPkgconfigDepends = [ dvdread ];
        libraryToolDepends = [ c2hs ];
        description = "A monadic interface to libdvdread";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {dvdread = null;};
···
        libraryHaskellDepends = [ base Win32 ];
        description = "Backend for a binding to the Microsoft DirectX 9 API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "dx9d3d" = callPackage
···
        librarySystemDepends = [ d3d9 ];
        description = "A binding to the Microsoft DirectX 9 API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {d3d9 = null;};
 
   "dx9d3dx" = callPackage
···
        librarySystemDepends = [ d3dx9 ];
        description = "A binding to the Microsoft DirectX 9 D3DX API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {d3dx9 = null;};
 
   "dyckword" = callPackage
···
          vector-space
        ];
        description = "Interactive diagram windows";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base binary bytestring hashable unordered-containers
        ];
        description = "Optionally serializable dynamic state keyed by type";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "dynamodb-simple" = callPackage
···
          test-framework-hunit test-framework-quickcheck2 vector
        ];
        description = "your dynamic optimization buddy";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "Dynamic reconfiguration in Haskell";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "dyre_0_9_1" = callPackage
+    ({ mkDerivation, base, binary, directory, executable-path, filepath
+     , io-storage, process, time, unix, xdg-basedir
+     }:
+     mkDerivation {
+       pname = "dyre";
+       version = "0.9.1";
+       sha256 = "1lrpjvah57p1ld3spcrgqds3claqkd5a9ay8inihl9wws0ifhfmh";
+       libraryHaskellDepends = [
+         base binary directory executable-path filepath io-storage process
+         time unix xdg-basedir
+       ];
+       testHaskellDepends = [ base directory process ];
+       description = "Dynamic reconfiguration in Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "dywapitchtrack" = callPackage
···
        libraryHaskellDepends = [ base hspec ];
        testHaskellDepends = [ base hspec ];
        description = "Parses command line arguments";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "easy-bitcoin" = callPackage
···
        sha256 = "0vj9j41706lalxc2sankpnxrn3mg650wfd4rl6yw32pns6bdq86f";
        libraryHaskellDepends = [ base bytestring containers mtl zlib ];
        description = "User-friendly creation of EPS, PostScript, and PDF files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "easytensor" = callPackage
···
          ghc-events-parallel gtk mtl text zip-archive
        ];
        description = "A Tool to Visualize Parallel Functional Program Executions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          ALUT base cmdtheline containers gloss OpenAL random wraparound
        ];
        description = "Top view space combat arcade game";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        librarySystemDepends = [ eibclient ];
        description = "EIBd Client";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {eibclient = null;};
···
        sha256 = "1am1j05z79prlybq3hg8vr4gwhl354af4dg9y1qr57vpp6gcpfwv";
        libraryHaskellDepends = [ base hmatrix safe ];
        description = "Find the elbow point";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "electrum-mnemonic" = callPackage
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-quickcheck ];
        description = "easy to remember mnemonic for a high-entropy value";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "elenco-albero" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "eliminators_0_8" = callPackage
+    ({ mkDerivation, base, extra, hspec, hspec-discover, singleton-nats
+     , singletons-base, template-haskell, th-abstraction, th-desugar
+     }:
+     mkDerivation {
+       pname = "eliminators";
+       version = "0.8";
+       sha256 = "00prqf3qnhsswigcx87nq9dfaq9vjvzgcgbpnxrpgw9k36p9mdh2";
+       libraryHaskellDepends = [
+         base extra singleton-nats singletons-base template-haskell
+         th-abstraction th-desugar
+       ];
+       testHaskellDepends = [ base hspec singleton-nats singletons-base ];
+       testToolDepends = [ hspec-discover ];
+       description = "Dependently typed elimination functions using singletons";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "elision" = callPackage
     ({ mkDerivation, base, profunctors }:
      mkDerivation {
···
          parallel-io pcre-light tasty tasty-hunit
        ];
        description = "Perform basic syntax and deliverability checks on email addresses";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "emailaddress" = callPackage
···
        ];
        executableHaskellDepends = [ base ];
        description = "support for embroidery formats in haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1jpz58zlkhgf2fl4fzicpdkqqdbwy3sw56dga8yvjmgv5zcqqshx";
        libraryHaskellDepends = [ base ];
        description = "Haskell binding for EPANET";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "equational-reasoning";
        version = "0.7.0.0";
        sha256 = "0l6gyq43byh6cy2pblb9a4qjy7w5k9maa97c076dxlsf53myj01h";
+       revision = "1";
+       editedCabalFile = "1a8dw9givg0przqrm33kkmff9r0fdv1ih6ik3dqa99ww71cc8q66";
        libraryHaskellDepends = [
          base containers template-haskell th-desugar void
        ];
···
        broken = true;
      }) {};
 
+  "erlang-ffi" = callPackage
+    ({ mkDerivation, base, binary, bytestring, directory, filepath
+     , hspec, MissingH, network, random
+     }:
+     mkDerivation {
+       pname = "erlang-ffi";
+       version = "1.0.0";
+       sha256 = "1vj0i7r4pr3dhyvlgk0mi31ljcq87y69s2vmh4q41m5q4wxz9c42";
+       libraryHaskellDepends = [
+         base binary bytestring directory filepath MissingH network random
+       ];
+       testHaskellDepends = [
+         base binary bytestring directory filepath hspec MissingH network
+         random
+       ];
+       description = "Send messages to an Erlang node using Haskell";
+       license = "GPL";
+     }) {};
+
   "eros" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, text }:
      mkDerivation {
···
          aeson attoparsec base bytestring yaml
        ];
        description = "Easy Runtime Templates";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yesod-form yesod-static yesod-test
        ];
        description = "Espial is an open-source, web-based bookmarking server";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, ghc-prim, primitive }:
      mkDerivation {
        pname = "eveff";
-       version = "0.1.0.0";
-       sha256 = "1d0bxg1dg66g1yv291cp4jh3xv3caxrddqrwb0g6g1929dl019fa";
+       version = "1.0.0.1";
+       sha256 = "0668345qdais176w8vbmjklys64ys36m4ppkiyqbad866n0zg7n9";
        libraryHaskellDepends = [ base ghc-prim primitive ];
        description = "Efficient effect handlers based on evidence translation";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "eventlog2html";
-       version = "0.8.3";
-       sha256 = "0xk9s8f20xx1xpbc2kbyfv3hhnrj8arim99lrr6wbv8y33qz0pkr";
+       version = "0.9.0";
+       sha256 = "1cjnkqdnk76839dl4dbpj3vzbkrjwgqryq2j3sgs9mmxfing7ahq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        testHaskellDepends = [ base doctest ];
        description = "Exheres generator for cabal packages";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bimap containers gauge prettyprinter raw-strings-qq
        ];
        description = "Linear programming over exponent pairs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "expand" = callPackage
···
      }:
      mkDerivation {
        pname = "experimenter";
-       version = "0.1.0.4";
-       sha256 = "0pzlmq2rb485x0df4ivw5i9sv8n14svy1vhgjqc69vm1p0md57ms";
+       version = "0.1.0.10";
+       sha256 = "0ys1m510j573f1ydbyilxcmdcizbannn8gm6c6pg0d9lq1avg5aw";
        libraryHaskellDepends = [
          aeson base bytestring cereal cereal-vector conduit containers
          deepseq directory esqueleto filepath HaTeX hostname lens matrix
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Fully-flexible polymorphic lenses, without any bizarre profunctors";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0g20kblzvhx53mi82frpx29x0nsfjrzsanqq8f6yw22lh47pbm4y";
        libraryHaskellDepends = [ base ];
        description = "explicit computation of determinant of small matrices";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
        broken = true;
+     }) {};
+
+  "exploring-interpreters" = callPackage
+    ({ mkDerivation, base, containers, fgl, mtl, transformers }:
+     mkDerivation {
+       pname = "exploring-interpreters";
+       version = "0.2.0.0";
+       sha256 = "1q2i68isdyc1fmxz9hcrjy8k3z8ji6xb2xrn4pc3wn0mrlnj1dka";
+       libraryHaskellDepends = [ base containers fgl mtl transformers ];
+       description = "A generic exploring interpreter for exploratory programming";
+       license = lib.licenses.bsd3;
      }) {};
 
   "exposed-containers" = callPackage
···
        benchmarkHaskellDepends = [ base digits gauge ];
        doHaddock = false;
        description = "Integer-to-digits conversion";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          pipes-attoparsec pipes-bytestring pipes-group pipes-text split text
        ];
        description = "A simple, mindless parser for fasta files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring cassava hxt network-uri text
        ];
        description = "Utilities for working with DuckDuckHack's FatHead Instant Answers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        doHaddock = false;
        description = "Build and create Fedora package repos and branches";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers
        ];
        description = "Algo for Formal Concept Analysis";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0hynmwic940vmna0czavbp1wx856ad9am7i6r0d2hq8jynrsin5w";
        libraryHaskellDepends = [ base ];
        description = "Library for Fedora distribution versions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "fedora-haskell-tools" = callPackage
···
          process simple-cmd simple-cmd-args split time unix
        ];
        description = "Building and maintenance tools for Fedora Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "fedora-img-dl" = callPackage
···
          xdg-userdirs
        ];
        description = "Fedora image download tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          raw-strings-qq scotty text transformers wai warp wreq xml
        ];
        description = "Translate syndication feeds";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base ];
        doHaddock = false;
        description = "To be written";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "fenfire" = callPackage
···
          tasty-hunit tasty-quickcheck time
        ];
        description = "Generate and verify HMAC-based authentication tokens";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, bytestring, filepath, QuickCheck, unix }:
      mkDerivation {
        pname = "filepath-bytestring";
-       version = "1.4.2.1.6";
-       sha256 = "11xrrzdkm5i96dazbz0gi1qp8nnj2lwbnxzwy7f4cnahskz4f4g7";
+       version = "1.4.2.1.7";
+       sha256 = "00xayqjq2qvb4yj0ppx838cabg5cx9swh0mzfb8c6njk9y5rc41n";
        libraryHaskellDepends = [ base bytestring unix ];
        testHaskellDepends = [ base bytestring filepath QuickCheck ];
        description = "Library for manipulating RawFilePaths in a cross platform way";
···
        sha256 = "08rb2nafnh5vx7i6i3ddhq4h1s2ffgz8ailap5knr1xl7izgyywp";
        libraryHaskellDepends = [ base base-io-access filepath ];
        description = "IO Access for filepath";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          optparse-applicative text tree-fun unordered-containers
        ];
        description = "Find the clumpiness of labels in a tree";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          http-directory simple-cmd-args text
        ];
        description = "List http/html files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty tasty-quickcheck temporary
        ];
        description = "File-backed recursive data structures";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          old-time QuickCheck text
        ];
        description = "FIX (co)parser";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base binary deepseq HTTP optparse-applicative process
        ];
        description = "Verify FLAC files ripped form CD using AccurateRip™";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "flags-applicative" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base directory parsec ];
        description = "flatten a latex multi-file latex document and remove all comments";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "flatbuffers" = callPackage
···
        broken = true;
      }) {};
 
+  "flatparse" = callPackage
+    ({ mkDerivation, attoparsec, base, bytesmith, bytestring
+     , containers, gauge, megaparsec, parsec, primitive
+     , template-haskell
+     }:
+     mkDerivation {
+       pname = "flatparse";
+       version = "0.1.1.1";
+       sha256 = "19k1336hf23n440bk5fjw296bs7kqccfa4mhl4wsvfvbsyrzlp09";
+       libraryHaskellDepends = [
+         base bytestring containers template-haskell
+       ];
+       benchmarkHaskellDepends = [
+         attoparsec base bytesmith bytestring gauge megaparsec parsec
+         primitive
+       ];
+       description = "High-performance parsing from strict bytestrings";
+       license = lib.licenses.mit;
+     }) {};
+
   "flay" = callPackage
     ({ mkDerivation, base, constraints, tasty, tasty-quickcheck
      , transformers
···
          directory MonadRandom mtl random
        ];
        description = "Simulate 454 pyrosequencing";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          resource-pool text time uuid-types yesod-core yesod-static
        ];
        description = "A simple web application as a online practice website for XDU SE 2017 fall SPM";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "fluffy-parser" = callPackage
···
          base binary bytestring pandoc parsec postgresql-simple
        ];
        description = "The parser for fluffy to parsec the question bank in .docx type";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          array base containers gloss optparse-applicative xml
        ];
        description = "Toolset for Folger Shakespeare Library's XML annotated plays";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "follow" = callPackage
···
          text time transformers unordered-containers yaml
        ];
        description = "Haskell library to follow content published on any subject";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          old-locale strict time
        ];
        description = "Follow Tweets anonymously";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "forsyde-shallow";
-       version = "3.4.0.1";
-       sha256 = "0im5xf8dcalsjk85fyvih042apv3wl54k3jlmdjg7fnm3mgxj1yj";
+       version = "3.5.0.0";
+       sha256 = "16skihnq2kkxdgliv6780s2lyka1bsm0naws6kz1sy3ggsw0qnp9";
        libraryHaskellDepends = [ base directory old-time process random ];
        testHaskellDepends = [
          base directory doctest hspec old-time process QuickCheck random
···
        sha256 = "1hmcicxnxcl99chidkbg1kspjzpxxcw8qh4lrwvmlpz2knzf11g3";
        libraryHaskellDepends = [ array-forth base free mtl ];
        description = "A simple eDSL for generating arrayForth code";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base frame pandoc ];
        description = "A markdown to Frame GUI writer for Pandoc";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "franchise" = callPackage
···
      }:
      mkDerivation {
        pname = "free-algebras";
-       version = "0.1.0.0";
-       sha256 = "0s5gj52b3s1hg92cs12qk7y2zgsl546livdzps2qm4fmjc394qj3";
+       version = "0.1.0.1";
+       sha256 = "13cyy6afp9y3wfv3qihf0ngrvs7rghbx627a88l3yq1l21r0bbj8";
        libraryHaskellDepends = [
          base containers data-fix dlist free groups kan-extensions mtl
          transformers
···
        libraryPkgconfigDepends = [ libfreenect ];
        description = "Interface to the Kinect device";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) freenect; freenect_sync = null; 
          libfreenect = null;};
 
···
          base QuickCheck test-framework test-framework-quickcheck2 vector
        ];
        description = "A functional image processing library for Haskell";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "friday-devil" = callPackage
···
        ];
        librarySystemDepends = [ libdevil ];
        description = "Uses the DevIL C library to read and write images from and to files and memory buffers";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libdevil;};
···
        sha256 = "18mnxlwlyh4q18xc9svpwma3qgwp473dfg1z1rmdll6za82zmvzn";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Arduino programming without the hassle of C";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base frpnow vty ];
        executableHaskellDepends = [ base containers frpnow vty ];
        description = "Program terminal applications with vty and frpnow!";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "Simple sentence segmenter";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "funbot" = callPackage
···
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base filepath pretty process ];
        description = "Functional MetaPost is a Haskell frontend to the MetaPost language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
     ({ mkDerivation, aeson, alex, ansi-terminal, array, base, binary
      , blaze-html, bmp, bytestring, bytestring-to-vector, cmark-gfm
      , containers, directory, directory-tree, dlist, file-embed
-     , filepath, free, gitrev, happy, haskeline, language-c-quote
-     , mainland-pretty, megaparsec, mtl, neat-interpolation, parallel
-     , parser-combinators, pcg-random, process, process-extras
-     , QuickCheck, regex-tdfa, sexp-grammar, srcloc, tasty, tasty-hunit
-     , tasty-quickcheck, template-haskell, temporary, terminal-size
-     , text, time, transformers, unordered-containers, utf8-string
-     , vector, vector-binary-instances, versions, zip-archive, zlib
+     , filepath, free, gitrev, happy, hashable, haskeline
+     , language-c-quote, mainland-pretty, megaparsec, mtl
+     , neat-interpolation, parallel, parser-combinators, pcg-random
+     , process, process-extras, QuickCheck, regex-tdfa, srcloc, tasty
+     , tasty-hunit, tasty-quickcheck, template-haskell, temporary
+     , terminal-size, text, time, transformers, unordered-containers
+     , utf8-string, vector, vector-binary-instances, versions
+     , zip-archive, zlib
      }:
      mkDerivation {
        pname = "futhark";
-       version = "0.19.1";
-       sha256 = "1nhy1pjqy7na7brpkh72yzcglfrwaz7l325fivfq5niaq85832dd";
+       version = "0.19.2";
+       sha256 = "0pkb9yqvfbahmq3lmp7ia0c4sfzx1cghnhk4b7z41xbf20qcakrx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal array base binary blaze-html bmp bytestring
          bytestring-to-vector cmark-gfm containers directory directory-tree
-         dlist file-embed filepath free gitrev haskeline language-c-quote
-         mainland-pretty megaparsec mtl neat-interpolation parallel
-         pcg-random process process-extras regex-tdfa sexp-grammar srcloc
+         dlist file-embed filepath free gitrev hashable haskeline
+         language-c-quote mainland-pretty megaparsec mtl neat-interpolation
+         parallel pcg-random process process-extras regex-tdfa srcloc
          template-haskell temporary terminal-size text time transformers
          unordered-containers utf8-string vector vector-binary-instances
          versions zip-archive zlib
···
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [ base text ];
        testHaskellDepends = [
-         base containers megaparsec mtl parser-combinators QuickCheck
-         sexp-grammar tasty tasty-hunit tasty-quickcheck text
+         base containers megaparsec mtl parser-combinators QuickCheck tasty
+         tasty-hunit tasty-quickcheck text
        ];
        description = "An optimising compiler for a functional, array-oriented language";
        license = lib.licenses.isc;
···
        isExecutable = true;
        executableHaskellDepends = [ base bytestring network unix ];
        description = "Simple IP-over-UDP tunnel using TUNTAP";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "10whksji6r1bilmj2fxcccg89zh7c08s2zfn07r6wj3xgschrckv";
        libraryHaskellDepends = [ base transformers ];
        description = "realtime resource handling with manual concurrency";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "futures" = callPackage
···
        broken = true;
      }) {};
 
+  "fuzzyfind" = callPackage
+    ({ mkDerivation, array, base, containers }:
+     mkDerivation {
+       pname = "fuzzyfind";
+       version = "0.1.0";
+       sha256 = "0ghv1paisvy4dn3l7vv499a6k6a4r54ks5bn3jl8zhy65xn5c8nv";
+       libraryHaskellDepends = [ array base containers ];
+       description = "Fuzzy text matching";
+       license = lib.licenses.mit;
+     }) {};
+
   "fuzzyset" = callPackage
     ({ mkDerivation, base, data-default, hspec, ieee754, text
      , text-metrics, unordered-containers, vector
···
        libraryHaskellDepends = [ base ];
        description = "Horizontally composable effects";
        license = lib.licenses.mit;
+     }) {};
+
+  "fxpak" = callPackage
+    ({ mkDerivation, base, bytestring, serialport }:
+     mkDerivation {
+       pname = "fxpak";
+       version = "0.0.1";
+       sha256 = "07c5za6limzk76if4rnwyq5iawhqp78hlm793y73cxhb65y0g9d0";
+       libraryHaskellDepends = [ base bytestring serialport ];
+       description = "Interface to the FXPak/FXPak Pro USB interface";
+       license = lib.licenses.bsd3;
      }) {};
 
   "g-npm" = callPackage
···
        libraryPkgconfigDepends = [ GConf ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the GNOME configuration database system";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs.gnome2) GConf;};
···
          transformers
        ];
        description = "recursive atomic build system";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "gdp" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base GLUT OpenGLRaw Vec ];
        description = "zooming rotating fractal gears graphics demo";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "gedcom" = callPackage
···
        librarySystemDepends = [ gegl ];
        libraryPkgconfigDepends = [ gegl ];
        description = "Haskell bindings to GEGL library";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gegl;};
···
        pname = "gemini-router";
        version = "0.1.1.0";
        sha256 = "19aq9ri0ixkg0d5g4ickda75dvpq340lwkdxn0ndcbkis9xrvkv9";
+       revision = "1";
+       editedCabalFile = "07lnx99d3dkjhqcail31zkbmivclzxdj3qjbhijg1cs3fkl57q3q";
        libraryHaskellDepends = [
          base gemini-server HsOpenSSL network-uri transformers
        ];
···
      }:
      mkDerivation {
        pname = "gemini-server";
-       version = "0.2.0.0";
-       sha256 = "06sqy3c04s3cjx6p9rzfi23cq34bjs1wbigczcc66i6ahf4x1hz2";
-       revision = "1";
-       editedCabalFile = "0zw9svhk5wmi56vqmw7630nqhp816xph9ldgc8l3jzspziz350fx";
+       version = "0.3.0.0";
+       sha256 = "0s9h0lzxz5yjvz8rzw9mx9dba21171960waaqikj2qbbja0iq3k3";
        libraryHaskellDepends = [
          base bytestring hslogger HsOpenSSL network network-run network-uri
          text utf8-string
···
        libraryHaskellDepends = [ attoparsec base text ];
        executableHaskellDepends = [ attoparsec base text ];
        description = "Identify a persons gender by their first name";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring cmdargs directory filepath GenI json text
        ];
        description = "Companion tools for use with the GenI surface realiser";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base ieee754 linear QuickCheck ];
        testHaskellDepends = [ base ieee754 linear QuickCheck ];
        description = "package for geometry in euklidean 2d space";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        enableSeparateDataOutput = true;
        executableHaskellDepends = [ base containers parsec ];
        description = "A type checker and runtime system of rCOS/g (impl. of ggts-FCS).";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "ghc-events";
-       version = "0.15.1";
-       sha256 = "16kh64z60353m6bj9lmv9yzlvydgmi66hm8gc4b22bs69xyh2pxz";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         array base binary bytestring containers text vector
-       ];
-       executableHaskellDepends = [ base containers ];
-       testHaskellDepends = [ base ];
-       description = "Library and tool for parsing .eventlog files from GHC";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "ghc-events_0_16_0" = callPackage
-    ({ mkDerivation, array, base, binary, bytestring, containers, text
-     , vector
-     }:
-     mkDerivation {
-       pname = "ghc-events";
        version = "0.16.0";
        sha256 = "0cr6aj4v9j2fadwhhifjlbg4anyc05phfmy3pvd9h7gn12a2ydr9";
        isLibrary = true;
···
        testHaskellDepends = [ base ];
        description = "Library and tool for parsing .eventlog files from GHC";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ghc-events-analyze" = callPackage
···
        pname = "ghc-lib-parser";
        version = "9.0.1.20210207";
        sha256 = "1gikdcgcgw1paxs5igxgxdfvpjp23963f6vn83m0a6vr88n2haah";
+       revision = "1";
+       editedCabalFile = "1fkh3xc2pq4k0mz1x92xhby5sqamfsnfm4rlq38p5shybkan7qgl";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          array base binary bytestring containers deepseq directory
···
          base criterion directory filepath temporary
        ];
        description = "Happy Haskell Hacking";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "ghc-tags-core";
-       version = "0.2.4.0";
-       sha256 = "1h2khrvykywdddnhpy6yg2adfjlzdy6i6zib8km5j2zakmhq9s9j";
+       version = "0.2.4.1";
+       sha256 = "0d1srd72ajp2csyic6wpj6i7818rimqbcg5c3lxj76cz9zpjr1g8";
        libraryHaskellDepends = [
          attoparsec base bytestring directory filepath-bytestring ghc mtl
          pipes pipes-attoparsec pipes-bytestring text transformers
···
      }:
      mkDerivation {
        pname = "ghc-tags-plugin";
-       version = "0.2.4.0";
-       sha256 = "1cpfh3cvad2avissri0cs7ghamg2q3nyifyzlj3dndmzbpjrvxy7";
+       version = "0.2.4.1";
+       sha256 = "1hzv3s6pys1cqwj3hs1xww52v5yapisw9y3d5fmxzh0s6nawpxf2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "ghc-typelits-presburger";
-       version = "0.5.2.0";
-       sha256 = "0ny7paq8ykc4ycag1dlb9mlpv17dh9a6csh22abj6bls5rx4iljr";
+       version = "0.6.0.0";
+       sha256 = "08jxp7xnpnlkn8429x25sy1r8xg4b4pv5a41bgw08dl0br4941cx";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = lib.licenses.asl20;
      }) {};
 
+  "ghcide_1_1_0_0" = callPackage
+    ({ mkDerivation, aeson, array, async, base, base16-bytestring
+     , binary, bytestring, bytestring-encoding, case-insensitive
+     , containers, cryptohash-sha1, data-default, deepseq, dependent-map
+     , dependent-sum, Diff, directory, dlist, extra, filepath
+     , fingertree, fuzzy, ghc, ghc-boot, ghc-boot-th, ghc-check
+     , ghc-exactprint, ghc-paths, ghc-typelits-knownnat, gitrev, Glob
+     , haddock-library, hashable, heapsize, hie-bios, hie-compat, hiedb
+     , hls-plugin-api, hp2pretty, hslogger, implicit-hie
+     , implicit-hie-cradle, lens, lsp, lsp-test, lsp-types, mtl
+     , network-uri, opentelemetry, optparse-applicative, parallel
+     , prettyprinter, prettyprinter-ansi-terminal, process, QuickCheck
+     , quickcheck-instances, record-dot-preprocessor, record-hasfield
+     , regex-tdfa, retrie, rope-utf16-splay, safe, safe-exceptions
+     , shake, shake-bench, sorted-list, sqlite-simple, stm, syb, tasty
+     , tasty-expected-failure, tasty-hunit, tasty-quickcheck
+     , tasty-rerun, text, time, transformers, unix, unliftio
+     , unliftio-core, unordered-containers, utf8-string, vector, yaml
+     }:
+     mkDerivation {
+       pname = "ghcide";
+       version = "1.1.0.0";
+       sha256 = "1i2xyp2n4g4cpz50wpwmzmknrzqzxnv3b551ibmhdy41v2fh6y5l";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson array async base base16-bytestring binary bytestring
+         bytestring-encoding case-insensitive containers cryptohash-sha1
+         data-default deepseq dependent-map dependent-sum Diff directory
+         dlist extra filepath fingertree fuzzy ghc ghc-boot ghc-boot-th
+         ghc-check ghc-exactprint ghc-paths Glob haddock-library hashable
+         heapsize hie-bios hie-compat hiedb hls-plugin-api hslogger
+         implicit-hie-cradle lens lsp lsp-types mtl network-uri
+         opentelemetry parallel prettyprinter prettyprinter-ansi-terminal
+         regex-tdfa retrie rope-utf16-splay safe safe-exceptions shake
+         sorted-list sqlite-simple stm syb text time transformers unix
+         unliftio unliftio-core unordered-containers utf8-string vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring containers data-default directory extra
+         filepath ghc gitrev hashable heapsize hie-bios hiedb hls-plugin-api
+         lens lsp lsp-test lsp-types optparse-applicative process
+         safe-exceptions shake text unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base binary bytestring containers data-default directory
+         extra filepath ghc ghc-typelits-knownnat haddock-library
+         hls-plugin-api lens lsp lsp-test lsp-types network-uri
+         optparse-applicative process QuickCheck quickcheck-instances
+         record-dot-preprocessor record-hasfield rope-utf16-splay safe
+         safe-exceptions shake tasty tasty-expected-failure tasty-hunit
+         tasty-quickcheck tasty-rerun text
+       ];
+       testToolDepends = [ implicit-hie ];
+       benchmarkHaskellDepends = [
+         aeson base directory extra filepath optparse-applicative shake
+         shake-bench text yaml
+       ];
+       benchmarkToolDepends = [ hp2pretty implicit-hie ];
+       description = "The core of an IDE";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ghcjs-ajax" = callPackage
     ({ mkDerivation, aeson, base, http-types, text }:
      mkDerivation {
···
        ];
        libraryPkgconfigDepends = [ atk ];
        description = "Atk bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) atk;};
 
   "gi-cairo" = callPackage
···
          setupCompileFlags+=" $(pkg-config --libs cairo-gobject)"
        '';
        description = "Cairo bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) cairo;};
 
   "gi-cairo-again" = callPackage
···
          base gi-cairo gi-cairo-render haskell-gi-base mtl
        ];
        description = "GI friendly Binding to the Cairo library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {};
 
   "gi-cairo-render" = callPackage
···
        ];
        libraryPkgconfigDepends = [ libdbusmenu ];
        description = "Dbusmenu bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) libdbusmenu;};
 
   "gi-dbusmenugtk3" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk3 libdbusmenu-gtk3 ];
        description = "DbusmenuGtk bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3; inherit (pkgs) libdbusmenu-gtk3;};
 
   "gi-gdk" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk3 ];
        description = "Gdk bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
   "gi-gdk_4_0_2" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk4 ];
        description = "Gdk bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) gtk4;};
 
···
        ];
        libraryPkgconfigDepends = [ gdk-pixbuf ];
        description = "GdkPixbuf bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gdk-pixbuf;};
 
   "gi-gdkx11" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk3 ];
        description = "GdkX11 bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
   "gi-gdkx11_4_0_2" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk4-x11 ];
        description = "GdkX11 bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {gtk4-x11 = null;};
 
···
        ];
        libraryPkgconfigDepends = [ libgit2-glib ];
        description = "libgit2-glib bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) libgit2-glib;};
 
   "gi-gio" = callPackage
···
        ];
        libraryPkgconfigDepends = [ glib ];
        description = "Gio bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib;};
 
   "gi-girepository" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gobject-introspection ];
        description = "GIRepository (gobject-introspection) bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gobject-introspection;};
 
   "gi-glib" = callPackage
···
        ];
        libraryPkgconfigDepends = [ glib ];
        description = "GLib bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib;};
 
   "gi-gobject" = callPackage
···
        ];
        libraryPkgconfigDepends = [ glib ];
        description = "GObject bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib;};
 
   "gi-graphene" = callPackage
···
        ];
        libraryPkgconfigDepends = [ graphene-gobject ];
        description = "Graphene bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {graphene-gobject = null;};
···
        ];
        libraryPkgconfigDepends = [ gtk4 ];
        description = "Gsk bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gtk4;};
···
        ];
        libraryPkgconfigDepends = [ gstreamer ];
        description = "GStreamer bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs.gst_all_1) gstreamer;};
 
   "gi-gstaudio" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gst-plugins-base ];
        description = "GStreamerAudio bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs.gst_all_1) gst-plugins-base;};
···
        ];
        libraryPkgconfigDepends = [ gst-plugins-base ];
        description = "GStreamerBase bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs.gst_all_1) gst-plugins-base;};
 
   "gi-gstpbutils" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gstreamer-pbutils ];
        description = "GStreamer Plugins Base Utils bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {gstreamer-pbutils = null;};
···
        ];
        libraryPkgconfigDepends = [ gstreamer-tag ];
        description = "GStreamer Tag bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {gstreamer-tag = null;};
···
        ];
        libraryPkgconfigDepends = [ gst-plugins-base ];
        description = "GStreamerVideo bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs.gst_all_1) gst-plugins-base;};
 
   "gi-gtk" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk3 ];
        description = "Gtk bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
   "gi-gtk_4_0_3" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk4 ];
        description = "Gtk bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) gtk4;};
 
···
          gi-gtk haskell-gi-base mtl text transformers
        ];
        description = "A wrapper for gi-gtk, adding a few more idiomatic API parts on top";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {};
 
   "gi-gtkosxapplication" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ];
        description = "GtkosxApplication bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {gtk-mac-integration-gtk3 = null;};
···
        ];
        libraryPkgconfigDepends = [ gtksheet ];
        description = "GtkSheet bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {gtksheet = null;};
···
        ];
        libraryPkgconfigDepends = [ gtksourceview3 ];
        description = "GtkSource bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtksourceview3;};
 
   "gi-handy" = callPackage
···
        ];
        libraryPkgconfigDepends = [ libhandy ];
        description = "libhandy bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libhandy;};
···
        ];
        libraryPkgconfigDepends = [ harfbuzz harfbuzz-gobject ];
        description = "HarfBuzz bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) harfbuzz; harfbuzz-gobject = null;};
 
   "gi-ibus" = callPackage
···
        ];
        libraryPkgconfigDepends = [ ibus ];
        description = "IBus bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) ibus;};
 
   "gi-javascriptcore" = callPackage
···
        ];
        libraryPkgconfigDepends = [ webkitgtk ];
        description = "JavaScriptCore bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) webkitgtk;};
 
···
        ];
        libraryPkgconfigDepends = [ libnotify ];
        description = "Libnotify bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) libnotify;};
 
   "gi-ostree" = callPackage
···
        ];
        libraryPkgconfigDepends = [ ostree ];
        description = "OSTree bindings";
-       license = lib.licenses.lgpl21;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       license = lib.licenses.lgpl21Only;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) ostree;};
 
   "gi-pango" = callPackage
···
          setupCompileFlags+=" $(pkg-config --libs cairo-gobject)"
        '';
        description = "Pango bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) cairo; inherit (pkgs) pango;};
 
   "gi-pangocairo" = callPackage
···
          setupCompileFlags+=" $(pkg-config --libs cairo-gobject)"
        '';
        description = "PangoCairo bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) cairo; inherit (pkgs) pango;};
 
   "gi-poppler" = callPackage
···
        ];
        libraryPkgconfigDepends = [ poppler_gi ];
        description = "Poppler bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) poppler_gi;};
···
        ];
        libraryPkgconfigDepends = [ libsecret ];
        description = "Libsecret bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) libsecret;};
 
   "gi-soup" = callPackage
···
        ];
        libraryPkgconfigDepends = [ libsoup ];
        description = "Libsoup bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) libsoup;};
 
   "gi-vte" = callPackage
···
        ];
        libraryPkgconfigDepends = [ vte_291 ];
        description = "Vte bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {vte_291 = pkgs.vte;};
 
   "gi-webkit" = callPackage
···
        libraryPkgconfigDepends = [ webkitgtk24x-gtk3 ];
        doHaddock = false;
        description = "WebKit bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) webkitgtk24x-gtk3;};
 
···
        ];
        libraryPkgconfigDepends = [ webkitgtk ];
        description = "WebKit2 bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) webkitgtk;};
 
···
        ];
        libraryPkgconfigDepends = [ webkitgtk ];
        description = "WebKit2-WebExtension bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) webkitgtk;};
 
···
        ];
        libraryPkgconfigDepends = [ libwnck ];
        description = "Wnck bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libwnck;};
···
        ];
        libraryPkgconfigDepends = [ xlibsWrapper ];
        description = "xlib bindings";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) xlibsWrapper;};
 
   "giak" = callPackage
···
        ];
        libraryPkgconfigDepends = [ system-glib ];
        description = "Binding to GIO";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {system-glib = pkgs.glib;};
 
   "gipeda" = callPackage
···
          aeson base bytestring conduit http-conduit text
        ];
        description = "A reliable command-line client for gist.github.com";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        checkPhase = ''PATH+=":$PWD" git-annex test'';
        enableSharedExecutables = false;
        description = "manage files with git, without checking their contents into git";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        maintainers = with lib.maintainers; [ peti ];
      }) {inherit (pkgs) bup; inherit (pkgs) curl; inherit (pkgs) git; 
          inherit (pkgs) gnupg; inherit (pkgs) lsof; inherit (pkgs) openssh; 
···
          test-framework-quickcheck2 time utf8-string
        ];
        description = "Bindings to the date parsing from Git";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          http-types network-uri text
        ];
        description = "git-lfs protocol";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "git-mediate" = callPackage
···
          optparse-applicative process unix-compat
        ];
        description = "Tool to help resolving git conflicts";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "git-monitor" = callPackage
···
          split text time transformers unix unix-compat utf8-string
        ];
        description = "repairs a damaged git repository";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableToolDepends = [ git ];
        description = "backs up everything github knows about a repository, to the repository";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) git;};
···
      }:
      mkDerivation {
        pname = "github-release";
-       version = "1.3.6";
-       sha256 = "07cxai2h6alyka0bsfch7vfjsvp3s9d48jw4n6z74kmxq3zdrgxh";
+       version = "1.3.7";
+       sha256 = "14dz9ap43m2ws6l4wfrn6wn3g5p2k0fgv639q7nyp4zdd4kn9czh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          http-client-tls monad-parallel tabular tagsoup text time vector
        ];
        description = "Various Github helper utilities";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base glib gtk ];
        libraryPkgconfigDepends = [ libglade ];
        description = "Binding to the glade library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs.gnome2) libglade;};
···
          base containers GLFW-b lens mtl OpenGL
        ];
        description = "An OpenGL micro framework";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryPkgconfigDepends = [ glib ];
        description = "Binding to the GLIB library for Gtk2Hs";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib;};
 
   "glicko" = callPackage
···
        ];
        testHaskellDepends = [ base data-default hspec ];
        description = "Glicko-2 implementation in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "glider-nlp" = callPackage
···
        editedCabalFile = "0nia67zywmxyvcnlk0a906dijh9h7m6w48330n9gs2mjkhkyqb13";
        libraryHaskellDepends = [ base gloss reactive-banana ];
        description = "An Interface for gloss in terms of a reactive-banana Behavior";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0ygjqzb1pn092j0d0gcwhxdv940rdlvpaj1gxa347mdgvp4jb9za";
        libraryHaskellDepends = [ base gloss sodium ];
        description = "A Sodium interface to the Gloss drawing package";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          priority-queue qd reflection Vec
        ];
        description = "Mandelbrot Set explorer using GTK";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ libgnome-keyring ];
        libraryToolDepends = [ c2hs ];
        description = "Bindings for libgnome-keyring";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs.gnome3) gnome-keyring; 
          inherit (pkgs) libgnome-keyring;};
 
···
        testPkgconfigDepends = [ libidn ];
        testToolDepends = [ c2hs ];
        description = "Bindings for GNU IDN";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libidn;};
···
        librarySystemDepends = [ gnutls ];
        libraryPkgconfigDepends = [ gnutls ];
        description = "Bindings for GNU libgnutls";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) gnutls;};
 
   "goa" = callPackage
···
        ];
        testHaskellDepends = [ base containers HUnit mtl parsec ];
        description = "A monadic take on a 2,500-year-old board game - library";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        executableHaskellDepends = [ base gtk ];
        testHaskellDepends = [ base HUnit ];
        description = "A monadic take on a 2,500-year-old board game - GTK+ UI";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "goldplate";
        version = "0.1.3";
        sha256 = "109qhyq0n4w1jdz7y2hd8cjf44pikavv6mfnmf65vyfjangjq610";
+       revision = "1";
+       editedCabalFile = "1chrg7mfs4w4hbc0i1pdsj1350c4h3dhcv7xswn2ygq78337xxqk";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "google-oauth2-jwt";
-       version = "0.3.2";
-       sha256 = "1njb9j6pb656drchi8qc94pniwph2bplnb667ga719yxmzm4256s";
+       version = "0.3.3";
+       sha256 = "13iy695qpb9yyr1wi3fslj0xd90izgj4wmvs04k5mhf6k53pk9dk";
        libraryHaskellDepends = [
          base base64-bytestring bytestring HsOpenSSL RSA text unix-time
        ];
···
          mime-types network optparse-applicative text wai warp
        ];
        description = "proxy gopher over http";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        maintainers = with lib.maintainers; [ sternenseemann ];
      }) {};
 
···
        sha256 = "0dzkv13w06hkxg2vkbblpskvsq02c2ay06rw2j4vyjpw13hms5bv";
        libraryHaskellDepends = [ base containers fgl ];
        description = "An implementation of algorithms for matchings in graphs";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "graphql-client";
        version = "1.1.0";
        sha256 = "0yk6nfyyynydrgwc1cdy5235121gw5q4iaapbvixpckz2diidxx7";
+       revision = "2";
+       editedCabalFile = "120c5cd9gj407lf3lcvfq0gqlvdpf3ciws9207nh0qqqdrpws9mj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          old-locale OpenGL OpenGLRaw parallel qd qd-vec ruff time Vec
        ];
        description = "fractal explorer GUI using the ruff library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          random ruff Vec
        ];
        description = "Mandelbrot Set examples using ruff and gruff";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryPkgconfigDepends = [ gsasl ];
        description = "Bindings for GNU libgsasl";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) gsasl;};
 
   "gsc-weighting" = callPackage
···
          base feed http-conduit scalpel-core text uri xml-types
        ];
        description = "scrapes google scholar, provides RSS feed";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ gst-plugins-base gstreamer ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the GStreamer open source multimedia framework";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {gst-plugins-base = null; gstreamer = null;};
···
        ];
        libraryPkgconfigDepends = [ gtk2 ];
        description = "Binding to the Gtk+ graphical user interface library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk2;};
 
   "gtk-helpers" = callPackage
···
        sha256 = "0fjlk6z8j77l35k9cdzgbyf1w5wd0v0k1sry78vf7f6j4mvv8wb0";
        libraryHaskellDepends = [ base gtk json transformers ];
        description = "A simple custom form widget for gtk which allows inputing of JSON values";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "gtk-largeTreeStore" = callPackage
···
        ];
        testHaskellDepends = [ base containers gtk3 hspec ];
        description = "Large TreeStore support for gtk2hs";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "gtk-mac-integration" = callPackage
···
        libraryHaskellDepends = [ array base containers glib gtk mtl ];
        libraryPkgconfigDepends = [ gtk-mac-integration-gtk2 ];
        description = "Bindings for the Gtk/OS X integration library";
-       license = lib.licenses.lgpl21;
-       platforms = [ "armv7l-linux" "x86_64-darwin" ];
+       license = lib.licenses.lgpl21Only;
+       platforms = [ "x86_64-darwin" ];
      }) {inherit (pkgs) gtk-mac-integration-gtk2;};
 
   "gtk-serialized-event" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk2 ];
        description = "GTK+ Serialized event";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gtk2;};
···
        sha256 = "1qqfhaap2996015h3jkgg9j3hyxrh88wn6kba29ys0q1h35f8yws";
        libraryHaskellDepends = [ base gtk ];
        description = "A simple custom form widget for gtk which allows single LOC creation/updating of list views";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "gtk-sni-tray" = callPackage
···
        sha256 = "14hb7nxf4l0q7hab8dzll8dh5ccb4hhc8arywijdgdrz4i2s2706";
        libraryHaskellDepends = [ base gtk ];
        description = "A simple custom form widget for gtk which allows single LOC creation/updating of toggle button lists";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "gtk-toy" = callPackage
···
        libraryHaskellDepends = [ base glib gtk3 ];
        libraryPkgconfigDepends = [ xlibsWrapper ];
        description = "A wrapper around the eggtraymanager library for Linux system trays";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) xlibsWrapper;};
 
   "gtk2hs-buildtools" = callPackage
···
        libraryToolDepends = [ alex happy ];
        executableHaskellDepends = [ base ];
        description = "Tools to build the Gtk2Hs suite of User Interface libraries";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "gtk2hs-cast-glade" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gtk3 ];
        description = "Binding to the Gtk+ 3 graphical user interface library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) gtk3;};
 
   "gtk3-helpers" = callPackage
···
        libraryHaskellDepends = [ array base containers glib gtk3 mtl ];
        libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ];
        description = "Bindings for the Gtk/OS X integration library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {gtk-mac-integration-gtk3 = null;};
···
        libraryPkgconfigDepends = [ gtkglext ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the GTK+ OpenGL Extension";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gtk2; inherit (pkgs.gnome2) gtkglext; 
···
        libraryPkgconfigDepends = [ gtkimageview ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the GtkImageView library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gtkimageview;};
···
        libraryPkgconfigDepends = [ gtksourceview ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the GtkSourceView library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gtksourceview;};
···
        libraryPkgconfigDepends = [ gtksourceview3 ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the GtkSourceView library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gtksourceview3;};
···
        enableSeparateDataOutput = true;
        executableHaskellDepends = [ base cairo containers filepath gtk ];
        description = "graphical untyped lambda calculus interactive interpreter";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0vvzlfnvh9r9jqf7v83d0piqpvl40sg0mswf9f41vncgzg0z79v2";
        libraryHaskellDepends = [ base ];
        description = "The first 1001 Fibonacci numbers, retrieved from the Gutenberg Project";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "gw" = callPackage
···
          stm template-haskell transformers utf8-string vinyl
        ];
        description = "Haskell library for retrieving data from various booru image sites";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base hOff-parser OpenGL ];
        executableHaskellDepends = [ base GLFW hOff-parser OpenGL parsec ];
        description = "The tool to transform the OFF to other image format";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1vjvn4sr9nb7dd0in57kay6sb49nqzs377v6k9570h5faaj1dyci";
        libraryHaskellDepends = [ base parsec ];
        description = "The parser to parser the OFF(Object File Format, Princeton ModelNet)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hOpenPGP" = callPackage
···
          ShellCheck split text
        ];
        description = "Dockerfile Linter JavaScript API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hadoop-formats" = callPackage
···
        ];
        testHaskellDepends = [ base doctest filemanip process ];
        description = "Confirm delegation of NS and MX records";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "hafar" = callPackage
···
        ];
        executableHaskellDepends = [ base time ];
        description = "Analytic Hierarchy Process";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          iterio-server mongoDB mtl
        ];
        description = "Dynamic launcher of Hails applications";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hairy" = callPackage
···
      , containers, cryptonite, data-default, deepseq, directory
      , file-embed, filepath, fsnotify, http-conduit, http-types
      , lrucache, memory, mtl, network-uri, optparse-applicative, pandoc
-     , pandoc-citeproc, parsec, process, QuickCheck, random, regex-tdfa
-     , resourcet, scientific, tagsoup, tasty, tasty-hunit
+     , parsec, process, QuickCheck, random, regex-tdfa, resourcet
+     , scientific, tagsoup, tasty, tasty-golden, tasty-hunit
      , tasty-quickcheck, template-haskell, text, time
      , time-locale-compat, unordered-containers, utillinux, vector, wai
      , wai-app-static, warp, yaml
      }:
      mkDerivation {
        pname = "hakyll";
-       version = "4.13.4.1";
-       sha256 = "1z9k3029bjyxy2aqmqr6gzsva50154y4bfxqkmsjgl38lx3s6kk9";
-       revision = "1";
-       editedCabalFile = "1hv80gqq50zz791620lgdvkspspii0z59ngj7la69cdw2739cc5g";
+       version = "4.14.0.0";
+       sha256 = "088df9vs5f2p5iiv7rbrisz4z4s38mkr9z41gy3hqdapg4m7mi1c";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          base binary blaze-html blaze-markup bytestring containers
          cryptonite data-default deepseq directory file-embed filepath
          fsnotify http-conduit http-types lrucache memory mtl network-uri
-         optparse-applicative pandoc pandoc-citeproc parsec process random
-         regex-tdfa resourcet scientific tagsoup template-haskell text time
+         optparse-applicative pandoc parsec process random regex-tdfa
+         resourcet scientific tagsoup template-haskell text time
          time-locale-compat unordered-containers vector wai wai-app-static
          warp yaml
        ];
        executableHaskellDepends = [ base directory filepath ];
        testHaskellDepends = [
-         base bytestring containers filepath QuickCheck tasty tasty-hunit
-         tasty-quickcheck text unordered-containers yaml
+         base bytestring containers filepath QuickCheck tasty tasty-golden
+         tasty-hunit tasty-quickcheck text unordered-containers yaml
        ];
        testToolDepends = [ utillinux ];
        description = "A static website compiler library";
···
        ];
        description = "Hakyll wrapper for the Elm compiler";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hakyll-favicon" = callPackage
···
          regex-posix split tasty tasty-hunit tasty-quickcheck
        ];
        description = "A shortcode extension module for Hakyll";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base hint process ];
        description = "looks for functions given a set of example input/outputs";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "halves" = callPackage
···
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Interpreter for SQL-structure definitions in YAML (YamSql)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          wai-middleware-static yaml
        ];
        description = "Simple Continuous Integration/Deployment System";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ libappindicator-gtk2 ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the appindicator library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libappindicator-gtk2;};
···
        libraryHaskellDepends = [ base glib gtk3 ];
        libraryPkgconfigDepends = [ libappindicator-gtk3 ];
        description = "Binding to the appindicator library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) libappindicator-gtk3;};
···
          array base clock language-dot transformers xml
        ];
        description = "Parser for dot made with happy";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "happy-hour" = callPackage
···
        pname = "happy-meta";
        version = "0.2.0.11";
        sha256 = "1vgv5fx1fya7wfh3zwdgy0hm0lyzp171gnpp6ymfd6kqmqkl3293";
+       revision = "1";
+       editedCabalFile = "1dspifamwsn6lcj2mxjyrbdsfjqfb4p6m0s1c9dkiv08cfkk02p6";
        libraryHaskellDepends = [
          array base containers fail haskell-src-meta mtl template-haskell
        ];
···
          base containers derive hlint hslogger hspec HUnit QuickCheck
        ];
        description = "A web service specification compiler that generates implementation and tests";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryPkgconfigDepends = [ groonga ];
        description = "Low level bindings for Groonga";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) groonga;};
···
          scotty text time transformers wai-extra
        ];
        description = "Yet another Groonga http server";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring conduit cryptohash hex path
        ];
        description = "Decompress SAPCAR archives";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "hascard" = callPackage
···
          base bytestring cryptohash directory filepath
        ];
        description = "Rename every file in a directory with his SHA1 hash";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hashring" = callPackage
···
          base cmdargs containers cpphs directory her-lexer split
        ];
        description = "A dialect of haskell with order of execution based on dependency resolution";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        broken = true;
      }) {};
 
-  "haskeline_0_8_1_1" = callPackage
+  "haskeline_0_8_1_2" = callPackage
     ({ mkDerivation, base, bytestring, containers, directory
      , exceptions, filepath, HUnit, process, stm, terminfo, text
      , transformers, unix
      }:
      mkDerivation {
        pname = "haskeline";
-       version = "0.8.1.1";
-       sha256 = "1cg51rbhpa7ism0rg39dw7njz4r3q5h5pnysnbc37dh6gcdiyg2p";
+       version = "0.8.1.2";
+       sha256 = "0axr258a8wrsq37jwx4g343969lycydx9symijnp64a7ki67jrnp";
        configureFlags = [ "-fterminfo" ];
        isLibrary = true;
        isExecutable = true;
···
        editedCabalFile = "0h900mw5kzd9fvywpbhfd9acnfwp3qk7nfi9yr9ibamjb8s87cm1";
        libraryHaskellDepends = [ base containers mtl protolude text ];
        description = "Write Emacs module in Haskell, using Emacs 25's Dynamic Module feature";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }) {};
 
   "haskell-ci" = callPackage
-    ({ mkDerivation, aeson, ansi-terminal, base, base-compat
-     , bytestring, Cabal, cabal-install-parsers, containers, deepseq
+    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
+     , base-compat, base16-bytestring, binary, bytestring, Cabal
+     , cabal-install-parsers, containers, cryptohash-sha256, deepseq
      , Diff, directory, exceptions, filepath, generic-lens-lite, HsYAML
-     , lattices, mtl, network-uri, optparse-applicative, parsec, pretty
-     , process, ShellCheck, tasty, tasty-golden, temporary, text
-     , transformers, unordered-containers
+     , indexed-traversable, indexed-traversable-instances, ini, lattices
+     , mtl, network-uri, optparse-applicative, parsec, pretty, process
+     , ShellCheck, tasty, tasty-golden, temporary, text, transformers
+     , unordered-containers, zinza
      }:
      mkDerivation {
        pname = "haskell-ci";
-       version = "0.10.3";
-       sha256 = "18qynghm1aj0qr18v6m3md75p2l3kyhki03798jwhi4kc5qdk2vv";
+       version = "0.12";
+       sha256 = "17ccxpsi483fkiyp98m09nzqds9n78y53naii5x18nvdxv9fssam";
        isLibrary = false;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson base base-compat bytestring Cabal cabal-install-parsers
-         containers deepseq directory exceptions filepath generic-lens-lite
-         HsYAML lattices mtl network-uri optparse-applicative parsec pretty
-         process ShellCheck temporary text transformers unordered-containers
+         aeson attoparsec base base-compat base16-bytestring binary
+         bytestring Cabal cabal-install-parsers containers cryptohash-sha256
+         deepseq directory exceptions filepath generic-lens-lite HsYAML
+         indexed-traversable indexed-traversable-instances ini lattices mtl
+         network-uri optparse-applicative parsec pretty process ShellCheck
+         temporary text transformers unordered-containers zinza
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
-         ansi-terminal base base-compat bytestring Diff directory filepath
-         tasty tasty-golden transformers
+         ansi-terminal base base-compat bytestring Cabal Diff directory
+         filepath tasty tasty-golden transformers
        ];
        doHaddock = false;
        description = "Cabal package script generator for Travis-CI";
···
        sha256 = "1iz94kyq1xn3v89aay282qglv2sh41b04p8vaygwm22v1g4b4kk7";
        libraryHaskellDepends = [ base process ];
        description = "Simple CoffeeScript API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bimap boolean-list bytestring containers
        ];
        description = "compress files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ glib gobject-introspection ];
        testHaskellDepends = [ base doctest process ];
        description = "Generate Haskell bindings for GObject Introspection capable libraries";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib; inherit (pkgs) gobject-introspection;};
 
   "haskell-gi-base" = callPackage
···
        libraryHaskellDepends = [ base bytestring containers text ];
        libraryPkgconfigDepends = [ glib ];
        description = "Foundation for libraries generated by haskell-gi";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) glib;};
 
   "haskell-gi-overloading" = callPackage
···
          base directory haskell-lsp lens process text unix
        ];
        description = "A haskell package to build your own Language Server client";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "18s8g82v3h4b7maz6di43vfym6d3w16j4rbh5sjh4ps26yjnnfy4";
        libraryHaskellDepends = [ base containers ];
        description = "A simple menu system for Haskell programs";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "haskell-ml" = callPackage
···
          old-locale poppler template-haskell time zlib
        ];
        description = "Tool for presenting PDF-based presentations";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.mit;
        hydraPlatforms = lib.platforms.none;
        broken = true;
-     }) {libpostal = null;};
+     }) {inherit (pkgs) libpostal;};
 
   "haskell-postgis" = callPackage
     ({ mkDerivation, aeson, base, binary, bytestring, bytestring-lexing
···
        sha256 = "03d8c1gnxd923f3fqqw06w3ibnd20llfgd7s5jgkscc872i5ghz6";
        libraryHaskellDepends = [ base syb ];
        description = "A DSL for expressing natural deduction rules in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers lens linear mtl random sdl2 sdl2-ttf text vector
        ];
        description = "Snake game implemetation in Haskell using SDL2";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "haskell-spacegoo" = callPackage
···
        libraryToolDepends = [ happy ];
        description = "Support for manipulating Haskell source code";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "haskell-src-exts" = callPackage
···
        sha256 = "0fv533nac6dlawgffr1kvn4xpv63hdcb4wgyqbbg2s6dg9a2hw38";
        libraryHaskellDepends = [ base process ];
        description = "Simple TypeScript API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-quickcheck2
        ];
        description = "A scrabble library capturing the core game logic of scrabble";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "Elm to Haskell translation";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "haskelzinc" = callPackage
···
      , http-types, lens, monad-control, monad-logger, mtl, network, nqe
      , optparse-applicative, QuickCheck, random, rocksdb-haskell-jprupp
      , rocksdb-query, scotty, stm, string-conversions, text, time
-     , transformers, unliftio, unordered-containers, wai, warp, wreq
+     , transformers, unliftio, unordered-containers, vault, wai
+     , wai-extra, warp, wreq
      }:
      mkDerivation {
        pname = "haskoin-store";
-       version = "0.49.0";
-       sha256 = "126krbi29jxi978my3wg8cl2gqpr0xn0fmbz6fxqcbbcwi75fa30";
+       version = "0.51.0";
+       sha256 = "0wgf4j28f3g8anm6xpi0qn1as8lw7b6gwsp92xpc0f2yvv38gm4d";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          haskoin-core haskoin-node haskoin-store-data hedis http-types lens
          monad-control monad-logger mtl network nqe random
          rocksdb-haskell-jprupp rocksdb-query scotty stm string-conversions
-         text time transformers unliftio unordered-containers wai warp wreq
+         text time transformers unliftio unordered-containers vault wai
+         wai-extra warp wreq
        ];
        executableHaskellDepends = [
          aeson aeson-pretty base base16 bytes bytestring cereal conduit
···
          http-types lens monad-control monad-logger mtl network nqe
          optparse-applicative random rocksdb-haskell-jprupp rocksdb-query
          scotty stm string-conversions text time transformers unliftio
-         unordered-containers wai warp wreq
+         unordered-containers vault wai wai-extra warp wreq
        ];
        testHaskellDepends = [
          aeson aeson-pretty base base16 base64 bytes bytestring cereal
···
          http-types lens monad-control monad-logger mtl network nqe
          QuickCheck random rocksdb-haskell-jprupp rocksdb-query scotty stm
          string-conversions text time transformers unliftio
-         unordered-containers wai warp wreq
+         unordered-containers vault wai wai-extra warp wreq
        ];
        testToolDepends = [ hspec-discover ];
        description = "Storage and index for Bitcoin and Bitcoin Cash";
···
      }:
      mkDerivation {
        pname = "haskoin-store-data";
-       version = "0.49.0";
-       sha256 = "1v9zb3m1pvhbqm6pxzy2w8ipyxnv80gw8xlsr25fj0g2ylifkjb2";
+       version = "0.51.0";
+       sha256 = "12p8caxi77hqy420bix3h3a427m5hq4vwwwgf1g4cmava7c0p7wq";
        libraryHaskellDepends = [
          aeson base binary bytes bytestring cereal containers data-default
          deepseq hashable haskoin-core http-client http-types lens mtl
···
        sha256 = "1a92ahmphsr0dgj1jlp2cxpq5yy59b3avw3gzmv0jzrds41p3ic8";
        libraryHaskellDepends = [ base haste-compiler transformers ];
        description = "Create, navigate and modify the DOM tree with composable syntax, with the haste compiler";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
          base cmdargs process split tasty tasty-hunit tasty-quickcheck
        ];
        description = "Hath manipulates network blocks in CIDR notation";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "hats" = callPackage
···
          base directory ghc ghc-mod ghc-paths libhbb
        ];
        description = "Haskell Busy Bee, a backend for text editors";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          optparse-applicative parsec primitive text transformers vector
        ];
        description = "An optimizing Brainfuck compiler and evaluator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          array attoparsec base containers hlint hspec QuickCheck text
        ];
        description = "Chess library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base unix ];
        librarySystemDepends = [ bluetooth cwiid ];
        description = "Library to interface with the wiimote";
-       license = lib.licenses.gpl2;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       license = lib.licenses.gpl2Only;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {bluetooth = null; inherit (pkgs) cwiid;};
 
   "hdaemonize" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base directory process unix vty ];
        description = "a small display manager";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        benchmarkHaskellDepends = [ base criterion deepseq primitive ];
        description = "Haskell implementation of High Dynamic Range (HDR) Histograms";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "headroom";
-       version = "0.4.0.0";
-       sha256 = "1xjm84k6wpi7b5w9pjf1siwy4c59rfsgmrg5cbjhznrv8mzvpygw";
+       version = "0.4.1.0";
+       sha256 = "1f98x1qm567wsa58nyavj7lfi2fmm6zrmjc0cwg0dyhvi63n9qp0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          vector
        ];
        description = "Find and annotate ITDs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          pipes pipes-text safe text turtle vector
        ];
        description = "Find and annotate ITDs with assembly or read pair joining";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "hedgehog";
-       version = "1.0.4";
-       sha256 = "16j60k0xg74861b5a5n9brx1pgwa2yg76v8q8drmhlx46ga5fwdz";
-       libraryHaskellDepends = [
-         ansi-terminal async base bytestring concurrent-output containers
-         deepseq directory erf exceptions lifted-async mmorph monad-control
-         mtl pretty-show primitive random resourcet stm template-haskell
-         text time transformers transformers-base wl-pprint-annotated
-       ];
-       testHaskellDepends = [
-         base containers mmorph mtl pretty-show text transformers
-       ];
-       description = "Release with confidence";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "hedgehog_1_0_5" = callPackage
-    ({ mkDerivation, ansi-terminal, async, base, bytestring
-     , concurrent-output, containers, deepseq, directory, erf
-     , exceptions, lifted-async, mmorph, monad-control, mtl, pretty-show
-     , primitive, random, resourcet, stm, template-haskell, text, time
-     , transformers, transformers-base, wl-pprint-annotated
-     }:
-     mkDerivation {
-       pname = "hedgehog";
        version = "1.0.5";
        sha256 = "1qsqs8lmxa3wmw228cwi98vvvh9hqbc9d43i1sy2c9igw9xlhfi6";
        libraryHaskellDepends = [
···
        ];
        description = "Release with confidence";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hedgehog-checkers" = callPackage
···
      }:
      mkDerivation {
        pname = "hedgehog-classes";
-       version = "0.2.5.1";
-       sha256 = "0gyq9dr25sz14yw5x8jlb73l2hzv92r1c6cfan7lygq7z0yaiw6b";
+       version = "0.2.5.2";
+       sha256 = "0h9givw1l83l8z59w6y1rjcnply297b2iag3qhy1rmcjyq3d6m0m";
        libraryHaskellDepends = [
          aeson base binary comonad containers hedgehog pretty-show primitive
          semirings silently transformers vector wl-pprint-annotated
···
          base containers Lucu mtl network regex-posix
        ];
        description = "Simple, distributed, anonymous data sharing network";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          mtl optparse-applicative semigroups split vty
        ];
        description = "A command-line manager for delicious kitchen recipes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }) {};
 
   "hexpat-streamparser" = callPackage
-    ({ mkDerivation, base, bytestring, hexpat, List, mtl
+    ({ mkDerivation, base, bytestring, hexpat, hspec, List, mtl
      , parser-combinators, text, transformers
      }:
      mkDerivation {
        pname = "hexpat-streamparser";
-       version = "0.0.2";
-       sha256 = "11g78dkr9dp4kgz8zmckgq66587qahdhxyhcn03ajr0b07ab27z3";
+       version = "0.1.1";
+       sha256 = "13wn89aw2fqhirrdshmdh1xqhihx4h5pgmp4x9lspy2jfrpga9f5";
        libraryHaskellDepends = [
          base bytestring hexpat List mtl parser-combinators text
          transformers
        ];
+       testHaskellDepends = [ base hexpat hspec ];
        license = lib.licenses.bsd3;
      }) {};
 
···
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [ base directory hspec ];
        description = "Unofficial bindings for GRIB API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {grib_api = null;};
···
      }:
      mkDerivation {
        pname = "hie-bios";
-       version = "0.7.4";
-       sha256 = "05ad47ll6vxi7say4f7zf13npcjpqbwb42pqs2bmxslif6rl9sdh";
+       version = "0.7.5";
+       sha256 = "0k8g1qkxqqa0ld15s82mvkgsm4icm65dkabsv8sd2mkrhck0lfw8";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          filepath hmatrix lens optparse-generic safe text text-show vector
        ];
        description = "Hierarchical spectral clustering of a graph";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring directory gtk HTTP http-conduit network temporary
        ];
        description = "Simple gtk2hs image viewer. Point it at an image and fire away.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "hint";
-       version = "0.9.0.3";
-       sha256 = "0kp2hngmk2sf4ariv02rgrrd190zzb7nlk0pj8fq7rsckcxc87ra";
+       version = "0.9.0.4";
+       sha256 = "0hdhnkldscq3hp5xn5ns79f6cd6bw6ih6k550d5c38sdqypx73ns";
        libraryHaskellDepends = [
          base directory exceptions filepath ghc ghc-boot ghc-paths random
          temporary transformers unix
···
          tasty-quickcheck text transformers unordered-containers
        ];
        description = "Majority Judgment";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hjugement-cli" = callPackage
···
          time transformers unix unordered-containers
        ];
        description = "Majority Judgment and Helios-C command line tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers
        ];
        description = "A cryptographic protocol for the Majority Judgment";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hkd" = callPackage
···
          simple-cmd-args typed-process xdg-basedir
        ];
        description = "Simple Hackage release workflow for package maintainers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hkt" = callPackage
···
          utility-ht wizards
        ];
        description = "Command-line interface for the hledger accounting system";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
          wai-extra warp
        ];
        description = "Web API server for the hledger accounting tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base hledger-lib text time ];
        description = "Compares the transactions in two ledger files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hledger-flow" = callPackage
···
          base containers foldl HUnit path path-io stm text turtle
        ];
        description = "An hledger workflow focusing on automated statement import and classification";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hledger-iadd" = callPackage
···
      }:
      mkDerivation {
        pname = "hledger-iadd";
-       version = "1.3.13";
-       sha256 = "19i5cr11zm4d27x2gddxy4993jgmf4ghgpvx8fw4acadwbvlnjvg";
+       version = "1.3.14";
+       sha256 = "0kcw8yp9g6cj6amc4rh8iwzd4zh5v68ns8sf5rv4hfa4xj928iy5";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          unordered-containers utf8-string
        ];
        description = "A reusable library providing the core functionality of hledger";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hledger-makeitso" = callPackage
···
          base containers foldl HUnit stm text turtle
        ];
        description = "An hledger workflow focusing on automated statement import and classification";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hledger-stockquotes" = callPackage
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
   "karver" = callPackage
        testHaskellDepends = [ base hlint ];
   "karver" = callPackage
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
   "karver" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hlint_3_3" = callPackage
+  "karver" = callPackage
+  "karver" = callPackage
+     , filepath, filepattern, ghc-lib-parser, ghc-lib-parser-ex
+     , hscolour, process, refact, text, transformers, uniplate
+     , unordered-containers, utf8-string, vector, yaml
+     }:
+     mkDerivation {
+  "karver" = callPackage
+       version = "3.3";
+       sha256 = "1cbmaw3ikni2fqkzyngc6qwg8k6ighy48979msfs97qg0kxjmbbd";
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+  "karver" = callPackage
+         data-default directory extra file-embed filepath filepattern
+         ghc-lib-parser ghc-lib-parser-ex hscolour process refact text
+  "karver" = callPackage
+       ];
+       executableHaskellDepends = [ base ];
+  "karver" = callPackage
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "karver" = callPackage
   "karver" = callPackage
      mkDerivation {
···
   "karver" = callPackage
        version = "1.0.0.0";
   "karver" = callPackage
+       revision = "1";
+       editedCabalFile = "0gch9wkz1h4g06xc48jhvs06jji9d0npa2zrj2gv1cbf6hjs0s92";
        libraryHaskellDepends = [
   "karver" = callPackage
   "karver" = callPackage
···
        license = lib.licenses.asl20;
      }) {};
 
+  "hls-retrie-plugin_1_0_0_1" = callPackage
+  "karver" = callPackage
+  "karver" = callPackage
+  "karver" = callPackage
+     }:
+     mkDerivation {
+  "karver" = callPackage
+       version = "1.0.0.1";
+       sha256 = "0vshnnh8x2n0kn7hh04z00mkdmw3130b3mmfrm3z4ygia852hzmq";
+       libraryHaskellDepends = [
+  "karver" = callPackage
+  "karver" = callPackage
+         transformers unordered-containers
+       ];
+  "karver" = callPackage
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "karver" = callPackage
   "karver" = callPackage
   "karver" = callPackage
···
   "karver" = callPackage
        librarySystemDepends = [ glpk ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) glpk;};
 
   "karver" = callPackage
···
        ];
        libraryPkgconfigDepends = [ gsl ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) gsl;};
 
   "karver" = callPackage
···
        isExecutable = true;
        libraryHaskellDepends = [ base hmatrix ];
   "karver" = callPackage
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "karver" = callPackage
   "karver" = callPackage
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "karver" = callPackage
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "karver" = callPackage
        version = "0.4";
   "karver" = callPackage
+       revision = "1";
+       editedCabalFile = "10dg0s6nrvb93ksyzgappmr28av4k204kmc8lb3vc2ribqhpb177";
        libraryHaskellDepends = [
   "karver" = callPackage
   "karver" = callPackage
···
   "karver" = callPackage
   "karver" = callPackage
   "karver" = callPackage
-  "karver" = callPackage
-  "karver" = callPackage
+     , tasty-discover, tasty-golden, tasty-hspec, tasty-hunit
+     , tasty-quickcheck, temporary, text, time, unix
+     , unordered-containers, vector
      }:
      mkDerivation {
   "karver" = callPackage
-       version = "0.4.1.0";
-  "karver" = callPackage
+       version = "0.4.2.0";
+       sha256 = "02i7vxhpaqwyjvd6w2raxjz7r0xxs37x5b6pq9rw6l1l0k18nx5i";
        libraryHaskellDepends = [
   "karver" = callPackage
   "karver" = callPackage
···
   "karver" = callPackage
   "karver" = callPackage
        ];
+       testToolDepends = [ tasty-discover ];
   "karver" = callPackage
        license = lib.licenses.asl20;
      }) {};
···
      }:
      mkDerivation {
   "karver" = callPackage
-       version = "0.4.1.0";
-  "karver" = callPackage
+       version = "0.4.2.0";
+       sha256 = "17v785dql4rl2yn1qdagvnyx8y9r3bd02npg51mfqhl49knd92fr";
        libraryHaskellDepends = [
   "karver" = callPackage
   "karver" = callPackage
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
   "karver" = callPackage
        license = "GPL";
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "karver" = callPackage
···
      }:
      mkDerivation {
   "karver" = callPackage
-       version = "0.1.2.1";
-  "karver" = callPackage
+       version = "0.2.0.0";
+       sha256 = "17vr2g8jv71k2bwv5x973xjjxacr5br4xlngxjpzbq6xk9n37laf";
        setupHaskellDepends = [ base Cabal directory ];
   "karver" = callPackage
   "karver" = callPackage
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
   "karver" = callPackage
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.agpl3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "karver" = callPackage
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.agpl3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "karver" = callPackage
···
        ];
   "karver" = callPackage
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "karver" = callPackage
···
        ];
   "karver" = callPackage
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
      }) {};
 
   "karver" = callPackage
···
        ];
        executableToolDepends = [ alex happy ];
   "karver" = callPackage
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          time transformers
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "karver" = callPackage
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "karver" = callPackage
        libraryHaskellDepends = [ base vector ];
   "karver" = callPackage
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
   "karver" = callPackage
        ];
   "karver" = callPackage
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hs-tags" = callPackage
+    ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
+     , mtl, process, strict
+     }:
+     mkDerivation {
+       pname = "hs-tags";
+       version = "0.1.5";
+       sha256 = "0gy894sr2557a6pmvi99dkn03990r43ycxknryxym62z54bz1q8f";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base Cabal containers directory filepath ghc mtl process strict
+       ];
+       description = "Create tag files (ctags and etags) for Haskell code";
+       license = lib.licenses.mit;
+     }) {};
+
   "hs-twitter" = callPackage
     ({ mkDerivation, base, HTTP, json, mime, network, old-locale
      , old-time, random, utf8-string
···
      }:
      mkDerivation {
        pname = "hs-watchman";
-       version = "0.0.0.3";
-       sha256 = "1cqhl4gydk8i003p49cy7dcvhw0rgrc4j2l54271y4cqgkd8pkfi";
+       version = "0.0.1.0";
+       sha256 = "1550rfmvqgm1ak9n9kj1mv1vn7rfdangk8g9a40qwry5s4b0aihi";
        libraryHaskellDepends = [
          async base binary bytestring containers filepath network process
          temporary
···
        libraryHaskellDepends = [ base lens ];
        testHaskellDepends = [ base HUnit lens ];
        description = "PID control loop";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "hsSqlite3" = callPackage
···
        enableSeparateDataOutput = true;
        executableHaskellDepends = [ base Hclip HTTP process unix ];
        description = "(ab)Use Google Translate as a speech synthesiser";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers vector
        ];
        description = "Haskell SuperCollider";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          natural-transformation profunctors text unordered-containers vector
        ];
        description = "Describe schemas for your Haskell data types";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "hschema-aeson" = callPackage
···
          scientific text time unordered-containers vector
        ];
        description = "Describe schemas for your Haskell data types";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "hschema-prettyprinter" = callPackage
···
          vector
        ];
        description = "Describe schemas for your Haskell data types";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "hschema-quickcheck" = callPackage
···
          quickcheck-instances text unordered-containers vector
        ];
        description = "Describe schemas for your Haskell data types";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "hsclock" = callPackage
···
        libraryHaskellDepends = [ base containers network ];
        librarySystemDepends = [ adns ];
        description = "Asynchronous DNS Resolver";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        maintainers = with lib.maintainers; [ peti ];
      }) {inherit (pkgs) adns;};
 
···
        sha256 = "1j7pny0yjpx5qw2d9br723dyic4v09k1qbvrham57p9qxn9m5b0q";
        libraryHaskellDepends = [ base containers language-puppet text ];
        description = "A small and ugly library that emulates the output of the puppet facter program";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "hslua";
-       version = "1.2.0";
-       sha256 = "0a295zqpbrv8a2hw7msz5p7brlswag16sg08dyz399ij6b7q5x0h";
-       configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ];
-       libraryHaskellDepends = [
-         base bytestring containers exceptions mtl text
-       ];
-       librarySystemDepends = [ lua5_3 ];
-       testHaskellDepends = [
-         base bytestring containers exceptions mtl QuickCheck
-         quickcheck-instances tasty tasty-hunit tasty-quickcheck text
-       ];
-       description = "Bindings to Lua, an embeddable scripting language";
-       license = lib.licenses.mit;
-     }) {inherit (pkgs) lua5_3;};
-
-  "hslua_1_3_0_1" = callPackage
-    ({ mkDerivation, base, bytestring, containers, exceptions, lua5_3
-     , mtl, QuickCheck, quickcheck-instances, tasty, tasty-hunit
-     , tasty-quickcheck, text
-     }:
-     mkDerivation {
-       pname = "hslua";
        version = "1.3.0.1";
        sha256 = "1mz8zk13dhgaf24hmmjqnn5hcln96iw73mcjwjilag8388wq72k7";
        configureFlags = [ "-fsystem-lua" "-f-use-pkgconfig" ];
···
        ];
        description = "Bindings to Lua, an embeddable scripting language";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) lua5_3;};
 
   "hslua-aeson" = callPackage
···
        libraryHaskellDepends = [ base colour ];
        testHaskellDepends = [ aeson base bytestring colour containers ];
        description = "HSLuv conversion utility";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {GraphicsMagick = null; inherit (pkgs) bzip2; freetype2 = null; 
-         jasper = null; inherit (pkgs) lcms; inherit (pkgs) libjpeg; 
-         inherit (pkgs) libpng; inherit (pkgs) libxml2; tiff = null; 
-         wmflite = null; inherit (pkgs) zlib;};
+         inherit (pkgs) jasper; inherit (pkgs) lcms; 
+         inherit (pkgs) libjpeg; inherit (pkgs) libpng; 
+         inherit (pkgs) libxml2; tiff = null; wmflite = null; 
+         inherit (pkgs) zlib;};
 
   "hsmisc" = callPackage
     ({ mkDerivation, base, containers, HUnit, mtl, old-locale, parsec
···
        librarySystemDepends = [ libsndfile ];
        libraryToolDepends = [ c2hs ];
        description = "Haskell bindings for libsndfile";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) libsndfile;};
 
   "hsndfile-storablevector" = callPackage
···
        sha256 = "1n7jw14pnixiv1z50lb7yzwyyl3yd3gdfg5w0gx0m52pnmqiav9z";
        libraryHaskellDepends = [ base hsndfile storablevector ];
        description = "Haskell bindings for libsndfile (Data.StorableVector interface)";
-       license = lib.licenses.lgpl2;
+       license = lib.licenses.lgpl2Only;
      }) {};
 
   "hsndfile-vector" = callPackage
···
        sha256 = "1598bf87llbiri1qh8zirhbsd94c9vhd41lf9vialqrykbmi3zig";
        libraryHaskellDepends = [ base hsndfile vector ];
        description = "Haskell bindings for libsndfile (Data.Vector interface)";
-       license = lib.licenses.lgpl2;
+       license = lib.licenses.lgpl2Only;
      }) {};
 
   "hsnock" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "hspec-golden-aeson_0_9_0_0" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
+     , filepath, hspec, hspec-core, HUnit, QuickCheck
+     , quickcheck-arbitrary-adt, random, silently, transformers
+     }:
+     mkDerivation {
+       pname = "hspec-golden-aeson";
+       version = "0.9.0.0";
+       sha256 = "1mj516xn6an2pkygfzm2418hbvaf8yvgwgvmpgpwrxqss87m3c84";
+       libraryHaskellDepends = [
+         aeson aeson-pretty base bytestring directory filepath hspec HUnit
+         QuickCheck quickcheck-arbitrary-adt random transformers
+       ];
+       testHaskellDepends = [
+         aeson base directory hspec hspec-core QuickCheck
+         quickcheck-arbitrary-adt silently transformers
+       ];
+       description = "Use tests to monitor changes in Aeson serialization";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "hspec-hashable" = callPackage
     ({ mkDerivation, base, hashable, hspec, hspec-core, QuickCheck
      , silently
···
      }:
      mkDerivation {
        pname = "hspec-wai";
-       version = "0.10.1";
-       sha256 = "05jv0cz8r8bf63ma5byjb2gkj9vwgnls4n9mks99qc525n055ckz";
+       version = "0.11.0";
+       sha256 = "0fk23vrs5apjy11z47mply2kay3n193gnyrbb9fkpwvmxyhxlp0x";
        libraryHaskellDepends = [
          base base-compat bytestring case-insensitive hspec-core
          hspec-expectations http-types QuickCheck text transformers wai
···
      }:
      mkDerivation {
        pname = "hspec-wai-json";
-       version = "0.10.1";
-       sha256 = "04mpqij446ki5l6xwi3bjmlf3ggjia2nzv8j62mdy6ick96dqwk6";
-       libraryHaskellDepends = [
-         aeson aeson-qq base bytestring case-insensitive hspec-wai
-         template-haskell
-       ];
-       testHaskellDepends = [ base hspec hspec-wai ];
-       description = "Testing JSON APIs with hspec-wai";
-       license = lib.licenses.mit;
-     }) {};
-
-  "hspec-wai-json_0_11_0" = callPackage
-    ({ mkDerivation, aeson, aeson-qq, base, bytestring
-     , case-insensitive, hspec, hspec-wai, template-haskell
-     }:
-     mkDerivation {
-       pname = "hspec-wai-json";
        version = "0.11.0";
        sha256 = "0cra0jfb8j9g5447lij0d8nnbqv06f5i4j51h14vjw0n7zb4i8y4";
        libraryHaskellDepends = [
···
        testHaskellDepends = [ base hspec hspec-wai ];
        description = "Testing JSON APIs with hspec-wai";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hspec-webdriver" = callPackage
···
        sha256 = "0y45jizkf2kfj3yjjkq96kavkfp74vf5dyyjvi9pj3kshf8sx8il";
        libraryHaskellDepends = [ base hspec QuickCheckVariant ];
        description = "Spec for testing properties for variant types";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-hunit
        ];
        description = "The Haskell Stream Processor command line utility";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, c2hs, directory, parsec, random, unix }:
      mkDerivation {
        pname = "hsshellscript";
-       version = "3.4.5";
-       sha256 = "0d66gsm7s2j4f60cjca6fsddg4i1m3l6rcyq29ywskifhfaxbgvx";
-       libraryHaskellDepends = [ base directory parsec random unix ];
-       libraryToolDepends = [ c2hs ];
-       description = "Haskell for Unix shell scripting tasks";
-       license = "LGPL";
-     }) {};
-
-  "hsshellscript_3_5_0" = callPackage
-    ({ mkDerivation, base, c2hs, directory, parsec, random, unix }:
-     mkDerivation {
-       pname = "hsshellscript";
        version = "3.5.0";
        sha256 = "1gdj6b3b0b71jcmxd5wc42gs9v5s37jqd1jwryif84qbiq8rskgr";
        libraryHaskellDepends = [ base directory parsec random unix ];
        libraryToolDepends = [ c2hs ];
        description = "Haskell for Unix shell scripting tasks";
        license = "LGPL";
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "hssourceinfo" = callPackage
···
          test-framework-quickcheck2
        ];
        description = "Distributed instant messaging over Tor";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
        executableHaskellDepends = [ base process ];
        testHaskellDepends = [ async base ];
        description = "A Tox protocol implementation in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers QuickCheck tasty tasty-quickcheck text transformers
        ];
        description = "Equiprobable draw from publicly verifiable random data";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "htlset" = callPackage
···
          base bytestring doctest doctest-discover hlint QuickCheck
        ];
        description = "Determine character encoding of HTML documents/fragments";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          htsn-common hxt MissingH network process tasty tasty-hunit unix
        ];
        description = "Parse XML files from The Sports Network feed";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          ansi-terminal base hslogger transformers
        ];
        description = "Display/logging facilities used by both htsn and htsn-import";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "htsn-import" = callPackage
···
          split tasty tasty-hunit time transformers tuple
        ];
        description = "Import XML files from The Sports Network into an RDBMS";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, attoparsec, attoparsec-iso8601, base, base-compat
      , bytestring, containers, cookie, hashable, hspec, hspec-discover
      , http-types, HUnit, nats, QuickCheck, quickcheck-instances, tagged
-     , text, time-compat, unordered-containers, uuid-types
+     , text, time-compat, transformers, unordered-containers, uuid-types
      }:
      mkDerivation {
        pname = "http-api-data";
-       version = "0.4.1.1";
-       sha256 = "1s93m2vh4c1p073xasvknnj3czbf8xsyg48kyznr4jwfhzi17anh";
-       revision = "1";
-       editedCabalFile = "1dshqb1140nj4h8d750s97gmzb2rk0ppr1rakvqxy1r79mg3m2wr";
+       version = "0.4.2";
+       sha256 = "0xzfvxxh33ivlnrnzmm19cni3jgb5ph18n9hykkw3d6l3rhwzcnl";
        libraryHaskellDepends = [
          attoparsec attoparsec-iso8601 base base-compat bytestring
          containers cookie hashable http-types tagged text time-compat
-         unordered-containers uuid-types
+         transformers unordered-containers uuid-types
        ];
        testHaskellDepends = [
          base base-compat bytestring cookie hspec HUnit nats QuickCheck
···
      }) {};
 
   "http-link-header" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring
-     , bytestring-conversion, criterion, directory, errors, hspec
-     , hspec-attoparsec, http-api-data, network-uri, QuickCheck, text
-     , transformers
-     }:
-     mkDerivation {
-       pname = "http-link-header";
-       version = "1.0.3.1";
-       sha256 = "0b9a3kax6zvn8aaflys63lanqan65hsv0dr8vwhbpbhyvxrxn9ns";
-       libraryHaskellDepends = [
-         attoparsec base bytestring bytestring-conversion errors
-         http-api-data network-uri text
-       ];
-       testHaskellDepends = [
-         base hspec hspec-attoparsec QuickCheck text
-       ];
-       benchmarkHaskellDepends = [
-         base criterion directory network-uri text transformers
-       ];
-       description = "A parser and writer for the HTTP Link header as specified in RFC 5988 \"Web Linking\"";
-       license = lib.licenses.publicDomain;
-     }) {};
-
-  "http-link-header_1_2_0" = callPackage
     ({ mkDerivation, attoparsec, base, bytestring, criterion, directory
      , errors, hspec, hspec-attoparsec, http-api-data, network-uri
      , QuickCheck, text, transformers
···
        ];
        description = "A parser and writer for the HTTP Link header per RFC 5988";
        license = lib.licenses.publicDomain;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "http-listen" = callPackage
···
      }:
      mkDerivation {
        pname = "http2";
-       version = "2.0.5";
-       sha256 = "1rg6dnkx2yxcdp87r1vdpyxacqv7jgxiq3bb1hjz45v5jk1xj676";
-       revision = "1";
-       editedCabalFile = "0xxi7gcldh3fvnh98khw9f2vm5w85sakbb6165s779nkvq7p8ak2";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         array base bytestring case-insensitive containers http-types
-         network network-byte-order psqueues stm time-manager
-       ];
-       testHaskellDepends = [
-         aeson aeson-pretty array base base16-bytestring bytestring
-         case-insensitive containers directory doctest filepath Glob hspec
-         http-types network network-byte-order psqueues stm text
-         time-manager unordered-containers vector
-       ];
-       benchmarkHaskellDepends = [
-         array base bytestring case-insensitive containers gauge heaps
-         mwc-random network-byte-order psqueues stm
-       ];
-       description = "HTTP/2 library";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "http2_2_0_6" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, array, base
-     , base16-bytestring, bytestring, case-insensitive, containers
-     , directory, doctest, filepath, gauge, Glob, heaps, hspec
-     , http-types, mwc-random, network, network-byte-order, psqueues
-     , stm, text, time-manager, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "http2";
        version = "2.0.6";
        sha256 = "17m1avrppiz8i6qwjlgg77ha88sx8f8vvfa57z369aszhld6nx9a";
        isLibrary = true;
···
        ];
        description = "HTTP/2 library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "http2-client" = callPackage
···
        ];
        description = "Encoders based on `proto3-wire` for gRPC over HTTP2";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "http2-grpc-types" = callPackage
···
          base directory filepath functor-infix text
        ];
        description = "Low-level (i.e. XML) access to HTTPS Everywhere rulesets.";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testSystemDepends = [ tvm_runtime ];
        description = "Bindings for TVM machine learning framework";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {tvm_runtime = null;};
···
        ];
        executableHaskellDepends = [ base directory network-uri ];
        description = "Haskell URL resolver";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0g2h5is0gbr43fn8pbfj2nzh4wlgx6kjayq4lcnbr10z0j3vpqpv";
        libraryHaskellDepends = [ base hvega text ];
        description = "Theme for hvega";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "hw-aeson" = callPackage
···
        pname = "hw-aeson";
        version = "0.1.1.0";
        sha256 = "0d50yghgnxhynbm6w5kgkhgr8xgnghr8g1xn7zf0p9ax8dxkdy00";
-       revision = "1";
-       editedCabalFile = "0akwsfw024i8i8w8y1h2wdp9vqd7ws5jfyb5v5d9yckjk3sa2wn1";
+       revision = "2";
+       editedCabalFile = "062g7zwbp9csgcbpbbyg6ckb8zhkx1kqk5dsms36fmx95dq4zl5j";
        libraryHaskellDepends = [ aeson base text ];
        testHaskellDepends = [
          aeson base doctest doctest-discover hedgehog hspec
···
        pname = "hw-balancedparens";
        version = "0.4.1.1";
        sha256 = "16v36fj5aawnx6glarzljl3yb93zkn06ij5cg40zba5rp8jhpg7z";
+       revision = "1";
+       editedCabalFile = "0jh79y6wl0ml4fc59icbg35nvcz7zi0fqbbg0p6y7nkxnhv4yc0j";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-bits";
        version = "0.7.2.1";
        sha256 = "18l9r0yhddkzgbc2vvk0qr9brb5ih25zjfga3bddb5j8gpaaq65q";
-       revision = "1";
-       editedCabalFile = "14y67p3rsj97rzlh2cw7iy04gb6cfa977bjbr35vgkav0skbigbn";
+       revision = "2";
+       editedCabalFile = "1almm4nl56gf99wys1kzalqcz0dkaih0pgxsyqv4q1j1w3ggfmfq";
        libraryHaskellDepends = [
          base bitvec bytestring deepseq hw-int hw-prim hw-string-parse
          vector
···
        pname = "hw-conduit";
        version = "0.2.1.0";
        sha256 = "1xnkkpqcgyii7f16jjh2k2qh4ydpsff5q2xnggyg4jf7m69yrih2";
+       revision = "1";
+       editedCabalFile = "1rmdwb4a7ax9yadj4xv63n582vsmk84h03qkr6npj9b9gw4qw6i3";
        libraryHaskellDepends = [
          array base bytestring conduit conduit-combinators time transformers
          unliftio-core word8
···
        pname = "hw-diagnostics";
        version = "0.0.1.0";
        sha256 = "111g54c5bhgjii6vbyb116bg3dxywa9l693r8xjjrxpamzvi0avj";
+       revision = "1";
+       editedCabalFile = "04qpkr54wkb99hdfzk6gxhi6ak5lc564jzab1cc7675s7lsj1nji";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base doctest doctest-discover ];
        testToolDepends = [ doctest-discover ];
···
        pname = "hw-dsv";
        version = "0.4.1.0";
        sha256 = "1wv0yg662c3bq4kpgfqfjks59v17i5h3v3mils1qpxn4c57jr3s8";
-       revision = "2";
-       editedCabalFile = "1l7aww6nci05ns7hnk46r20as3xy1j0s5fxsrb5w0x9y2kwvqj61";
+       revision = "3";
+       editedCabalFile = "066vlpy361f6r5k74b3myi6lc2g8lxm7cz23i5hhyi319yjp1jxh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-dump";
        version = "0.1.1.0";
        sha256 = "14ya18i3xvay5xn8j20b06msqyd49h34w526k1x1fxdp0i2l3rwr";
-       revision = "2";
-       editedCabalFile = "0p6cbijds7vc8bx9rb8s8bwr9dp4qc91idmd64llgz06d9kmvkcs";
+       revision = "3";
+       editedCabalFile = "16wpfpmxp3r1nrzfmcihzfcfhaiwrlq7x7z9kf68aib5zqmdxzwf";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-eliasfano";
        version = "0.1.2.0";
        sha256 = "1wqpzznmz6bl88wzhrfcbgi49dw7w7i0p92hyc0m58nanqm1zgnj";
-       revision = "2";
-       editedCabalFile = "0l7h7pr6gpq0xnp4w003q3dxw7pmv2d6kpx2iqfc3nzzpa562ivv";
+       revision = "3";
+       editedCabalFile = "1g6w3j4azxvikiycjnb4rjsaw8pyica3m17yhsrxq24pms4n35pl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-excess";
        version = "0.2.3.0";
        sha256 = "0xiyf3xyg6f4kgkils9ycx6q0qcsbd6rw4m9lizw9295mnp05s3g";
+       revision = "1";
+       editedCabalFile = "0qq8svkn9365vdbb0y3y4m2pdklsrf6z3a1m0kyfmbr0vphza369";
        libraryHaskellDepends = [
          base hw-bits hw-prim hw-rankselect-base safe vector
        ];
···
        pname = "hw-fingertree";
        version = "0.1.2.0";
        sha256 = "0b1aff5aa9ifapyf2qvqggxfm36x5w7l7c37bfy9qdll264pdh0i";
+       revision = "1";
+       editedCabalFile = "0hg9hnga0d15a5md67q7xl53kgp34hwvl4aw9s8xkjm4fs7a54z9";
        libraryHaskellDepends = [ base deepseq hw-prim ];
        testHaskellDepends = [
          base deepseq doctest doctest-discover hedgehog hspec
···
        pname = "hw-fingertree-strict";
        version = "0.1.2.0";
        sha256 = "1zhh694m8hbin7059ys8c6sqjvyfsazcsp0jxqg59w5ypqjznzca";
+       revision = "1";
+       editedCabalFile = "0vr8xqvwihg3j83bqfhcqlnlpdq7k2v6kkx1xly7fdjw2hcwgkhl";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base doctest doctest-discover hedgehog hspec HUnit
···
        pname = "hw-hedgehog";
        version = "0.1.1.0";
        sha256 = "0a2pic2h983kdkai68wabclzwjbk5i9vz229jlwvs0hyw6b0mzz9";
+       revision = "1";
+       editedCabalFile = "1fwgxwbfz6yfj6xfl9471q7fpsckm2wvpb8wxwb32c3x5122ly5v";
        libraryHaskellDepends = [ base hedgehog vector ];
        testHaskellDepends = [ base doctest doctest-discover ];
        testToolDepends = [ doctest-discover ];
···
        pname = "hw-hspec-hedgehog";
        version = "0.1.1.0";
        sha256 = "04r30hb4664yciwfl3kyx0xn6sqc6abwhavb4wxiaas8b4px9kyn";
+       revision = "2";
+       editedCabalFile = "16v3dcpm51m8g2va85jfnbxqyc6dds2nazyd31080fa4804a90wz";
        libraryHaskellDepends = [
          base call-stack hedgehog hspec HUnit transformers
        ];
···
        pname = "hw-int";
        version = "0.0.2.0";
        sha256 = "13ifa28b12hiibhmwas5hn3dmmiz2rihlc837hhii0z1ng03s360";
+       revision = "1";
+       editedCabalFile = "13vc1hvyil8qql2d6ryi2m4a6snhm2v8vghh8s9hr4qx6dzh4irv";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base doctest doctest-discover hedgehog hspec hw-hedgehog
···
        pname = "hw-ip";
        version = "2.4.2.0";
        sha256 = "1bvh4fkg1ffr3y8wink62rgkynlcgjhmra7a4w01h1dmw1vb2vfx";
-       revision = "1";
-       editedCabalFile = "19jbgqsmc71apmr6z0n0a2hgfhv9r0bsqa2x55r8grpyr91blpmw";
+       revision = "2";
+       editedCabalFile = "19x9s7hdch768annsss3paz7sqxqr3flz01wky1vijf18abakk3l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-json";
        version = "1.3.2.2";
        sha256 = "03h5zv94ndsz4vh0jql8rg8pl95rbf8xkyzvr3r55i3kpmb85sbg";
+       revision = "1";
+       editedCabalFile = "1ivm89r5kqflpsayl941xq0q3izjklakfqzr2f6nl78wpa3ykkiq";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-json-lens";
        version = "0.2.1.0";
        sha256 = "1v3ws69pyrw5ja00r326kqlq6hd7r5np119fk2la7f74aqhajjf6";
-       revision = "1";
-       editedCabalFile = "1gxqds8889dzkfncnlncjb7avw4zm7dzj3063mq4rsb05gyrplhz";
+       revision = "2";
+       editedCabalFile = "0n6cxjr2r7w2i735c1dz2cflgvbgcdspzzzg8w3knhl1kgiyi2ih";
        libraryHaskellDepends = [
          aeson base bytestring containers hw-json lens scientific text word8
        ];
···
        pname = "hw-json-simd";
        version = "0.1.1.0";
        sha256 = "0bpfyx2bd7pcr8y8bfahcdm30bznqixfawraq3xzy476vy9ppa9n";
-       revision = "1";
-       editedCabalFile = "047s5clxvi3l9x80lnf7nrv7myxnvqmh8y7syb2ryv3m549lyv2q";
+       revision = "2";
+       editedCabalFile = "1amvva0pqidwcjdd4snywm8m614ygc2zn6036fh4v1ps20pyq2l9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring hw-prim lens vector ];
···
        pname = "hw-json-simple-cursor";
        version = "0.1.1.0";
        sha256 = "1kwxnqsa2mkw5sa8rc9rixjm6f75lyjdaz7f67yyhwls5v4315bl";
-       revision = "3";
-       editedCabalFile = "0zmq1gb9znb84d9igppww6295glnhg5b6xlgadr435cddp5zmhpx";
+       revision = "4";
+       editedCabalFile = "0mpjnc99yi474h9qvgg48kjcl3hxxhl58gar72bzcf5rx12pyn9w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-json-standard-cursor";
        version = "0.2.3.1";
        sha256 = "1mpsspp6ba2zqv38a0rcv93mbwb1rb8snmxklf32g02djj8b4vir";
-       revision = "1";
-       editedCabalFile = "0gdvwhj2jmd8dm1yi3kzs0lyw5r4bk7c50s21z1600v36bmzpdm1";
+       revision = "2";
+       editedCabalFile = "1qc0nxcahlc0zn4ycfxhhj1qplxc0r8qh20zmq4m2n7wyghlb3hc";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-mquery";
        version = "0.2.1.0";
        sha256 = "1qhd8jcwffr57mjraw0g3xj9kb0jd75ybqaj1sbxw31lc2hr9w9j";
+       revision = "1";
+       editedCabalFile = "15jji7wzx2ws58nqd965r6bycdgl09qlp4rrcd81y57mq24h27mb";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ ansi-wl-pprint base dlist lens ];
···
        pname = "hw-packed-vector";
        version = "0.2.1.0";
        sha256 = "13hly2yzx6kx4j56iksgj4i3wmvg7rmxq57d0g87lmybzhha9q38";
-       revision = "2";
-       editedCabalFile = "0hlmi9w5z7j9ycqjf5avx3b09yglcbx8krypv274j2qrm5fzypr4";
+       revision = "3";
+       editedCabalFile = "1zn1aqkyzsa0mk9b7igvnmxas0907h9if96c9km1gjrndnjvxkyd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-parser";
        version = "0.1.1.0";
        sha256 = "1zsbw725mw3fn4814qricqanbvx1kgbnqvgwijqgfv8jz7yf5gxa";
+       revision = "1";
+       editedCabalFile = "0yh06ypgvag83h32czz8dpsrc9a4w0pqy3m4jvds8sbgnj45havs";
        libraryHaskellDepends = [
          attoparsec base bytestring hw-prim text
        ];
···
        pname = "hw-prim";
        version = "0.6.3.0";
        sha256 = "0gqn7s0ki9x951n5whyh0pkcbbqz4kpcn80xxpsv1c0v34946xv7";
+       revision = "1";
+       editedCabalFile = "1z3fcff42xq0j430q72ncjv6zc0zvzzq94ifh06m342z0x8imv83";
        libraryHaskellDepends = [
          base bytestring deepseq ghc-prim mmap transformers unliftio-core
          vector
···
        pname = "hw-rankselect";
        version = "0.13.4.0";
        sha256 = "0chk3n4vb55px943w0l3q7pxhgbvqm64vn7lkhi7k0l2dpybycp7";
-       revision = "2";
-       editedCabalFile = "03lc8cgijr4ysz0i9c4pjhas4cd5ifxs400cr0nbasjvmz27hr3c";
+       revision = "3";
+       editedCabalFile = "14awklhpnw53jalxfq0446aidndmanpnwjxp1136imjv7p270pvn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hw-rankselect-base";
        version = "0.3.4.1";
        sha256 = "1s0lqwq0rjmjca6lshfnxqi0c7bzlyflhm45xw1xa9pvqci8439h";
-       revision = "1";
-       editedCabalFile = "0flhrgqgwgxwk6ik3k7322dn8ybyjzh6g1csg2d9bafldj7akcwv";
+       revision = "2";
+       editedCabalFile = "174a3qhkdam5m5rqwb9qzapg2xkd8vb0lirkz2d0xb4xxc0vzcy7";
        libraryHaskellDepends = [
          base bits-extra bitvec hw-bits hw-int hw-prim hw-string-parse
          vector
···
        pname = "hw-simd";
        version = "0.1.2.0";
        sha256 = "1r202xzqprb1v8ajd9n6ixckjfdy17mn8jibx4j2xgknx595v24f";
+       revision = "1";
+       editedCabalFile = "0vl82knb53njkp7n6jrwp4fpipfkc7s4lsi2cqd6w2xkgmlc0rxv";
        libraryHaskellDepends = [
          base bits-extra bytestring deepseq hw-bits hw-prim hw-rankselect
          hw-rankselect-base transformers vector
···
        broken = true;
      }) {};
 
+  "hw-simd-cli" = callPackage
+    ({ mkDerivation, base, bits-extra, bytestring, containers, deepseq
+     , directory, doctest, doctest-discover, generic-lens, hw-bits
+     , hw-prim, hw-rankselect-base, hw-simd, lens, mmap, mtl
+     , optparse-applicative, resourcet, vector
+     }:
+     mkDerivation {
+       pname = "hw-simd-cli";
+       version = "0.0.0.1";
+       sha256 = "0fqkrhjrflkiacq1qfnfiy4rk6pg47j72d0ni0jwfdn6ajx22y90";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bits-extra bytestring containers deepseq directory
+         generic-lens hw-bits hw-prim hw-rankselect-base hw-simd lens mmap
+         mtl optparse-applicative resourcet vector
+       ];
+       executableHaskellDepends = [
+         base bits-extra bytestring containers deepseq directory
+         generic-lens hw-bits hw-prim hw-rankselect-base hw-simd lens mmap
+         mtl optparse-applicative resourcet vector
+       ];
+       testHaskellDepends = [ base bits-extra doctest doctest-discover ];
+       testToolDepends = [ doctest-discover ];
+       description = "SIMD library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "hw-streams" = callPackage
     ({ mkDerivation, base, bytestring, criterion, directory, doctest
      , doctest-discover, exceptions, ghc-prim, hedgehog, hspec
···
        pname = "hw-streams";
        version = "0.0.1.0";
        sha256 = "0hzpx1j06h98y0zcmysklzn3s3mvpbb1nkwg4zkbdxvzzqs5hnm5";
+       revision = "1";
+       editedCabalFile = "0fib78604y6cjchah7zhjsfli820ks51qq7yjv81wwbckjjkpw5v";
        libraryHaskellDepends = [
          base bytestring ghc-prim hw-bits hw-prim mmap primitive
          transformers vector
···
        pname = "hw-xml";
        version = "0.5.1.0";
        sha256 = "0g81kknllbc6v5wx7kgzhh78409njfzr3h7lfdx7ip0nkhhnpmw4";
-       revision = "3";
-       editedCabalFile = "0b1lkhc6qf5vqafn69bid01k1hi043k7yrpl7pbxfrn154w8afpm";
+       revision = "4";
+       editedCabalFile = "1hnbcr376pncgzzrbilffxwz5sk67c4d9hzjix3xa94cja09w1ny";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        executableToolDepends = [ alex happy ];
        testHaskellDepends = [ array base Cabal containers mtl ];
        description = "An implementation of Neil D. Jones' While language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          containers hedgehog hspec magic-wormhole protolude saltine text
        ];
        description = "magic-wormhole client";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base Cabal containers mtl QuickCheck ];
        description = "An alternate Prelude";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          scotty stm stm-conduit text transformers
        ];
        description = "A haskell wrapper for the Zulip API";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          attoparsec base bytestring network unix
        ];
        description = "An API for the Interactive Brokers Trading Workstation written in pure Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0yrdh4y0ssldg0lmrbr6yk0zg2sihirp3mnh20dvg3m887kdhrj1";
        libraryHaskellDepends = [ base dbus directory unix xdg-basedir ];
        description = "A simple uncomplete ibus api";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "ical" = callPackage
···
      }:
      mkDerivation {
        pname = "ice40-prim";
-       version = "0.2.0.0";
-       sha256 = "02dm3zqq24phhxis471gp91figkazpwpz0ndhazp14jajxvka0cd";
+       version = "0.3.0.0";
+       sha256 = "0qrpaqmgas3czhw2ppc1f1m4m7y2hc93za2g0rvfw80ncbrkl83s";
        libraryHaskellDepends = [
          base Cabal clash-prelude ghc-typelits-extra ghc-typelits-knownnat
          ghc-typelits-natnormalise interpolate
···
          transformers wl-pprint-text
        ];
        description = "An keyboard-driven interactive graph editor";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ ige-mac-integration ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Bindings for the Gtk/OS X integration library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {ige-mac-integration = null;};
···
          parsec richreports split staticanalysis text uxadt
        ];
        description = "Multi-platform parser analyzer and generator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base hspec parsec ];
        benchmarkHaskellDepends = [ base criterion parsec ];
        description = "A math-inspired programmatic 2D & 3D CAD system";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "implicit-hie" = callPackage
···
        editedCabalFile = "02x6cmbxyw26y5azhjrx8461vngsj27l0a255xvhg2pl25zwfbfs";
        libraryHaskellDepends = [ base mtl time transformers ];
        description = "A logging framework built around implicit parameters";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring criterion deepseq monoid-subclasses text
        ];
        description = "Generic parser library capable of providing partial results from partial input";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "incremental-sat-solver" = callPackage
···
        libraryHaskellDepends = [ array base deepseq vector ];
        testHaskellDepends = [ array base deepseq QuickCheck text vector ];
        description = "Non-contiguous interval data types with potentially infinite ranges";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ base optparse-applicative parsec ];
        description = "Type inference and checker for JavaScript (experimental)";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "influxdb";
-       version = "1.9.1";
-       sha256 = "1g8lj56xi61g0vfindiz4lmnypjh2bzp2nm92dmh2d4mlfhrh78y";
-       isLibrary = true;
-       isExecutable = true;
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         aeson attoparsec base bytestring clock containers foldl http-client
-         http-types lens network optional-args scientific tagged text time
-         unordered-containers vector
-       ];
-       testHaskellDepends = [
-         base containers doctest lens raw-strings-qq tasty tasty-hunit
-         template-haskell time vector
-       ];
-       description = "InfluxDB client library for Haskell";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "influxdb_1_9_1_1" = callPackage
-  "karver" = callPackage
-     , cabal-doctest, clock, containers, doctest, foldl, http-client
-     , http-types, lens, network, optional-args, raw-strings-qq
-     , scientific, tagged, tasty, tasty-hunit, template-haskell, text
-     , time, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "influxdb";
        version = "1.9.1.1";
        sha256 = "1qdfrl5ragkn726ymh16p0shgc6sn72gd1hh6a6bw19m527pdcc0";
        isLibrary = true;
···
        ];
        description = "InfluxDB client library for Haskell";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "informative" = callPackage
···
          time-locale-compat yesod yesod-auth yesod-core yesod-form
        ];
        description = "A yesod subsite serving a wiki";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1iw82rzw2w3y40zndz3mxpa7k5ds8zs87ccvp228s4zva0mp5ddl";
        libraryHaskellDepends = [ base ];
        description = "Monadic functions with injected parameters";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ aether base text ];
        description = "Console client for encyclopedias";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {aether = null;};
···
      }:
      mkDerivation {
        pname = "instana-haskell-trace-sdk";
-       version = "0.6.0.0";
-       sha256 = "0b27fvvq1xxici2w33m823xnj7fwq1irjhwrcaav1khz3h93qv85";
+       version = "0.6.2.0";
+       sha256 = "1yvxsz1b9qrhyw6zamqs5254mpba3vijhach1n424mqa6aq1935s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          http-types network scotty text wai wai-extra
        ];
        description = "Basic HTTP gateway to save articles to Instapaper";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1fc3vgxxzk6rw0y6d40jiyrc66fd1ig7nk4bdmfn1q595q5iwnz3";
        libraryHaskellDepends = [ array base containers music-diatonic ];
        description = "Render Instrument Chords";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "int-cast" = callPackage
···
          vector
        ];
        description = "Integrate different assays";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-hunit
        ];
        description = "GHC preprocessor and library to enable variable interpolation in strings";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base deepseq fingertree ];
        testHaskellDepends = [ base tasty tasty-hunit ];
        description = "Intervals with adherences";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executablePkgconfigDepends = [ ncurses ];
        description = "A game of competitive puzzle-design";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) ncurses;};
 
   "intrinsic-superclasses" = callPackage
···
        pname = "io-streams";
        version = "1.5.2.0";
        sha256 = "1hbabrk5145d77qi23688piaf1wc93n8vaj846n0s3zk953z1lk3";
-       revision = "1";
-       editedCabalFile = "1dcadj5gv1m2yy97zsbq5x67vsblp8gy58a0kl5di9vkbgrcw46n";
+       revision = "2";
+       editedCabalFile = "1mr0y8m6xdkgvvk76n7pn1airqzgdp8kd8x6jd9w97iy5wjp14q7";
        configureFlags = [ "-fnointeractivetests" ];
        libraryHaskellDepends = [
          attoparsec base bytestring bytestring-builder network primitive
···
          unix
        ];
        description = "interactive patch editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "ipfs" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory, directory-tree
-     , doctest, envy, flow, Glob, http-media, ip, lens, lens-aeson
-     , monad-logger, QuickCheck, regex-compat, rio, servant
+     , doctest, envy, flow, Glob, http-media, lens, lens-aeson
+     , monad-logger, network-ip, QuickCheck, regex-compat, rio, servant
      , servant-client, servant-multipart, servant-server, swagger2, text
      , vector, yaml
      }:
      mkDerivation {
        pname = "ipfs";
-       version = "1.3.0.0";
-       sha256 = "1ag3rx7p4gp39rhgwap083ny5x00z5p8aks1lwvrsmdlvn83ym6l";
+       version = "1.3.0.3";
+       sha256 = "08g1lvh7w46qsg80h5nm3r333zbhl2q4shnrm5jann4p3g5ii08x";
        libraryHaskellDepends = [
-         aeson base bytestring envy flow Glob http-media ip lens
-         monad-logger regex-compat rio servant servant-client
+         aeson base bytestring envy flow Glob http-media lens monad-logger
+         network-ip regex-compat rio servant servant-client
          servant-multipart servant-server swagger2 text vector
        ];
        testHaskellDepends = [
          aeson base bytestring directory directory-tree doctest envy flow
-         Glob http-media ip lens lens-aeson monad-logger QuickCheck
+         Glob http-media lens lens-aeson monad-logger network-ip QuickCheck
          regex-compat rio servant servant-client servant-multipart
          servant-server swagger2 text vector yaml
        ];
···
        sha256 = "1yi1ia4ii6xg17ndp0v47cix0ds6bbrsbf0pghcmx3y4b55v0dlr";
        libraryHaskellDepends = [ aeson base http-client lens text wreq ];
        description = "Iron.IO message queueing client library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers hspec megaparsec QuickCheck
        ];
        description = "Isotopic masses and relative abundances";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          haskell98 hoauth mtl old-locale parsec time utf8-string xml
        ];
        description = "CLI (command line interface) to YQL";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "03ysmgg5f3dsimskqw5vpnrv5jg4gf1gd0khmf0s1ilfm1jc1nfd";
        libraryHaskellDepends = [ base hosc ];
        description = "control JackMiniMix";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ base boxes directory filepath ];
        description = "Export sheet music and audio from Windows/Mac app Jammit";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "japanese-calendar" = callPackage
···
        ];
        executableHaskellDepends = [ base mtl network ];
        description = "Implementation of Java Debug Interface";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, mtl, parsec, tasty, tasty-hunit, text }:
      mkDerivation {
        pname = "jira-wiki-markup";
-       version = "1.3.3";
-       sha256 = "0sgm9x2bdwazhj598aix2xyshjy6cvai4sgq5zz8gxv2l6prfbr7";
+       version = "1.3.4";
+       sha256 = "0rrqaibgafbynrlcsp7f7hkzgkp2gix7ji2hkpgpby6fvp6965fh";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base mtl parsec text ];
···
      }:
      mkDerivation {
        pname = "jose-jwt";
-       version = "0.9.0";
-       sha256 = "1dnkyzs7kk2lxz2kj3x6v8w1lypsr0rppyn78s7w5sr89y924752";
+       version = "0.9.1";
+       sha256 = "0dy076k7zrg9mn4ll73k5p68r1dwzj9wqm4zn7w22py6wx06xg9p";
        libraryHaskellDepends = [
          aeson attoparsec base bytestring cereal containers cryptonite
          memory mtl text time transformers transformers-compat
···
        ];
        testToolDepends = [ hspec-discover ];
        description = "JSON-RPC 2.0 server over a Conduit.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "juandelacosa" = callPackage
     ({ mkDerivation, base, base64-bytestring, bytestring
-     , data-default-class, docopt, entropy, fast-logger, http-types
-     , interpolatedstring-perl6, mtl, mysql, mysql-simple, network
-     , resource-pool, scotty, text, unix, wai, wai-extra
-     , wai-middleware-static, warp
+     , data-default-class, entropy, fast-logger, http-types, mtl, mysql
+     , mysql-simple, network, optparse-applicative, resource-pool
+     , scotty, text, unix, wai, wai-extra, wai-middleware-static, warp
      }:
      mkDerivation {
        pname = "juandelacosa";
-       version = "0.1.1";
-       sha256 = "060zq739i3xhr7w448p460r7x3jyyzf7pn61abp7f9g8vjn6vqw7";
+       version = "0.1.2";
+       sha256 = "0lrqklpff24cklsdrlfym7ryvszyripjkwsb0m8dn7vab9yqswn2";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        executableHaskellDepends = [
-         base base64-bytestring bytestring data-default-class docopt entropy
-         fast-logger http-types interpolatedstring-perl6 mtl mysql
-         mysql-simple network resource-pool scotty text unix wai wai-extra
+         base base64-bytestring bytestring data-default-class entropy
+         fast-logger http-types mtl mysql mysql-simple network
+         optparse-applicative resource-pool scotty text unix wai wai-extra
          wai-middleware-static warp
        ];
        description = "Manage users in MariaDB >= 10.1.1";
···
          optparse-applicative text unordered-containers yaml
        ];
        description = "Tableau-based theorem prover for justification logic";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          process
        ];
        description = "Build profiles for kdesrc-build";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          process
        ];
        description = "Build profiles for kdesrc-build";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "kdt" = callPackage
···
      }:
      mkDerivation {
        pname = "kempe";
-       version = "0.1.1.3";
-       sha256 = "0p0zm3dxjcmckwif966cnsn8qb667mxd8yh7wx56nl7jsxz90cw1";
+       version = "0.2.0.0";
+       sha256 = "1wgbjk1iyb4njcr957lipxnypk3c08c98v9czk3xld9dqzq9xxf1";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          unix unix-compat utf8-string wai warp zxcvbn-c
        ];
        description = "back up a secret key securely to the cloud";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          parsec text transformers unix unordered-containers yaml
        ];
        description = "Command-line file tagging and organization tool";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base kind-generics template-haskell ];
        description = "Template Haskell support for generating `GenericK` instances";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "kind-generics-th_0_2_2_2" = callPackage
+    ({ mkDerivation, base, ghc-prim, kind-generics, template-haskell
+     , th-abstraction
+     }:
+     mkDerivation {
+       pname = "kind-generics-th";
+       version = "0.2.2.2";
+       sha256 = "1lgz7wvz5jvq65r7zmymcfx3hwskw2b45a3vfwj0pgnddpjmh9n4";
+       libraryHaskellDepends = [
+         base ghc-prim kind-generics template-haskell th-abstraction
+       ];
+       testHaskellDepends = [ base kind-generics template-haskell ];
+       description = "Template Haskell support for generating `GenericK` instances";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "kinds" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base parsec ];
        description = "Untyped Lambda calculus to JavaScript compiler";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base clash-prelude Lambdaya template-haskell
        ];
        description = "Fpga bus core and serialization for RedPitaya";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1nmyirpf07q7lrgfdqxwaspa173a2g3077gy9k7rpviw8pg2az0w";
        libraryHaskellDepends = [ base bytestring http-streams Mapping ];
        description = "A Lisp";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          megaparsec prettyprinter QuickCheck split text time
        ];
        description = "Dockerfile parser, pretty-printer and embedded DSL";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "language-dockerfile" = callPackage
···
          transformers unordered-containers yaml
        ];
        description = "Dockerfile linter, parser, pretty-printer and embedded DSL";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          grammatical-parsers prettyprinter tasty tasty-hunit text
        ];
        description = "Parser, pretty-printer, and more for the Oberon programming language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, liblapack, netlib-ffi }:
      mkDerivation {
        pname = "lapack-ffi";
-       version = "0.0.2";
-       sha256 = "11759avf0kzkqy4s24kn556j93l10x28njpg6h14y915pdl35dyl";
+       version = "0.0.3";
+       sha256 = "1qj7l2maka7z0gnkb59kl9qnyql12g5akmmqwsjvcnhbywgiv1yr";
        libraryHaskellDepends = [ base netlib-ffi ];
        libraryPkgconfigDepends = [ liblapack ];
        description = "Auto-generated interface to Fortran LAPACK";
···
          HDBC-sqlite3 hsini HTTP mtl old-locale regex-compat tagsoup time
        ];
        description = "Tool to track security alerts on LWN";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          template-haskell vector-space
        ];
        description = "Identifiers for not-yet-computed values";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          temporary
        ];
        description = "Storing computed values for re-use when the same program runs again";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base doctest lens ];
        testToolDepends = [ markdown-unlit ];
        description = "Lazy-Spined Monadic Priority Queues";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base blaze-html directory filepath pandoc split
        ];
        description = "A simple portfolio generator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          semigroups terminal-progress-bar text
        ];
        description = "frugal issue tracker";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers doctest lattices ];
        testHaskellDepends = [ base doctest QuickCheck ];
        description = "L-Fuzzy Set Theory implementation in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "libfuse3";
        version = "0.1.2.0";
        sha256 = "0a59b4xag5vzisrnvf4v1zkdsdzky96h8w2mdj6cip3vgr196frb";
-       revision = "1";
-       editedCabalFile = "0gnq6aav00xx7dc8am87q2n6xw7cf7jm29g5bq5n1b72gqs91rzf";
+       revision = "2";
+       editedCabalFile = "0fbf1zrw5i3jag6yrzxsxcx82dag7a3mw5rmz6ab6v3gm9w8m9b2";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          base bytestring ghc ghc-paths hspec mtl syb
        ];
        description = "Backend for text editors to provide better Haskell editing support";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-th text time transformers
        ];
        description = "Prelude based on protolude for GHC 8 and beyond";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-th text time transformers
        ];
        description = "Prelude based on protolude for GHC 8 and beyond";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base directory errors protolude tasty tasty-hunit text
        ];
        description = "Bindings to the nix package manager";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        executableHaskellDepends = [ base bytestring time ];
        testHaskellDepends = [ base ];
        description = "Bindings to liboath";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {liboath = null; oath = null;};
···
        librarySystemDepends = [ pafe ];
        testHaskellDepends = [ base bytestring iconv transformers ];
        description = "Wrapper for libpafe";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {pafe = null;};
···
          base HUnit network test-framework test-framework-hunit
        ];
        description = "Haskell bindings for libsystemd-daemon";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {libsystemd-daemon = null; systemd-daemon = null;};
···
        librarySystemDepends = [ taglib ];
        libraryPkgconfigDepends = [ taglib ];
        description = "Binding to TagLib C library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) taglib;};
···
        isExecutable = true;
        executableHaskellDepends = [ base ];
        description = "Convert newlines in text";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "line-drawing" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base ];
        description = "Display the number of bytes of each line";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "line2pdf" = callPackage
···
          tasty-smallcheck
        ];
        description = "A simple library for linear codes (coding theory, error correction)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base bytestring network ];
        testHaskellDepends = [ base hspec network tasty-hspec ];
        description = "Typed sockets";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "linear-tests" = callPackage
···
          semigroups tagged transformers vector vector-space
        ];
        description = "Native, complete, matrix-free linear algebra";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryPkgconfigDepends = [ blkid ];
        description = "Linux libblkid";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {blkid = null;};
···
        ];
        description = "Labeled File System interface for LIO";
        license = "GPL";
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {};
 
   "lio-simple" = callPackage
···
          simple-templates text
        ];
        description = "LIO support for the Simple web framework";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          ansi-terminal base data-default hspec stm terminal-size vty
        ];
        description = "A simple list prompt UI for the terminal";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          MissingH tasty tasty-hunit tasty-quickcheck
        ];
        description = "List all remote forwards for mail accounts stored in a SQL database";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1172rmrk5xgqsy9igg9bspbybvhmbpakvjijn6gnp715a01gfadd";
        libraryHaskellDepends = [ base containers text transformers ];
        description = "Library for localization (l10n)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "localize" = callPackage
···
        ];
        testHaskellDepends = [ base test-framework ];
        description = "A library for lattice cryptography";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework time
        ];
        description = "Lattice-based cryptographic applications using <https://hackage.haskell.org/package/lol lol>.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          MonadRandom split statistics
        ];
        description = "A library for benchmarking <https://hackage.haskell.org/package/lol lol>.";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text-format transformers
        ];
        description = "Calculus for LOL (λω language)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base lol lol-apps test-framework ];
        benchmarkHaskellDepends = [ base DRBG lol lol-apps MonadRandom ];
        description = "A fast C++ backend for <https://hackage.haskell.org/package/lol lol>.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base lol-tests ];
        benchmarkHaskellDepends = [ base DRBG lol lol-benches ];
        description = "A repa backend for <https://hackage.haskell.org/package/lol lol>.";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base lol test-framework ];
        description = "A library for testing <https://hackage.haskell.org/package/lol Λ ∘ λ>.";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          monad-classes tasty tasty-hunit text text-format transformers
        ];
        description = "Type inferencer for LOL (λω language)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ loris ];
        libraryToolDepends = [ c2hs ];
        description = "interface to Loris API";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {loris = null;};
···
          vector
        ];
        description = "An EDSL for diagrams based based on linear constraints";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "lp-diagrams-svg" = callPackage
···
          aeson base bytestring file-embed hspec QuickCheck text th-utilities
        ];
        description = "Core functionality for LTI 1.3.";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text
        ];
        description = "Library functions for reading and writing Lua chunks";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base exceptions hspec hspec-core random text turtle uuid
        ];
        description = "LXD client written in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-hunit test-framework-quickcheck2 text yaml
        ];
        description = "Read the configuration file of the standard LXD client";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "lye" = callPackage
···
        sha256 = "0ccwckq0gkrnahf224s59gsdd9baay1dfc8fh1kz2r87rbygzsk7";
        libraryHaskellDepends = [ base bytestring ];
        description = "Lzip compression / Lzlib bindings";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          monad-control mtl resourcet stm stm-containers time transformers
        ];
        description = "Machine transducers for Amazonka calls";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "machines-attoparsec";
        version = "0";
        sha256 = "0mxm1gy7kr7czhmfwskl56wnawb2l3axfig22935bliq75mpvbs4";
-       revision = "1";
-       editedCabalFile = "1n57r25q0aajakkl7r82yw6rs9dqlhmr0qmhs7vb7ycs5i1chyis";
+       revision = "2";
+       editedCabalFile = "16gb0nd9njzz0nb97ii6i8vq0c309m6wl0cdgy08rdbf4cpzfx91";
        libraryHaskellDepends = [
          attoparsec base bytestring machines text
        ];
···
          aeson base bytestring mtl text time xml zip-archive zlib
        ];
        description = "A parser library for DMARC and SMTP TLS reports";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-hunit
        ];
        description = "Count mailboxes in a SQL database";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "mailchimp" = callPackage
···
          template-haskell text unix utf8-string
        ];
        description = "The Haskell/Gtk+ Integrated Live Environment";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        doHaddock = false;
        description = "Virtual package to install all Manatee packages";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
          split stm text unix utf8-string
        ];
        description = "Multithread interactive input/search framework for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          mtl stm text utf8-string webkit
        ];
        description = "Browser extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
          template-haskell text time unix utf8-string
        ];
        description = "The core of Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          old-time regex-tdfa stm template-haskell text utf8-string
        ];
        description = "Download Manager extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          filepath gtk gtksourceview2 manatee-core regex-tdfa stm text
        ];
        description = "Editor extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          manatee-core mtl old-locale old-time stm text utf8-string
        ];
        description = "File manager extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          gtkimageview manatee-core regex-tdfa stm text utf8-string
        ];
        description = "Image viewer extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          regex-posix split stm template-haskell text unix utf8-string
        ];
        description = "IRC client extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text time unix utf8-string
        ];
        description = "Mplayer client extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          manatee-core mtl poppler stm text utf8-string
        ];
        description = "PDF viewer extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          proc stm text
        ];
        description = "Process manager extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          filepath gtk manatee-core stm text utf8-string webkit
        ];
        description = "Feed reader extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
          filepath gtk gtksourceview2 manatee-core regex-tdfa stm text
        ];
        description = "Template code to create Manatee application";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          stm text unix vte
        ];
        description = "Terminal Emulator extension for Manatee";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          filepath gtk manatee-core regex-tdfa stm text
        ];
        description = "Welcome module to help user play Manatee quickly";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base ];
        description = "Simple mancala game";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "mandrill" = callPackage
···
          array base bytestring containers directory filepath GLUT hslua time
        ];
        description = "A zooming visualisation of the Mandelbrot Set as many Julia Sets";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          semigroups vector-space
        ];
        description = "Sampling random points on general manifolds";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-hunit tasty-quickcheck vector-space
        ];
        description = "Coordinate-free hypersurfaces";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1bvmr0gcfj7zd0rff0qjlzjy8hqdbh52ljiiazrmqmb9abdsciq3";
        libraryHaskellDepends = [ base call-stack tagged vector-space ];
        description = "The basic classes for the manifolds hierarchy";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "map-classes" = callPackage
···
          pandoc temporary text transformers webkit
        ];
        description = "A simple markup document preview (markdown, textile, reStructuredText)";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
          array base bytestring colour gloss MonadRandom mtl random
        ];
        description = "Generates mountainous terrain using a random walk algorithm";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base configurator dlist parsek pretty
        ];
        description = "Markup language preprocessor for Haskell";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "masakazu-bot" = callPackage
···
          twitter-types
        ];
        description = "@minamiyama1994_bot on haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1bbi9368zg50xvhn0lkrza1fpfi1cjz21lxyay6qb9v2r7h0mhr3";
        libraryHaskellDepends = [ base data-default-class ];
        description = "Parse and evaluate math expressions with variables and functions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "mathflow" = callPackage
···
          graphviz HTTP process safe tagsoup text
        ];
        description = "Discover your (academic) ancestors!";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "mathista" = callPackage
···
          tagsoup text time xdg-basedir
        ];
        description = "download bugs mailboxes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          MissingH polyparse process text unix
        ];
        description = "Machine Configuration Manager";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "14z1x9dqnjj391nrlngs9s887yqh3arc7kfgk0m3d89vrkc185vq";
        libraryHaskellDepends = [ base MonadRandom ];
        description = "MCMC applied to probabilistic program synthesis";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring storable-endian transformers utility-ht
        ];
        description = "Parse song module files from Amiga MED and OctaMED";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "medea" = callPackage
···
          servant-client servant-server text time
        ];
        description = "Haskell SDK for communicating with the Medium API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "mercury-api";
        version = "0.1.0.2";
        sha256 = "0ybpc1kai85rflgdr80jd8cvwxaxmbphv82nz2p17502jrmdfkhg";
-       revision = "5";
-       editedCabalFile = "15xgb00cv8srnhfgh7v01b2qijcwapwsbx92jbdss525n3j74d48";
+       revision = "6";
+       editedCabalFile = "03d71mfq8nvqjr7hcpkh1q25fi1avqj35mfrrf7rkm13fr49bi7i";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          tasty tasty-quickcheck text unordered-containers vector
        ];
        description = "A tiny JSON library with light dependency footprint";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "microbase" = callPackage
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "microlens";
-       version = "0.4.11.2";
-       sha256 = "1z6zdprpr193a56r5s67q75554rrqyp2kk6srxn1gif7fd54sj2f";
-       libraryHaskellDepends = [ base ];
-       description = "A tiny lens library with no dependencies";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microlens_0_4_12_0" = callPackage
-    ({ mkDerivation, base }:
-     mkDerivation {
-       pname = "microlens";
        version = "0.4.12.0";
        sha256 = "10q7gl9yavcln58sxdxzih7ff0ixxq5hpd87icvxw97yqf1p6hmm";
        libraryHaskellDepends = [ base ];
        description = "A tiny lens library with no dependencies";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microlens-aeson" = callPackage
···
      }:
      mkDerivation {
        pname = "microlens-ghc";
-       version = "0.4.12";
-       sha256 = "07qh66alv00jz4l3w80km8grym6sk36c5kx5jfaya20irq91ni1b";
-       libraryHaskellDepends = [
-         array base bytestring containers microlens transformers
-       ];
-       description = "microlens + array, bytestring, containers, transformers";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microlens-ghc_0_4_13" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, microlens
-     , transformers
-     }:
-     mkDerivation {
-       pname = "microlens-ghc";
        version = "0.4.13";
        sha256 = "1r6x788br3f9rksj0dmk1nyh5mfvd9zzasclf1mi3rxhb7c0j926";
        libraryHaskellDepends = [
···
        ];
        description = "microlens + array, bytestring, containers, transformers";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microlens-mtl" = callPackage
···
      }:
      mkDerivation {
        pname = "microlens-platform";
-       version = "0.4.1";
-       sha256 = "0zlijw6ib9zf15n750qz6jlvj9l6sdf0d29w8nkflr2bspbvxn03";
-       libraryHaskellDepends = [
-         base hashable microlens microlens-ghc microlens-mtl microlens-th
-         text unordered-containers vector
-       ];
-       description = "microlens + all batteries included (best for apps)";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "microlens-platform_0_4_2" = callPackage
-    ({ mkDerivation, base, hashable, microlens, microlens-ghc
-     , microlens-mtl, microlens-th, text, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "microlens-platform";
        version = "0.4.2";
        sha256 = "0yf0z0glq2d6mpclzswc64h9w2cck4fd8l8ffm89pyb0a5n8m4c7";
        libraryHaskellDepends = [
···
        ];
        description = "microlens + all batteries included (best for apps)";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "microlens-process" = callPackage
···
          tf-random transformers
        ];
        description = "Language for algorithmic generation of MIDI files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1dkja5arps41wanhv1jnkf99xrc8f5aiimp27myd595lqqdr87s2";
        libraryHaskellDepends = [ base containers safe stm ];
        description = "Hot-swappable FRP";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "midi" = callPackage
···
        ];
        description = "Convert between datatypes of the midi and the alsa packages";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {};
 
   "midi-music-box" = callPackage
···
        ];
        benchmarkHaskellDepends = [ base bytestring criterion ];
        description = "A simple and fast library for working with MIDI messages";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "midi-util" = callPackage
···
          base bytestring directory event-list midi parsec process
        ];
        description = "Utilities for working with MIDI data";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-quickcheck
        ];
        description = "Lambda calculus interpreter";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "16fdzbfspxqi0h7v6gn25n065anvk9zm28236qvfwbvr9l2ki172";
        libraryHaskellDepends = [ base vector ];
        description = "Bindings to Miniball, a smallest enclosing ball library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "miniforth" = callPackage
···
          array base bytestring containers mtl semigroups text transformers
        ];
        description = "A minimalistic lens library, providing only the simplest, most basic lens functionality";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base binary bytestring vector ];
        testHaskellDepends = [ base binary directory hspec vector ];
        description = "Read and write IDX data that is used in e.g. the MINST database.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring ghc-prim hspec primitive vector
        ];
        description = "A Minisat-based CDCL SAT solver in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers twitter-conduit
        ];
        description = "Tweet mirror";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          anydbm base Cabal directory HUnit MissingH
        ];
        description = "Haskell interface to Python";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "mmark";
+       version = "0.0.7.2";
+       sha256 = "1wwszzba6fvg0r4q5z2dzashim0nkaxzx4rmjl216kdi08jkp7mm";
+       revision = "3";
+       editedCabalFile = "1ffa76pz544pa3s764lnc38rdmfccyn8z6zn1w76pqb01p0f9k9p";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base case-insensitive containers deepseq dlist email-validate
+         foldl hashable html-entity-map lucid megaparsec microlens
+         microlens-th modern-uri mtl parser-combinators text text-metrics
+         unordered-containers yaml
+       ];
+       testHaskellDepends = [
+         aeson base foldl hspec hspec-megaparsec lucid megaparsec modern-uri
+         QuickCheck text
+       ];
+       benchmarkHaskellDepends = [ base criterion text weigh ];
+       description = "Strict markdown processor for writers";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
+  "mmark_0_0_7_3" = callPackage
+    ({ mkDerivation, aeson, base, case-insensitive, containers
+     , criterion, deepseq, dlist, email-validate, foldl, hashable, hspec
+     , hspec-megaparsec, html-entity-map, lucid, megaparsec, microlens
+     , microlens-th, modern-uri, mtl, parser-combinators, QuickCheck
+     , text, text-metrics, unordered-containers, weigh, yaml
+     }:
+     mkDerivation {
+       pname = "mmark";
        version = "0.0.7.3";
        sha256 = "1gfl9jhqm1jaqxi0yxd8r4z3ai5c3f1wv53vjs0ln84qjpcqp30s";
+       revision = "1";
+       editedCabalFile = "19yg41grkliim428x9cqwcynmjvkh83mqfyxiv2dc6fvid6fmcrk";
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          aeson base case-insensitive containers deepseq dlist email-validate
···
        libraryHaskellDepends = [ base binary bytestring vector ];
        testHaskellDepends = [ base binary directory hspec vector ];
        description = "Read and write IDX data that is used in e.g. the MNIST database.";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "moan" = callPackage
···
          semigroups split text transformers
        ];
        description = "Modify fasta (and CLIP) files in several optional ways";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base hmatrix sparse-linear-algebra spectral-clustering vector
        ];
        description = "Find the modularity of a network";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          nats pandoc-types parsec prettify process semigroups text
        ];
        description = "Modular C code generator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "mohws" = callPackage
     ({ mkDerivation, base, bytestring, containers, data-accessor
-     , directory, explicit-exception, filepath, html, HTTP, network
-     , network-uri, old-locale, old-time, parsec, process, transformers
-     , unix, utility-ht
+     , directory, explicit-exception, fail, filepath, html, HTTP
+     , network, network-uri, old-locale, old-time, parsec, process
+     , transformers, unix, utility-ht
      }:
      mkDerivation {
        pname = "mohws";
-       version = "0.2.1.6";
-       sha256 = "0rnb6nq99bav0z5dxzc4xkb2ai6ifm5v2ijd76sgzbs2032v6wqs";
+       version = "0.2.1.8";
+       sha256 = "039abcwkqijsw8qp2iid6ilnyg79lvc1m6zik0jc4gadl5g704wh";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
          base bytestring containers data-accessor directory
-         explicit-exception filepath html HTTP network network-uri
+         explicit-exception fail filepath html HTTP network network-uri
          old-locale old-time parsec process transformers unix utility-ht
        ];
+       executableHaskellDepends = [ base bytestring ];
        description = "Modular Haskell Web Server";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
          base contravariant invariant MonadRandom mtl primitive transformers
        ];
        description = "Monad, monad transformer, and typeclass representing choices";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "monad-chronicle" = callPackage
···
          base containers directory mtl optparse-applicative process unix
        ];
        description = "A system state collecting library and application";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-quickcheck template-haskell text unordered-containers yaml
        ];
        description = "A multi-lingual, typed, workflow language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          simple-ui template-haskell text unix utf8-string vty
        ];
        description = "Music player for linux";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "11c62m19ngap44fv4gnv0ln8iff1b08dg2vclj16jx1fj8pqps9y";
        libraryHaskellDepends = [ base containers dbus mtl ];
        description = "Interface for MPRIS";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base directory filepath gtk mtl process template-haskell unix
        ];
        description = "A minimalist mpv GUI written in I/O heavy Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          stm text transformers
        ];
        description = "A MQTT client library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testToolDepends = [ alex happy ];
        description = "An intermediate language designed to perform advanced code analysis";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        executableHaskellDepends = [ base ];
        executablePkgconfigDepends = [ gtk3 ];
        description = "Supply your tunes info without leaving your music player";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gtk3;};
···
          test-framework-smallcheck text time transformers xmlhtml
        ];
        description = "Send an email to all MusicBrainz editors";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "musicw";
-       version = "0.3.7";
-       sha256 = "0b5wn084ka4xnvimzxd47y4m0ldmfqr7sa30a5bm08g62333h3yr";
+       version = "0.3.8";
+       sha256 = "00hw1ayzcyh9dxrha3kmyi9r69d5bb942ggl020jm3r5jayzs28h";
        libraryHaskellDepends = [
          array base bytestring containers data-default file-embed ghcjs-base
          ghcjs-dom ghcjs-prim json monad-loops mtl safe text time
···
          process
        ];
        description = "Watches your screensaver and (un)mutes music when you (un)lock the screen";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          http-client-tls network-uri text yaml
        ];
        description = "Export from MyAnimeList";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "mysql";
-       version = "0.1.7.3";
-       sha256 = "1yf9ni64q19ci6ripcjh0pvpklxyi0fzigb33ss05wswlal385rc";
-       setupHaskellDepends = [ base Cabal ];
-       libraryHaskellDepends = [ base bytestring containers ];
-       librarySystemDepends = [ mysql ];
-       testHaskellDepends = [ base bytestring hspec ];
-       description = "A low-level MySQL client library";
-       license = lib.licenses.bsd3;
-     }) {inherit (pkgs) mysql;};
-
-  "mysql_0_2" = callPackage
-    ({ mkDerivation, base, bytestring, Cabal, containers, hspec, mysql
-     }:
-     mkDerivation {
-       pname = "mysql";
        version = "0.2";
        sha256 = "09b1rhv16g8npjblq9jfi29bffsplvq4hnksdhknd39anr5gpqzc";
        setupHaskellDepends = [ base Cabal ];
···
        testHaskellDepends = [ base bytestring hspec ];
        description = "A low-level MySQL client library";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) mysql;};
 
   "mysql-effect" = callPackage
···
        libraryHaskellDepends = [ base ];
        executableHaskellDepends = [ base ];
        description = "EDSL to specify Nagios configuration files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "nagios-perfdata" = callPackage
···
        libraryHaskellDepends = [ aeson attoparsec base lens text wreq ];
        executableHaskellDepends = [ base text ];
        description = "Tool to keep namecoin names updated and well";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "named" = callPackage
···
          kanji microlens microlens-aeson optparse-applicative text
        ];
        description = "Performs 漢字検定 (Japan Kanji Aptitude Test) level analysis on given Kanji";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          aeson base iso639 lens lens-aeson network-uri random text wreq
        ];
        description = "Interface to Naver Translate";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ ncurses ];
        libraryToolDepends = [ c2hs ];
        description = "Modernised bindings to GNU ncurses";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) ncurses;};
 
   "ndjson-conduit" = callPackage
···
          random transformers
        ];
        description = "A NEAT library for Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers hspec ];
        description = "Nested set model implementation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "nestedmap" = callPackage
···
        editedCabalFile = "00wqr9nnjn8hm0r8xa5qrgqva5r0pcf32hlksrqhkzy12yl2kv08";
        libraryHaskellDepends = [ base bytestring hosc network ];
        description = "Netclock protocol";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring tasty tasty-golden tasty-quickcheck
        ];
        description = "Parser for .netrc files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "netrium" = callPackage
···
          base bytestring enumerator transformers
        ];
        description = "Enumerator-based netstring parsing";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0hxbzzdjrxnx9pknsbma7iyfr3pxrsff5n9mhbkpaqaizhibq7q7";
        libraryHaskellDepends = [ array base containers mtl ];
        description = "data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        broken = true;
      }) {};
 
+  "network-packet-linux" = callPackage
+    ({ mkDerivation, base, bytestring, hspec, hspec-discover, HUnit
+     , network, QuickCheck, vendored-network, vendored-network-test
+     }:
+     mkDerivation {
+       pname = "network-packet-linux";
+       version = "0.1.0.0";
+       sha256 = "17096sa20jijq37nr0bn4bcnpilh5yx4pdwqb4c2vk4i0lkwg58m";
+       revision = "2";
+       editedCabalFile = "0w3ca2z3ppj7b8ifafh4y42zv6wpkdd0mmfsvmvcdmfprlsh244b";
+       libraryHaskellDepends = [ base network vendored-network ];
+       testHaskellDepends = [
+         base bytestring hspec HUnit network QuickCheck
+         vendored-network-test
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Types for working with Linux packet sockets";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {vendored-network = null; vendored-network-test = null;};
+
   "network-pgi" = callPackage
     ({ mkDerivation, attoparsec, attoparsec-enumerator, base
      , bytestring, enumerator, tnet
···
          text transformers xml-types
        ];
        description = "Client library for the XMPP protocol";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers
        ];
        description = "ByteString and Text streams for networking";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers fixedprec random ];
        executableHaskellDepends = [ base random time ];
        description = "Exact and approximate synthesis of quantum circuits";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "newt" = callPackage
···
        ];
        executableHaskellDepends = [ base ];
        description = "Nico Nico Douga (ニコニコ動画) Comment Translator";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers
        ];
        description = "IDL compiler and RPC/distributed object framework for microservices";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1wd2vd0qn8ln3a5r29gikdcr4c2c2rf43p6kq3wmqm8ww30djgca";
        libraryHaskellDepends = [ base containers ];
        description = "Binders and alpha-equivalence made easy";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "nomyx-api" = callPackage
···
      }) {nomyx-auth = null;};
 
   "non-empty" = callPackage
-    ({ mkDerivation, base, containers, deepseq, QuickCheck, utility-ht
+    ({ mkDerivation, base, containers, deepseq, doctest-exitcode-stdio
+     , QuickCheck, utility-ht
      }:
      mkDerivation {
        pname = "non-empty";
-       version = "0.3.2";
-       sha256 = "0j47d1xaxi2ynsa3wckapjbcvzr66cwca74xpzi554ba70agq40v";
+       version = "0.3.3";
+       sha256 = "01vhkj9xgggml51zmrj3hngxxnzrcd4zs0a7yjg69i6z518mh0pg";
        libraryHaskellDepends = [
          base containers deepseq QuickCheck utility-ht
        ];
-       testHaskellDepends = [ base containers QuickCheck utility-ht ];
+       testHaskellDepends = [
+         base containers doctest-exitcode-stdio QuickCheck utility-ht
+       ];
        description = "List-like structures with static restrictions on the number of elements";
        license = lib.licenses.bsd3;
      }) {};
···
     ({ mkDerivation, base, comonad, deepseq, doctest, Glob, safe }:
      mkDerivation {
        pname = "nonempty-zipper";
-       version = "1.0.0.0";
-       sha256 = "0qqdrp1rr1qmgxxzwn21gy1gc9mwdhliyp72d74bndqr3yki46fm";
+       version = "1.0.0.1";
+       sha256 = "17h070rciwbdk36n68dbin1yv2ybrb2vak9azimfv51z6b6a7b4w";
        libraryHaskellDepends = [ base comonad deepseq safe ];
        testHaskellDepends = [ base comonad deepseq doctest Glob safe ];
        description = "A non-empty comonadic list zipper";
···
          ad base nonlinear-optimization primitive reflection vector
        ];
        description = "Wrapper of nonlinear-optimization package for using with AD package";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "nonlinear-optimization-backprop" = callPackage
···
          reflection vector
        ];
        description = "Wrapper of nonlinear-optimization package for using with backprop package";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "noodle" = callPackage
···
      }:
      mkDerivation {
        pname = "normalization-insensitive";
-       version = "2.0.1";
-       sha256 = "00nbha984yg4lxnpkyd3q0gbywf7xn5z5ixy3cr9ksn05w6blm1v";
-       revision = "4";
-       editedCabalFile = "1p0vxvp44nzjn7big9m3wj8gvffaxz05c46jalm73fwm8cj54iqf";
+       version = "2.0.2";
+       sha256 = "1rr12rrij64hi6jkd42h4x2m86k1ra10ykzpzc38n6rfdhyiswpn";
        libraryHaskellDepends = [
          base bytestring deepseq hashable text unicode-transforms
        ];
···
          base bytestring cassava containers optparse-generic text vector
        ];
        description = "Normalize data using a variety of methods";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "normalize-imports" = callPackage
···
        librarySystemDepends = [ notmuch talloc ];
        libraryToolDepends = [ c2hs ];
        description = "Haskell binding to Notmuch, the mail indexer";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) notmuch; inherit (pkgs) talloc;};
 
   "notmuch-haskell" = callPackage
···
        editedCabalFile = "1lsxi6704g6svw0834haggp6j97kb6r51583lr2a3kn1ni2zh60c";
        libraryHaskellDepends = [ base microlens microlens-th ];
        description = "Flexible and accurate (for a given precision) numerical->string conversion";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "numbered-semigroups" = callPackage
···
        editedCabalFile = "04wkhb2r275nax8wh00w6c4pxfaky190g2bsviw39jyi7wr2f33c";
        libraryHaskellDepends = [ base call-stack semigroups ];
        description = "A sequence of semigroups, for composing stuff in multiple spatial directions";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }) {};
 
   "numeric-prelude" = callPackage
-    ({ mkDerivation, array, base, containers, deepseq, non-negative
-     , parsec, QuickCheck, random, semigroups, storable-record
-     , utility-ht
+  "karver" = callPackage
+     , doctest-exitcode-stdio, doctest-lib, non-negative, parsec
+     , QuickCheck, random, semigroups, storable-record, utility-ht
      }:
      mkDerivation {
        pname = "numeric-prelude";
-       version = "0.4.3.2";
-       sha256 = "1vd777ax2yvxknfxp9isgjk7cabjv3q86dgf3hybv78hc4ji5gmq";
+       version = "0.4.3.3";
+       sha256 = "0kqz3xzg0j3cqaidmdzmg47h564ivp4iz5ys8zs5g41k2wd06ild";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          array base containers deepseq non-negative parsec QuickCheck random
          semigroups storable-record utility-ht
        ];
+       testHaskellDepends = [
+         base doctest-exitcode-stdio doctest-lib QuickCheck random
+         utility-ht
+       ];
        description = "An experimental alternative hierarchy of numeric type classes";
        license = lib.licenses.bsd3;
      }) {};
···
        ];
        testHaskellDepends = [ base bytestring ];
        description = "Fully Automatic Luxury OAuth 1.0a headers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "oauth2-jwt-bearer" = callPackage
···
        ];
        testHaskellDepends = [ base ];
        description = "Communicate to OBD interfaces over ELM327";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          array base bytestring containers hexpr mtl parsec symbol text
        ];
        description = "Lisp with more dynamism, more power, more simplicity";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testToolDepends = [ hspec-discover ];
        description = "memoization for IO actions and functions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "one-line-aeson-text" = callPackage
···
        sha256 = "0xpm2adf47clhzpwd833w706mc5xfxwr2wp4aywigy11687f9bly";
        libraryHaskellDepends = [ base ];
        description = "Support for OO-like prototypes";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "op" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base basic-prelude text turtle ];
        description = "Open haddock HTML documentation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base ];
        description = "Functional interface for OpenGL 4.1+ and OpenGL ES 2.0+";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {EGL = null; GLESv2 = null;};
···
      }) {};
 
   "optparse-applicative" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, bytestring, process
-     , QuickCheck, transformers, transformers-compat
-     }:
-     mkDerivation {
-       pname = "optparse-applicative";
-       version = "0.15.1.0";
-       sha256 = "1ws6y3b3f6hsgv0ff0yp6lw4hba1rps4dnvry3yllng0s5gngcsd";
-       revision = "1";
-       editedCabalFile = "0zmhqkd96v2z1ilhqdkd9z4jgsnsxb8yi2479ind8m5zm9363zr9";
-       libraryHaskellDepends = [
-         ansi-wl-pprint base process transformers transformers-compat
-       ];
-       testHaskellDepends = [ base bytestring QuickCheck ];
-       description = "Utilities and combinators for parsing command line options";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "optparse-applicative_0_16_1_0" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, process, QuickCheck
      , transformers, transformers-compat
      }:
···
        testHaskellDepends = [ base QuickCheck ];
        description = "Utilities and combinators for parsing command line options";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "optparse-applicative-simple" = callPackage
···
 
   "optparse-generic" = callPackage
     ({ mkDerivation, base, bytestring, Only, optparse-applicative
-     , semigroups, system-filepath, text, time, transformers, void
-     }:
-     mkDerivation {
-       pname = "optparse-generic";
-       version = "1.3.1";
-       sha256 = "0c2fhy54mn8h7z5qj3mq1qcdb1ab6bxbpiaaqwrmh7iys41zg6q0";
-       libraryHaskellDepends = [
-         base bytestring Only optparse-applicative semigroups
-         system-filepath text time transformers void
-       ];
-       description = "Auto-generate a command-line parser for your datatype";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "optparse-generic_1_4_4" = callPackage
-    ({ mkDerivation, base, bytestring, Only, optparse-applicative
      , system-filepath, text, time, transformers, void
      }:
      mkDerivation {
···
        ];
        description = "Auto-generate a command-line parser for your datatype";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "optparse-helper" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base parsec regex-compat ];
        description = "Basic org to anki exporter";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "organize-imports" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ attoparsec base text ];
        description = "Organize scala imports";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers universum
        ];
        description = "Statistics visualizer for org-mode";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.mit;
      }) {};
 
+  "ory-kratos" = callPackage
+    ({ mkDerivation, aeson, base, containers, exceptions, http-api-data
+     , http-client, http-client-tls, http-types, mtl, network-uri
+     , servant, servant-client, servant-client-core, servant-server
+     , swagger2, text, time, transformers, uuid, wai, warp
+     }:
+     mkDerivation {
+       pname = "ory-kratos";
+       version = "0.0.5.9";
+       sha256 = "1c4vn8zyv9lakchiip6w80cfxkz7zsgfiwd5mq5dnc6fcsri3c6h";
+       libraryHaskellDepends = [
+         aeson base containers exceptions http-api-data http-client
+         http-client-tls http-types mtl network-uri servant servant-client
+         servant-client-core servant-server swagger2 text time transformers
+         uuid wai warp
+       ];
+       testHaskellDepends = [
+         aeson base containers exceptions http-api-data http-client
+         http-client-tls http-types mtl network-uri servant servant-client
+         servant-client-core servant-server swagger2 text time transformers
+         uuid wai warp
+       ];
+       description = "API bindings for Ory Kratos";
+       license = lib.licenses.asl20;
+     }) {};
+
   "os-release" = callPackage
     ({ mkDerivation, aeson, base, bytestring, filepath, hspec
      , hspec-megaparsec, megaparsec, pretty-simple, safe-exceptions
···
        sha256 = "1452a2y085xbj5q83g6y8f9vrxmlq804i8kyx6rfwyzfvzq5s3ic";
        libraryHaskellDepends = [ base colour gloss random ];
        description = "Implements an osculatory packing (kissing circles) algorithm and display";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          process temporary
        ];
        description = "Better conversion of Oxford Scholarship Online material to PDF";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
        description = "Efficient “spreadsheet table” like maps with multiple marginals";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          optparse-applicative simple-cmd-args text
        ];
        description = "Pagure client";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "pagure-hook-receiver" = callPackage
···
        libraryToolDepends = [ c2hs ];
        description = "Haskell binding for C PAM API";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {pam = null;};
···
     ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
      , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
      , case-insensitive, citeproc, commonmark, commonmark-extensions
-     , commonmark-pandoc, connection, containers, criterion
-     , data-default, deepseq, Diff, directory, doclayout, doctemplates
-     , emojis, exceptions, executable-path, file-embed, filepath, Glob
-     , haddock-library, hslua, hslua-module-system, hslua-module-text
-     , HsYAML, HTTP, http-client, http-client-tls, http-types, ipynb
-     , jira-wiki-markup, JuicyPixels, mtl, network, network-uri
-     , pandoc-types, parsec, process, QuickCheck, random, safe
-     , scientific, SHA, skylighting, skylighting-core, split, syb
-     , tagsoup, tasty, tasty-golden, tasty-hunit, tasty-lua
-     , tasty-quickcheck, temporary, texmath, text, text-conversions
-     , time, unicode-transforms, unix, unordered-containers, weigh, xml
-     , zip-archive, zlib
-     }:
-     mkDerivation {
-       pname = "pandoc";
-       version = "2.11.4";
-       sha256 = "1x8s6gidcij81vcxhj3pday484dyxn3d5s9sz0rh3nfml80cgkyk";
-       configureFlags = [ "-fhttps" "-f-trypandoc" ];
-       isLibrary = true;
-       isExecutable = true;
-       enableSeparateDataOutput = true;
-       libraryHaskellDepends = [
-  "karver" = callPackage
-         blaze-html blaze-markup bytestring case-insensitive citeproc
-         commonmark commonmark-extensions commonmark-pandoc connection
-         containers data-default deepseq directory doclayout doctemplates
-         emojis exceptions file-embed filepath Glob haddock-library hslua
-         hslua-module-system hslua-module-text HsYAML HTTP http-client
-         http-client-tls http-types ipynb jira-wiki-markup JuicyPixels mtl
-         network network-uri pandoc-types parsec process random safe
-         scientific SHA skylighting skylighting-core split syb tagsoup
-         temporary texmath text text-conversions time unicode-transforms
-         unix unordered-containers xml zip-archive zlib
-       ];
-       executableHaskellDepends = [ base ];
-       testHaskellDepends = [
-         base base64-bytestring bytestring containers Diff directory
-         doctemplates exceptions executable-path filepath Glob hslua mtl
-         pandoc-types process QuickCheck tasty tasty-golden tasty-hunit
-         tasty-lua tasty-quickcheck temporary text time xml zip-archive
-       ];
-       benchmarkHaskellDepends = [
-         base bytestring containers criterion mtl text time weigh
-       ];
-       postInstall = ''
-         mkdir -p $out/share/man/man1
-         mv "man/"*.1 $out/share/man/man1/
-       '';
-       description = "Conversion between markup formats";
-       license = lib.licenses.gpl2Plus;
-       maintainers = with lib.maintainers; [ peti ];
-     }) {};
-
-  "pandoc_2_12" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
-     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
-     , case-insensitive, citeproc, commonmark, commonmark-extensions
      , commonmark-pandoc, connection, containers, data-default, deepseq
      , Diff, directory, doclayout, doctemplates, emojis, exceptions
      , executable-path, file-embed, filepath, Glob, haddock-library
···
        '';
        description = "Conversion between markup formats";
        license = lib.licenses.gpl2Plus;
-       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
···
          base directory filepath pandoc-types process text-conversions
        ];
        description = "Insert a preamble before pandoc-citeproc's bibliography";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "pandoc-crossref" = callPackage
···
          utility-ht
        ];
        description = "Pandoc filter for cross-references";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "pandoc-csv2table" = callPackage
     ({ mkDerivation, base, csv, pandoc, pandoc-types, text }:
      mkDerivation {
        pname = "pandoc-csv2table";
-       version = "1.0.8";
-       sha256 = "0sf0af2cx5fi3a2iixkjjdpzp0153hxsjzs5wwqssby39g7s24gb";
+       version = "1.0.9";
+       sha256 = "14ln4i75cpqpjyzhqx0wvsrggvm6ak8rif514r5qwnckjl97v79l";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
          pandoc-types shelly system-fileio system-filepath text
        ];
        description = "Japanese-specific markup filters for pandoc";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "pandoc-plot";
-       version = "1.1.0";
-       sha256 = "1dk9s37z3hah1kiha3q9d1yzl0vfgivdazhdcraivaspzi78iry8";
+       version = "1.1.1";
+       sha256 = "10wwci7p3kphmjxlnpymbnx3cw2l3yfydm29l6k2vakz1pd7zdh0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          mtl pandoc-types tasty tasty-hspec tasty-hunit temporary text
        ];
        description = "A Pandoc filter to include figures generated from Python code blocks";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers Yampa
        ];
        description = "A super-pang clone";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryPkgconfigDepends = [ pango ];
        description = "Binding to the Pango text rendering engine";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {inherit (pkgs) pango;};
 
   "pangraph" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base bytestring containers ];
        description = "A passphrase generator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "090yhbbh2i5lwfwrfml0n54ziy8mz3mgmwnykr4ab06w1ylc2zh4";
        libraryHaskellDepends = [ base ];
        description = "Parallel Parsing Processes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "parsely" = callPackage
···
          random
        ];
        description = "a simple password manager";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          passman-core resourcet text X11 yaml
        ];
        description = "Deterministic password generator command line interface";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
        ];
        doHaddock = false;
        description = "Deterministic password generator core";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
   "password" = callPackage
     ({ mkDerivation, base, base-compat, base64, bytestring, Cabal
-     , cabal-doctest, cryptonite, doctest, memory, QuickCheck
-     , quickcheck-instances, scrypt, tasty, tasty-hunit
-     , tasty-quickcheck, template-haskell, text
-     }:
-     mkDerivation {
-       pname = "password";
-       version = "2.1.1.0";
-       sha256 = "1x3nv3bn0rp0f6rayrzp7yvw7x1ly7vjygcl6wdq86y0k1ca2wby";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         base base64 bytestring cryptonite memory template-haskell text
-       ];
-       testHaskellDepends = [
-         base base-compat bytestring cryptonite doctest memory QuickCheck
-         quickcheck-instances scrypt tasty tasty-hunit tasty-quickcheck
-         template-haskell text
-       ];
-       description = "Hashing and checking of passwords";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "password_3_0_0_0" = callPackage
-    ({ mkDerivation, base, base-compat, base64, bytestring, Cabal
      , cabal-doctest, cryptonite, doctest, memory, password-types
      , QuickCheck, quickcheck-instances, scrypt, tasty, tasty-hunit
      , tasty-quickcheck, template-haskell, text
···
        ];
        description = "Hashing and checking of passwords";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "password-instances" = callPackage
     ({ mkDerivation, aeson, base, base-compat, Cabal, cabal-doctest
-     , doctest, http-api-data, password, persistent, QuickCheck
-     , quickcheck-instances, tasty, tasty-hunit, tasty-quickcheck
-     , template-haskell, text
-     }:
-     mkDerivation {
-       pname = "password-instances";
-       version = "2.0.0.2";
-       sha256 = "03dl3b530m02y7mv2lvssamhakswa3d9bj2r2ndvg78wi0vm5xp1";
-       setupHaskellDepends = [ base Cabal cabal-doctest ];
-       libraryHaskellDepends = [
-         aeson base http-api-data password persistent text
-       ];
-       testHaskellDepends = [
-         aeson base base-compat doctest http-api-data password persistent
-         QuickCheck quickcheck-instances tasty tasty-hunit tasty-quickcheck
-         template-haskell text
-       ];
-       description = "typeclass instances for password package";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "password-instances_3_0_0_0" = callPackage
-    ({ mkDerivation, aeson, base, base-compat, Cabal, cabal-doctest
      , doctest, http-api-data, password, password-types, persistent
      , QuickCheck, quickcheck-instances, tasty, tasty-hunit
      , tasty-quickcheck, template-haskell, text
···
        ];
        description = "typeclass instances for password package";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "password-types" = callPackage
···
      , filepath, mtl, network, network-uri, optparse-applicative, pandoc
      , pandoc-types, process, QuickCheck, skylighting, tasty
      , tasty-hunit, tasty-quickcheck, terminal-size, text, time
-     , unordered-containers, yaml
+     , unordered-containers, wcwidth, yaml
      }:
      mkDerivation {
        pname = "patat";
-       version = "0.8.6.1";
-       sha256 = "1n9qw4wmh7aqmnkqdc6v12rs80vipnszr4744nlkasq6jlzijw0c";
+       version = "0.8.7.0";
+       sha256 = "05bg36lbhqlh80w952hrpy88n99qddv86hiqqbc6p3bc89rlzg1w";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson ansi-terminal ansi-wl-pprint async base base64-bytestring
          bytestring colour containers directory filepath mtl network
          network-uri optparse-applicative pandoc pandoc-types process
-         skylighting terminal-size text time unordered-containers yaml
+         skylighting terminal-size text time unordered-containers wcwidth
+         yaml
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [
          base directory QuickCheck tasty tasty-hunit tasty-quickcheck text
        ];
        description = "Terminal-based presentations using Pandoc";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base directory filepath ghc ghc-paths old-time process
        ];
        description = "pdynload is polymorphic dynamic linking library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers filepath haskeline logict mtl parsec
        ];
        description = "a lazy non-deterministic concatenative programming language";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base optparse-applicative persistent text
        ];
        description = "Transforms persist's quasi-quoted syntax into ER format";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "Type-safe, multi-backend data serialization";
        license = lib.licenses.mit;
+       maintainers = with lib.maintainers; [ psibi ];
+     }) {};
+
+  "persistent_2_11_0_4" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
+     , blaze-html, bytestring, conduit, containers, fast-logger, hspec
+     , http-api-data, monad-logger, mtl, path-pieces, resource-pool
+     , resourcet, scientific, shakespeare, silently, text, time
+     , transformers, unliftio, unliftio-core, unordered-containers
+     , vector
+     }:
+     mkDerivation {
+       pname = "persistent";
+       version = "2.11.0.4";
+       sha256 = "1n5wkhfvyqq6p57nkf9yx73kap6spyzam5w12ni8pmd1m6pk77xn";
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-html bytestring
+         conduit containers fast-logger http-api-data monad-logger mtl
+         path-pieces resource-pool resourcet scientific silently text time
+         transformers unliftio unliftio-core unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-html bytestring
+         containers hspec http-api-data path-pieces scientific shakespeare
+         text time transformers unordered-containers vector
+       ];
+       description = "Type-safe, multi-backend data serialization";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "persistent-mtl_0_2_1_0" = callPackage
+    ({ mkDerivation, base, bytestring, conduit, containers
+     , monad-logger, mtl, persistent, persistent-postgresql
+     , persistent-sqlite, persistent-template, resource-pool, resourcet
+     , tasty, tasty-golden, tasty-hunit, text, transformers, unliftio
+     , unliftio-core, unliftio-pool
+     }:
+     mkDerivation {
+       pname = "persistent-mtl";
+       version = "0.2.1.0";
+       sha256 = "1lwzkxb55bb4ldcwxkkfjfly39bnjjdg01yihl6znx8y3c461yrx";
+       libraryHaskellDepends = [
+         base conduit containers mtl persistent resource-pool resourcet text
+         transformers unliftio unliftio-core unliftio-pool
+       ];
+       testHaskellDepends = [
+         base bytestring conduit containers monad-logger persistent
+         persistent-postgresql persistent-sqlite persistent-template
+         resource-pool resourcet tasty tasty-golden tasty-hunit text
+         unliftio
+       ];
+       description = "Monad transformer for the persistent API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "persistent-mysql" = callPackage
     ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
      , containers, fast-logger, hspec, HUnit, monad-logger, mysql
···
          unordered-containers
        ];
        description = "Persona (BrowserID) library";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          pem persona scotty shakespeare text time transformers unix wai x509
        ];
        description = "Persona (BrowserID) Identity Provider";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          async base ini postgresql-simple random scotty text transformers
        ];
        description = "REST service and library for creating/consuming temporary PostgreSQL databases";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          warp
        ];
        description = "REST service for creating temporary PostgreSQL databases";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers pretty ];
        librarySystemDepends = [ gu pgf ];
        description = "Bindings to the C version of the PGF runtime";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {gu = null; inherit (pkgs) pgf;};
···
        ];
        testSystemDepends = [ pHash ];
        description = "Haskell bindings to pHash, the open source perceptual hash library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {pHash = null;};
 
   "phizzle" = callPackage
···
        ];
        testHaskellDepends = [ base ];
        description = "Library for checking if a given link is in a phishtank json file";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "phoityne" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base mtl SDL transformers ];
        description = "A fractal viewer";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          io-streams mtl network parsec RSA transformers
        ];
        description = "Applied pi-calculus interpreter";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base ];
        description = "Lightweight access control solution for the pijul vcs";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          xdg-basedir
        ];
        description = "Set up port forwarding with the Private Internet Access VPN service";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base hmatrix JuicyPixels vector ];
        executableHaskellDepends = [ base cli hmatrix ];
        description = "simple image manipulation functions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base matrix transformers xml ];
        description = "Converts a svg image to tikz code";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers
        ];
        description = "Back up the notes you've saved to Pinboard";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "pinch" = callPackage
···
        ];
        testHaskellDepends = [ base ];
        description = "A program for turning pixel art into 3D prints";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          http-directory simple-cmd simple-cmd-args text
        ];
        description = "Package tree diff tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "13hqkz0p3c81d7v3qnbcf90cxyb15na9icfjch4hw0222i6kn21i";
        libraryHaskellDepends = [ base bytestring mtl time unix ];
        description = "plaimi's prelude";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base cairo colour fixed-vector gtk hmatrix plot text vector
        ];
        description = "A quick way to use Mathematica like Manipulation abilities";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base colour gtk hmatrix plot text vector
        ];
        description = "A plotting tool with Mathematica like Manipulation abilities";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1csi81i0j3hk2gsc3c0rx939i67b0mj2pi064giw20yspqqjrp27";
        libraryHaskellDepends = [ base requirements ];
        description = "Polykinded extensible records";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "polyToMonoid" = callPackage
···
          process time unix wx wxcore
        ];
        description = "pomodoro timer";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ gdk-pixbuf gtk2 pango poppler_gi ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the Poppler";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) gdk-pixbuf; inherit (pkgs) gtk2; 
···
      }) {};
 
   "postgresql-placeholder-converter" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, hspec
+    ({ mkDerivation, attoparsec, base, bytestring, either-result, hspec
      , hspec-discover, mtl, utf8-string
      }:
      mkDerivation {
        pname = "postgresql-placeholder-converter";
-       version = "0.1.0.0";
-       sha256 = "1dprqv0r00nrx6m0byqfzpb91h5kz3nxd0w0m21150l68sj2d8ys";
-       revision = "1";
-       editedCabalFile = "0mla1cibyc13bz7gvv5b31il8nyp0vjfi8xqgpynbjfq7d4fjnnc";
+       version = "0.2.0.0";
+       sha256 = "0jpsa6c2m0m8d9abki585krf9pvj5p4rsayg1qs963r4vg1m8p23";
        libraryHaskellDepends = [
-         attoparsec base bytestring mtl utf8-string
+         attoparsec base bytestring either-result mtl utf8-string
        ];
        testHaskellDepends = [ base hspec ];
        testToolDepends = [ hspec-discover ];
···
        isExecutable = true;
        executableHaskellDepends = [ base binary bytestring split ];
        description = "Command line Dreamcast VMU filesystem toolset";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          JuicyPixels vector
        ];
        description = "Trace bitmap images to paths using potrace";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "potrace-diagrams" = callPackage
···
        editedCabalFile = "1iwsxi5zkqqjf9wr460bqjpghcvjhpgqgk27a11ji6bpdf6gnhga";
        libraryHaskellDepends = [ base diagrams-lib JuicyPixels potrace ];
        description = "Potrace bindings for the diagrams library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base tasty tasty-hunit tasty-quickcheck vector-space
        ];
        description = "Alternative Show class that gives shorter view if possible";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "prairie" = callPackage
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec ];
        description = "prime number tools";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "primes" = callPackage
···
          xformat
        ];
        description = "Parse process information for Linux";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        editedCabalFile = "1a20ziwki29chw069jqrjm2rb64j4sfxbi7xyqxqd6vh9gpwdmm1";
        libraryHaskellDepends = [ base deepseq mtl time ];
        description = "Functionality for reporting function progress";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "prolens";
-       version = "0.0.0.0";
-       sha256 = "1p4cl83knkvfa11ijw9qb2akz9n8lv9ixawgxwynypygg7vdg9j2";
+       version = "0.0.0.1";
+       sha256 = "0sf9s363gdyhs4qs6z2zqf1ha49qhfx9b1rldj28cgljrxy8jkws";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [
          base doctest hedgehog hspec hspec-hedgehog inspection-testing
···
 
   "proto3-wire" = callPackage
     ({ mkDerivation, base, bytestring, cereal, containers, deepseq
-     , doctest, hashable, QuickCheck, safe, tasty, tasty-hunit
-     , tasty-quickcheck, text, unordered-containers
-     }:
-     mkDerivation {
-       pname = "proto3-wire";
-       version = "1.1.0";
-       sha256 = "1f8vllbysz6d7njkqd6f52k4nixjj4wf2k4nh4gb4b7dihdzhnmg";
-       revision = "1";
-       editedCabalFile = "1ws072947d8lmchknyhrzpg9mh6dacya872a4b9dw0cdgkn13zm8";
-       libraryHaskellDepends = [
-         base bytestring cereal containers deepseq hashable QuickCheck safe
-         text unordered-containers
-       ];
-       testHaskellDepends = [
-         base bytestring cereal doctest QuickCheck tasty tasty-hunit
-         tasty-quickcheck text
-       ];
-       description = "A low-level implementation of the Protocol Buffers (version 3) wire format";
-       license = lib.licenses.asl20;
-     }) {};
-
-  "proto3-wire_1_2_0" = callPackage
-    ({ mkDerivation, base, bytestring, cereal, containers, deepseq
      , doctest, ghc-prim, hashable, parameterized, primitive, QuickCheck
      , safe, tasty, tasty-hunit, tasty-quickcheck, text, transformers
      , unordered-containers, vector
···
        description = "A low-level implementation of the Protocol Buffers (version 3) wire format";
        license = lib.licenses.asl20;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "protobuf" = callPackage
···
          time
        ];
        description = "Computations that automatically track data dependencies";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers stm unix ];
        librarySystemDepends = [ libpulseaudio ];
        description = "A low-level (incomplete) wrapper around the pulseaudio client asynchronous api";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {inherit (pkgs) libpulseaudio;};
 
   "punkt" = callPackage
···
          mtl text
        ];
        description = "A program that displays the puppet resources associated to a node given .pp files.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "purebred-email";
-       version = "0.4.2";
-       sha256 = "18cjifncnxi4c3xxkgvvvay56h2a0zs83505xf1a9fkz5n8iwqby";
+       version = "0.4.3";
+       sha256 = "00jl1n200nfn8iaqqdpa9h77b14r0fd6amsh46h16ad4ky3p2nkj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          tasty-hedgehog tasty-hunit tasty-quickcheck text time
        ];
        description = "types and parser for email messages (including MIME)";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Plus;
      }) {};
 
   "purescheme-wai-routing-core" = callPackage
···
          test-framework-hunit
        ];
        description = "Command line interface for the pwstore library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "pwstore-fast" = callPackage
···
        libraryHaskellDepends = [ base process qtah-generator ];
        librarySystemDepends = [ qtbase ];
        description = "Qt bindings for Haskell - C++ library";
-       license = lib.licenses.lgpl3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       license = lib.licenses.lgpl3Only;
      }) {inherit (pkgs.qt5) qtbase;};
 
   "qtah-examples" = callPackage
···
          base binary bytestring containers filepath hoppy-runtime qtah-qt5
        ];
        description = "Example programs for Qtah Qt bindings";
-       license = lib.licenses.lgpl3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "qtah-generator" = callPackage
···
        ];
        executableHaskellDepends = [ base ];
        description = "Generator for Qtah Qt bindings";
-       license = lib.licenses.lgpl3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "qtah-qt5" = callPackage
···
        libraryToolDepends = [ qtbase ];
        testHaskellDepends = [ base hoppy-runtime HUnit ];
        description = "Qt bindings for Haskell";
-       license = lib.licenses.lgpl3;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       license = lib.licenses.lgpl3Only;
      }) {inherit (pkgs.qt5) qtbase;};
 
   "quack" = callPackage
···
        ];
        executableToolDepends = [ alex happy ];
        description = "Quite Useless DB";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ base ];
        description = "Quenya verb conjugator";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base ieee754 pretty-show QuickCheck ];
        testHaskellDepends = [ base hspec ieee754 QuickCheck ];
        description = "HUnit like assertions for QuickCheck";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "quickcheck-classes" = callPackage
···
          test-framework-quickcheck2
        ];
        description = "QuickLZ compression for ByteStrings";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "quickpull" = callPackage
···
        ];
        executableHaskellDepends = [ base ];
        description = "An interface for describing and executing terminal applications";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "quicktest" = callPackage
···
          servant-server text warp
        ];
        description = "A quick webapp generator for any file processing tool";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers microspec tf-random vector
        ];
        description = "Easy-to-use randomness for livecoding";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers tree-fun
        ];
        description = "Create random trees";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "random-variates" = callPackage
···
          base bytestring cassava containers lens optparse-generic vector
        ];
        description = "Find the rank product of a data set";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "rank1dynamic" = callPackage
···
          base eve hspec lens QuickCheck quickcheck-instances text yi-rope
        ];
        description = "A modular text editor";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          rasa-ext-logger rasa-ext-slate rasa-ext-views rasa-ext-vim yi-rope
        ];
        description = "Example user config for Rasa";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers data-default lens rasa text
        ];
        description = "Rasa Ext for running commands";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base data-default lens mtl rasa text text-lens yi-rope
        ];
        description = "Rasa Ext adding cursor(s)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yi-rope
        ];
        description = "Rasa Ext for filesystem actions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1wv3bkfq92h7b91x88mzqcijbpb2kh7zkgg4ljxdx59qi4lb7hry";
        libraryHaskellDepends = [ base lens mtl rasa ];
        description = "Rasa Ext for logging state/actions";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text vty yi-rope
        ];
        description = "Rasa extension for rendering to terminal with vty";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0grfj3qxlmk63x5cxrbibkhrrgij077f7sr0kj6vcl0np7a5dl98";
        libraryHaskellDepends = [ base data-default lens rasa yi-rope ];
        description = "Rasa Ext for populating status-bar";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "198phwvsndsk149rj744znjzw8w2n0238pbv07d7rfs2c1987s04";
        libraryHaskellDepends = [ base data-default lens rasa ];
        description = "Rasa Ext managing rendering styles";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yi-rope
        ];
        description = "Rasa Ext managing rendering views";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base hspec ];
        description = "Rasa Ext for vim bindings";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "ratel";
-       version = "1.0.13";
-       sha256 = "0ydg5xlf10g1wp18bwpr3mg9x29fyc1c5g22rn4szy0cs6hvqx6m";
+       version = "1.0.14";
+       sha256 = "0yjr8hj5c5i2l4p9zinwvzf33vhn6s9lipndqwx0km4ry0rylwwx";
        libraryHaskellDepends = [
          aeson base bytestring case-insensitive containers http-client
          http-client-tls http-types text uuid
···
      }:
      mkDerivation {
        pname = "ratel-wai";
-       version = "1.1.4";
-       sha256 = "1b2d5agip0zw10nmkr45gwhzpaga9nsdqv62xil11gadhaqji2f7";
+       version = "1.1.5";
+       sha256 = "0afrsnj1sjcr99sw7cpv2l4pn2is9y6qck4lq1vc33h8kk4hr25y";
        libraryHaskellDepends = [
          base bytestring case-insensitive containers http-client ratel wai
        ];
···
      }) {};
 
   "rattletrap" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, array, base, binary
-     , bytestring, caerbannog, containers, filepath, http-client
-     , http-client-tls, HUnit, text, transformers
+    ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
+     , containers, filepath, http-client, http-client-tls, HUnit, text
+     , transformers
      }:
      mkDerivation {
        pname = "rattletrap";
-       version = "10.0.7";
-       sha256 = "1wpxysd23gz2lga6bzg3cx21yxjvcprqgk9xqlg3b5gmj22h2mdg";
+       version = "11.0.0";
+       sha256 = "10xr9fv0xdiz173i5apz29sh66bvya3ris2c7ig2qs8dfbqi165s";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson aeson-pretty array base binary bytestring caerbannog
-         containers filepath http-client http-client-tls text transformers
+         aeson aeson-pretty array base bytestring containers filepath
+         http-client http-client-tls text transformers
        ];
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base bytestring filepath HUnit ];
···
          aeson aeson-pretty base bytestring scotty time transformers
        ];
        description = "react-tutorial web server";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base doctest ];
        description = "home (etc) automation using reactive-banana";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          SDL-ttf
        ];
        description = "Reactive Banana bindings for SDL";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "An alternate implementation of push-pull FRP";
        license = "GPL";
-       platforms = [ "armv7l-linux" ];
+       platforms = lib.platforms.none;
      }) {};
 
   "reactor" = callPackage
···
   "recover-rtti" = callPackage
     ({ mkDerivation, aeson, base, bytestring, containers, ghc-heap
      , ghc-prim, mtl, QuickCheck, sop-core, stm, tasty, tasty-quickcheck
-     , text, vector
+     , text, unordered-containers, vector
      }:
      mkDerivation {
        pname = "recover-rtti";
-       version = "0.1.0.0";
-       sha256 = "19bf4279nfq8sv20v56sah30mv2g10zy2yxcylhc33w85d9jkisl";
+       version = "0.3.0.0";
+       sha256 = "0zk08jzsww8sv3q9h1mnc6a8ckqlf3lvc5cxwfbni7rb9giz6zia";
        libraryHaskellDepends = [
          aeson base bytestring containers ghc-heap mtl sop-core stm text
+         unordered-containers vector
        ];
        testHaskellDepends = [
          aeson base bytestring containers ghc-heap ghc-prim mtl QuickCheck
-         sop-core stm tasty tasty-quickcheck text vector
+         sop-core stm tasty tasty-quickcheck text unordered-containers
+         vector
        ];
        description = "Recover run-time type information from the GHC heap";
        license = lib.licenses.bsd3;
···
        version = "0.1.0.0";
        sha256 = "0lraykl190x0cj65z495c11vi4pcg3g8gz1bdgdndf6662lp56x9";
        libraryHaskellDepends = [ base crypto-api ];
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "ref" = callPackage
···
        sha256 = "1cvffbx2vhv18k4p95p0ddcxzyn8f10hg2bxa2da60fy9zkjg3am";
        libraryHaskellDepends = [ base parsec ];
        description = "The parser and render to parsec and render the string";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "regex-pcre-builtin";
-       version = "0.95.1.3.8.43";
-       sha256 = "0n1sbsjch0n5cgv2lhw2yfaxb611mckyg0jpz2kcbyj5hcrvzv3c";
-       libraryHaskellDepends = [
-         array base bytestring containers regex-base text
-       ];
-       description = "PCRE Backend for \"Text.Regex\" (regex-base)";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "regex-pcre-builtin_0_95_2_3_8_43" = callPackage
-    ({ mkDerivation, array, base, bytestring, containers, regex-base
-     , text
-     }:
-     mkDerivation {
-       pname = "regex-pcre-builtin";
        version = "0.95.2.3.8.43";
        sha256 = "02c6vzxcy1zkqwy6w4dsc97xvvdwlh8xr7imrlx2qs2521rvswr7";
        libraryHaskellDepends = [
···
        ];
        description = "PCRE Backend for \"Text.Regex\" (regex-base)";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "regex-pcre-text" = callPackage
···
        sha256 = "1y4vmiq1xksxxd84yvyark6axsz51ywb6slswbddlxbdpcpfday7";
        doHaddock = false;
        description = "\"Regex for Windows\" C library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {};
 
   "regex-posix-unittest" = callPackage
···
        pname = "relation";
        version = "0.5.2.0";
        sha256 = "1sinb0rw2jq1xjy80rsxnjf5va33n2i67km55hxfls9w15wsg2yw";
+       revision = "1";
+       editedCabalFile = "18nh56qp1cjpg28sagwiy4h44v5dvm5rhm3wqyyz4mw3k78x71kh";
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [
          base containers doctest doctest-discover hedgehog hspec
···
        license = lib.licenses.mit;
      }) {};
 
+  "relude_1_0_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, containers, criterion, deepseq
+     , doctest, ghc-prim, Glob, hashable, hedgehog, mtl, stm, text
+     , transformers, unordered-containers
+     }:
+     mkDerivation {
+       pname = "relude";
+       version = "1.0.0.1";
+       sha256 = "0cw9a1gfvias4hr36ywdizhysnzbzxy20fb3jwmqmgjy40lzxp2g";
+       libraryHaskellDepends = [
+         base bytestring containers deepseq ghc-prim hashable mtl stm text
+         transformers unordered-containers
+       ];
+       testHaskellDepends = [
+         base bytestring containers doctest Glob hedgehog text
+       ];
+       benchmarkHaskellDepends = [ base criterion unordered-containers ];
+       description = "Safe, performant, user-friendly and lightweight Haskell Standard Library";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "remark" = callPackage
     ({ mkDerivation, base, GenericPretty, tasty, tasty-golden
      , tasty-hunit
···
        sha256 = "1s0s3p0dy07222ks83w3spfw9df33q5lggqv3dw4m9hd5x16a6zi";
        libraryHaskellDepends = [ base ];
        description = "Abstraction to manage user defined Type Errors";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "rere" = callPackage
···
      }:
      mkDerivation {
        pname = "rescue";
-       version = "0.4.0";
-       sha256 = "0hv2q8mkd94ksxgvijn83bkxf9lgnqn92g6k4ryl05z21sc8wl8d";
+       version = "0.4.2.1";
+       sha256 = "096wlxiz8bjvjpnp68qzmkplddm3nh5417b3amn9x6kj7wvbf1ky";
        libraryHaskellDepends = [
          base exceptions ghc mtl text transformers transformers-base
          world-peace
···
          base bytestring directory filepath tasty tasty-hunit
        ];
        description = "Domain Name Service (DNS) lookup via the libresolv standard library routines";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
      }) {};
 
···
          optparse-applicative process unix
        ];
        description = "Remove trivial conflict markers in a git repository";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring containers tasty tasty-hunit temporary text
        ];
        description = "Easy Git repository serialization";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "restricted-workers" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ array base process ];
        description = "Text-only reversi (aka othelo) game";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base simple-cmd ];
        description = "Bugzilla query tool";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ ansi-terminal base options time ];
        description = "Ring-LWE/LWR challenges using Lol";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          monad-control mtl process resourcet text time unix
        ];
        description = "A build daemon for Haskell development";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base optparse-applicative random regex-applicative
        ];
        description = "Playing with applicatives and dice!";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          wreq
        ];
        description = "Query the namecoin blockchain";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "rose" = callPackage
···
          base containers deepseq minilens mtl transformers
        ];
        description = "Trees with polymorphic paths to nodes, combining properties of Rose Trees and Tries";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryToolDepends = [ c2hs ];
        description = "Bindings to librtlsdr";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) rtl-sdr;};
 
   "rtnetlink" = callPackage
···
          QuickCheck temporary utf8-string
        ];
        description = "Parsing and manipulation of rtorrent state file contents";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "rts-loader" = callPackage
···
        ];
        executableHaskellDepends = [ base Cabal process ];
        description = "Dynamically load Haskell libraries";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryToolDepends = [ c2hs ];
        testHaskellDepends = [ base ];
        description = "Binding to the C++ audio stretching library Rubber Band";
-       license = lib.licenses.gpl3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       license = lib.licenses.gpl3Only;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) rubberband;};
 
   "ruby-marshal" = callPackage
···
          base cmdargs directory filepath old-time process
        ];
        description = "runghc replacement for fast repeated runs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "runhs" = callPackage
···
        ];
        testHaskellDepends = [ base basic-prelude tasty tasty-hunit ];
        description = "SwiftNav's SBP Library";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "sbp2udp" = callPackage
···
          base hspec scalpel scalpel-core tagsoup text uri
        ];
        description = "scalpel scrapers for search engines";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          options text text-icu transformers wai warp
        ];
        description = "Find the ideal lesson layout";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base groom hspec msgpack-binary QuickCheck
        ];
        description = "Encoding-independent schemas for Haskell data types";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base ditto ditto-lucid lucid scotty text
        ];
        description = "Html form validation using `ditto`";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-quickcheck2 text validation
        ];
        description = "Scrape websites for changes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          vector
        ];
        description = "scroll(6), a roguelike game";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "scrypt" = callPackage
···
          base Cabal hspec hspec-core lrucache QuickCheck stm
        ];
        description = "image compositing with sdl2 - declarative style";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ SDL2_mixer ];
        description = "Bindings to SDL2_mixer";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) SDL2_mixer;};
 
   "sdl2-sprite" = callPackage
···
        libraryPkgconfigDepends = [ SDL2 SDL2_ttf ];
        description = "Bindings to SDL2_ttf";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;};
 
   "sdnv" = callPackage
···
          base containers diagrams-cairo diagrams-lib haskell-qrencode random
        ];
        description = "Secret Santa game assigner using QR-Codes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework test-framework-quickcheck2 vector
        ];
        description = "Information-theoretic secure secret sharing";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {};
 
   "secrm" = callPackage
···
        ];
        librarySystemDepends = [ sedna ];
        description = "Sedna C API XML Binding";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {sedna = null;};
···
      }:
      mkDerivation {
        pname = "selective";
-       version = "0.4.1.1";
-       sha256 = "1ix9080g4qcs3w89bmilr6f84kg6vw9hyx5cs5hiw9xnp7dh4sdc";
+       version = "0.4.2";
+       sha256 = "1mg5hnr3f4zjh3ajy16jkxj630rnfa9iqnnmpjqd9gkjdxpssd5l";
        libraryHaskellDepends = [ base containers transformers ];
        testHaskellDepends = [
          base containers mtl QuickCheck tasty tasty-expected-failure
···
        ];
        executableHaskellDepends = [ base ];
        description = "Evaluate code snippets in Literate Haskell";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testToolDepends = [ hspec-discover ];
        description = "SmartyPants for Korean language";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-hunit transformers vector
        ];
        description = "A package with basic parsing utilities for several Bioinformatic data formats";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "sequenceTools" = callPackage
···
          base bytestring hspec pipes sequence-formats vector
        ];
        description = "A package with tools for processing DNA sequencing data";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "sequent-core" = callPackage
···
        ];
        testHaskellDepends = [ base hspec QuickCheck servant-server text ];
        description = "Type-safe pagination for Servant APIs";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, servant-client-core, servant-rawm }:
      mkDerivation {
        pname = "servant-rawm-client";
-       version = "1.0.0.1";
-       sha256 = "0ldjhmmfdh0jpfaz4sg1b9n5l23wza3w0m8bvvf80gvl7p6fk0fj";
+       version = "1.0.0.2";
+       sha256 = "08b52fzg1q2p8r58cwbjfc2ixrsxhv1hpzh99wb276s6bka4m9lr";
        libraryHaskellDepends = [ base servant-client-core servant-rawm ];
        description = "The client implementation of servant-rawm";
        license = lib.licenses.bsd3;
···
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base directory exceptions hspec ];
        description = "Session types library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base distributed-process hspec network-transport-tcp sessiontypes
        ];
        description = "Session types distributed";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-hunit test-framework-quickcheck2
        ];
        description = "S-Expression parsing/printing made fun and easy";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "Build rules for historical benchmarking";
        license = lib.licenses.asl20;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       maintainers = with lib.maintainers; [ maralorn ];
      }) {};
 
   "shake-bindist" = callPackage
···
        ];
        executableHaskellDepends = [ base shake ];
        description = "Shake build system on-disk caching";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          hmatrix JuicyPixels random random-shuffle split vector
        ];
        description = "Machine Learning algorithms";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "19zjwzh3i8ql5xz9rvmbz7n2l3z7dcq683ikrpvqx3wxnc06058m";
        libraryHaskellDepends = [ base ];
        description = "Sieve is an implementation of the Sieve abstract data type";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "sifflet" = callPackage
···
      }:
      mkDerivation {
        pname = "signable";
-       version = "0.3";
-       sha256 = "1bh4i93333s3yldn4nnl4xv4gb92ggdwap6im9f259cfg1v22d2q";
+       version = "0.4";
+       sha256 = "0fzf3zijr61ifqbxkmkzii8vbl5h04ydpzc24z5ixvcq94yfzlgx";
        libraryHaskellDepends = [
          asn1-encoding asn1-types base binary bytestring casing cryptonite
          memory microlens pem proto-lens proto-lens-runtime
···
          unordered-containers vector wai wai-extra
        ];
        description = "A minimalist web framework for the WAI server interface";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "simple-actors" = callPackage
···
        libraryHaskellDepends = [ base parsec text transformers ];
        executableHaskellDepends = [ base text ];
        description = "Evaluate a Text to an Integer: \"1 + 1\" -> 2";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          resource-pool simple transformers
        ];
        description = "Connector package for integrating postgresql-orm with the Simple web framework";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "simple-reflect" = callPackage
···
          cookie cryptohash http-types simple transformers wai wai-extra
        ];
        description = "Cookie-based session management for the Simple web framework";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "simple-sessions" = callPackage
···
          aeson attoparsec base hspec HUnit scientific vector
        ];
        description = "A basic template language for the Simple web framework";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "simple-text-format" = callPackage
···
          transformers vector vty
        ];
        description = "UI library for terminal";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base directory filepath mtl process random regex-compat split time
        ];
        description = "A simple markup language that translates to LaTeX";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "simplex-basic" = callPackage
···
        sha256 = "0a8414006gdya8b4dw38251kim3x2i5g7m03ga479ialghralrc8";
        libraryHaskellDepends = [ base containers ];
        description = "Load data organized in a tree";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "since" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "singleton-nats_0_4_6" = callPackage
+    ({ mkDerivation, base, singletons, singletons-base }:
+     mkDerivation {
+       pname = "singleton-nats";
+       version = "0.4.6";
+       sha256 = "1drjwwkpszgifhnd7p4qqz92z85nh7w81w1hpdqv9a6vc5hfbv7r";
+       libraryHaskellDepends = [ base singletons singletons-base ];
+       description = "Unary natural numbers relying on the singletons infrastructure";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "singleton-typelits" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "singletons_3_0" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "singletons";
+       version = "3.0";
+       sha256 = "1zrnmdv00i9lyrqvbvljx24lvi49p11m5gbvh1xc2ygnhgb6xmx5";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base ];
+       description = "Basic singleton types and definitions";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "singletons-base" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, deepseq, directory
+     , filepath, pretty, process, singletons, singletons-th, tasty
+     , tasty-golden, template-haskell, text, th-desugar, turtle
+     }:
+     mkDerivation {
+       pname = "singletons-base";
+       version = "3.0";
+       sha256 = "0syrh4f9rs4g643c90md1vqrpr6p8h8g8sh4x3j2dld12yvrw4wn";
+       setupHaskellDepends = [ base Cabal directory filepath ];
+       libraryHaskellDepends = [
+         base pretty singletons singletons-th template-haskell text
+         th-desugar
+       ];
+       testHaskellDepends = [
+         base bytestring deepseq filepath process tasty tasty-golden text
+         turtle
+       ];
+       description = "A promoted and singled version of the base library";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "singletons-presburger" = callPackage
-    ({ mkDerivation, base, ghc, ghc-typelits-presburger, mtl
-     , reflection, singletons
+    ({ mkDerivation, base, ghc-typelits-presburger, mtl, reflection
+     , singletons
      }:
      mkDerivation {
        pname = "singletons-presburger";
-       version = "0.5.0.0";
-       sha256 = "0pc95rg9vbcgzw6bzsj41vbz3h85p4lhf1ry8ik6l8c2nz3ga6bb";
+       version = "0.6.0.0";
+       sha256 = "1yg1l770c2817yhm569ij5rb8l15c69p5f68i0vrdd8kwpv1ka63";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base ghc ghc-typelits-presburger mtl reflection singletons
+         base ghc-typelits-presburger mtl reflection singletons
        ];
        description = "Presburger Arithmetic Solver for GHC Type-level natural numbers with Singletons package";
        license = lib.licenses.bsd3;
      }) {};
 
+  "singletons-th" = callPackage
+    ({ mkDerivation, base, containers, ghc-boot-th, mtl, singletons
+     , syb, template-haskell, th-desugar, th-orphans, transformers
+     }:
+     mkDerivation {
+       pname = "singletons-th";
+       version = "3.0";
+       sha256 = "1c0w7sg0lbpizrzns4g55wxsk5jm8wlqw0w9rz4jzqwy15byb572";
+       libraryHaskellDepends = [
+         base containers ghc-boot-th mtl singletons syb template-haskell
+         th-desugar th-orphans transformers
+       ];
+       description = "A framework for generating singleton types";
+       license = lib.licenses.bsd3;
+     }) {};
+
   "singnal" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        sha256 = "16f0grf63wgkaab64mmqhxwwk50pzzy354i3v23lzw7s5x0bk8sj";
        libraryHaskellDepends = [ base ];
        description = "Singnal";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "skylighting" = callPackage
     ({ mkDerivation, base, binary, blaze-html, bytestring, containers
-     , directory, filepath, pretty-show, skylighting-core, text
+     , pretty-show, skylighting-core, text
      }:
      mkDerivation {
        pname = "skylighting";
-       version = "0.10.4";
-       sha256 = "057nrlm714r78rfdrqyy4zjl50npvz5qaprrb9nfwdiyb50nyz2j";
+       version = "0.10.4.1";
+       sha256 = "1a1s0fvfbq9q4fy72192mh9sdxz81cpl2z6ghsbh7prfl2kbqsiv";
        configureFlags = [ "-fexecutable" ];
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         base binary bytestring containers skylighting-core
+         base binary containers skylighting-core
        ];
        executableHaskellDepends = [
-         base blaze-html bytestring containers directory filepath
-         pretty-show text
+         base blaze-html bytestring containers pretty-show text
        ];
        description = "syntax highlighting library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
+     }) {};
+
+  "skylighting_0_10_5" = callPackage
+    ({ mkDerivation, base, binary, blaze-html, bytestring, containers
+     , pretty-show, skylighting-core, text
+     }:
+     mkDerivation {
+       pname = "skylighting";
+       version = "0.10.5";
+       sha256 = "09f21wkw8n5bjdn5bbrqphq4f44gipd1cb9b0ikjn9zrggglfnx9";
+       configureFlags = [ "-fexecutable" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base binary containers skylighting-core
+       ];
+       executableHaskellDepends = [
+         base blaze-html bytestring containers pretty-show text
+       ];
+       description = "syntax highlighting library";
+       license = lib.licenses.gpl2Only;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "skylighting-core" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
      , base64-bytestring, binary, blaze-html, bytestring
      , case-insensitive, colour, containers, criterion, Diff, directory
-     , filepath, HUnit, mtl, pretty-show, QuickCheck, random, safe
-     , tasty, tasty-golden, tasty-hunit, tasty-quickcheck, text
-     , transformers, utf8-string, xml-conduit
+     , filepath, mtl, pretty-show, QuickCheck, safe, tasty, tasty-golden
+     , tasty-hunit, tasty-quickcheck, text, transformers, utf8-string
+     , xml-conduit
      }:
      mkDerivation {
        pname = "skylighting-core";
-       version = "0.10.4";
-       sha256 = "0b5cbwsr5mnl4wppxw8rwy4a14pk6s804c4qwf1cd2vzz9j64dag";
+       version = "0.10.4.1";
+       sha256 = "07pnwixyi4v24412j6fs2j5kip2j2rx5fakpdiczffwma4jagv73";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          filepath mtl safe text transformers utf8-string xml-conduit
        ];
        testHaskellDepends = [
-         aeson base bytestring containers Diff directory filepath HUnit
-         pretty-show QuickCheck random tasty tasty-golden tasty-hunit
-         tasty-quickcheck text utf8-string
+         aeson base bytestring containers Diff directory filepath
+         pretty-show QuickCheck tasty tasty-golden tasty-hunit
+         tasty-quickcheck text
        ];
        benchmarkHaskellDepends = [
          base containers criterion directory filepath text
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "skylighting-core_0_10_5" = callPackage
+    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
+     , base64-bytestring, binary, blaze-html, bytestring
+     , case-insensitive, colour, containers, criterion, Diff, directory
+     , filepath, mtl, pretty-show, QuickCheck, safe, tasty, tasty-golden
+     , tasty-hunit, tasty-quickcheck, text, transformers, utf8-string
+     , xml-conduit
+     }:
+     mkDerivation {
+       pname = "skylighting-core";
+       version = "0.10.5";
+       sha256 = "1iaisswfg8ab6rd11002390jfxr309qyvlm85h57mi8svwxk09x2";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson ansi-terminal attoparsec base base64-bytestring binary
+         blaze-html bytestring case-insensitive colour containers directory
+         filepath mtl safe text transformers utf8-string xml-conduit
+       ];
+       testHaskellDepends = [
+         aeson base bytestring containers Diff directory filepath
+         pretty-show QuickCheck tasty tasty-golden tasty-hunit
+         tasty-quickcheck text
+       ];
+       benchmarkHaskellDepends = [
+         base containers criterion directory filepath text
+       ];
+       description = "syntax highlighting library";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "skylighting-extensions" = callPackage
     ({ mkDerivation, base, containers, skylighting, skylighting-modding
      , text
···
        libraryHaskellDepends = [ base time ];
        executableHaskellDepends = [ base time ];
        description = "zZzzZz";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "slice-cpp-gen" = callPackage
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "slist_0_2_0_0" = callPackage
+    ({ mkDerivation, base, containers, doctest, Glob, hedgehog, hspec
+     , hspec-hedgehog
+     }:
+     mkDerivation {
+       pname = "slist";
+       version = "0.2.0.0";
+       sha256 = "1aiswwh33rxp49adhjygyjrhivsflafz5z0kyv3wfnb0wk15jv96";
+       libraryHaskellDepends = [ base containers ];
+       testHaskellDepends = [
+         base doctest Glob hedgehog hspec hspec-hedgehog
+       ];
+       description = "Sized list";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "sloane" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
      , bloomfilter, bytestring, conduit, conduit-extra, containers
···
          base Chart Chart-cairo colour data-default-class lens
        ];
        description = "Visualize mathematical function's slope fields";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "slot-lambda" = callPackage
···
        testHaskellDepends = [ base containers hspec QuickCheck ];
        benchmarkHaskellDepends = [ base criterion time ];
        description = "Symbolic Model Checking for Dynamic Epistemic Logic";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          template-haskell
        ];
        description = "A type-safe interface to communicate with an SMT solver";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          mtl smtlib2 smtlib2-pipe text
        ];
        description = "Dump the communication with an SMT solver for debugging purposes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base Cabal cabal-test-quickcheck smtlib2 smtlib2-quickcheck
        ];
        description = "A type-safe interface to communicate with an SMT solver";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers dependent-map dependent-sum mtl QuickCheck smtlib2
        ];
        description = "Helper functions to create SMTLib expressions in QuickCheck";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "12828gfip43pwjwnhd0smvkz1ar71gbp4lkv3njli6yp5dbcwfi5";
        libraryHaskellDepends = [ base dependent-sum mtl smtlib2 time ];
        description = "Get timing informations for SMT queries";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "Serve Elm files through the Snap web framework";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "snap-error-collector" = callPackage
···
          snap snap-core
        ];
        description = "CoffeeScript for Snap, auto-compilation and pre-compilation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        testHaskellDepends = [ base hspec-snap hspec2 lens snap text ];
        description = "Lexical Style Sheets - Snap Web Framework adaptor";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "snaplet-mandrill" = callPackage
···
          sednaDBXML snap
        ];
        description = "Snaplet for Sedna Bindings. Essentailly a rip of snaplet-hdbc.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base classy-prelude containers lens linear mtl ncurses transformers
        ];
        description = "Tiny, declarative wrapper around ncurses";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers directory filepath HsSyck parsec safe spoonutil
        ];
        description = "The Simple Nice-Looking Manual Generator";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          optparse-applicative parsec random
        ];
        description = "Strategic board game of medium complexity";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring containers gl-capture GLUT OpenGL OpenGLRaw random
        ];
        description = "randomized fractal snowflakes demo";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "snowtify" = callPackage
···
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [ base cairo gtk old-time stm ];
        description = "GUI functions as used in the book \"The Haskell School of Expression\"";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec HUnit QuickCheck ];
        description = "Generate string for sort key";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "sorting" = callPackage
···
      }) {};
 
   "spacecookie" = callPackage
-    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
-     , directory, fast-logger, filepath, hxt-unicode, mtl, socket
-     , systemd, transformers, unix
+    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
+     , containers, directory, download-curl, fast-logger
+     , filepath-bytestring, hxt-unicode, mtl, process, socket, systemd
+     , tasty, tasty-expected-failure, tasty-hunit, text, transformers
+     , unix
      }:
      mkDerivation {
        pname = "spacecookie";
-       version = "0.2.1.2";
-       sha256 = "0cb51kji78vfg17mcnz3a5jlfbnyavh880x09b18y9syqwx4in7l";
+       version = "1.0.0.0";
+       sha256 = "0v61n5afcrfmj7dd51h4wi7d5hzl4r86wvaymhsi3h4jday58ln0";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         attoparsec base bytestring containers directory fast-logger
-         filepath hxt-unicode mtl socket transformers unix
+         async attoparsec base bytestring containers directory
+         filepath-bytestring hxt-unicode mtl socket text transformers unix
        ];
        executableHaskellDepends = [
-         aeson attoparsec base bytestring containers directory filepath mtl
-         socket systemd transformers unix
+         aeson attoparsec base bytestring containers directory fast-logger
+         filepath-bytestring mtl socket systemd text transformers unix
        ];
-       description = "Gopher Library and Server Daemon";
-       license = lib.licenses.gpl3;
+       testHaskellDepends = [
+         attoparsec base bytestring containers directory download-curl
+         filepath-bytestring process tasty tasty-expected-failure
+         tasty-hunit
+       ];
+       description = "Gopher server library and daemon";
+       license = lib.licenses.gpl3Only;
        maintainers = with lib.maintainers; [ sternenseemann ];
      }) {};
 
···
        ];
        testHaskellDepends = [ base ];
        description = "An SPARQL 1.1 Protocol client library.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "sparrow" = callPackage
···
          mwc-random primitive QuickCheck scientific
        ];
        description = "Numerical computing in native Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "sparse-tensor" = callPackage
···
          tasty-quickcheck vector-space
        ];
        description = "Rotate about any suitable axis";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "spawn" = callPackage
···
          sparse-linear-algebra statistics vector
        ];
        description = "Library for spectral clustering";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty tasty-hunit tasty-quickcheck vector
        ];
        description = "A parallel implementation of the Sorokina/Zeilfelder spline scheme";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base directory extensible-exceptions filepath parsec
        ];
        description = "Spoon's utilities. Simple testing and nice looking error reporting.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          temporary text time vty
        ];
        description = "text UI for scanning with SANE";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0b6y8yi0cfisi58pxxx1gnd1vab2i8f5wb3gzv1dfsxx5hl6jlwf";
        libraryHaskellDepends = [ base MissingH ];
        description = "Reusable static analysis interfaces and modules";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "statistics" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base statistics text vector ];
        description = "command line statistics";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring monad-control mtl network random
        ];
        description = "StatsD API";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          aeson base base64-bytestring binary bytestring split text
        ];
        description = "Parse Structured Test Data Format (STDF)";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base mtl process stm unix ];
        testHaskellDepends = [ base QuickCheck stm ];
        description = "Simple STM Promises for IO computations and external processes";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base Chart Chart-cairo containers mtl random
        ];
        description = "Monadic composition of probabilistic functions and sampling";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "store";
-       version = "0.7.9";
-       sha256 = "189ygrm1ycyyklh77a9vhdvw86gbhjba0kl8kj7z1b79sw8q4v4g";
+       version = "0.7.10";
+       sha256 = "0026bjff7nsw23i1l5427qnvw69ncbii5s2q1nshkrs1nrspb0i2";
        libraryHaskellDepends = [
          array async base base-orphans base64-bytestring bifunctors
          bytestring containers contravariant cryptohash deepseq directory
···
          unordered-containers vector
        ];
        description = "Client for Stratum protocol";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "streamly";
        version = "0.7.3";
        sha256 = "11bjyyqc745igw7122284fjph0922l56jddnhfy5h7w84nj35ck3";
+       revision = "1";
+       editedCabalFile = "1fbhk59p5hjkxf4dnghs8wb70pyv0kx6br5sf4csf4vk1rkqyljw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "strive";
-       version = "5.0.13";
-       sha256 = "137kqb3lvqyzvarcgvc8ifphj2927z01pcl752sna9vcvj7q7wp6";
+       version = "5.0.14";
+       sha256 = "0a9hnrl7ww92ki1z4qa8m2smxlc0gq2a856w706ayzzfkma5dxil";
        libraryHaskellDepends = [
          aeson base bytestring data-default gpolyline http-client
          http-client-tls http-types template-haskell text time transformers
···
          testing-feat
        ];
        description = "Instantiate structural induction schemas for algebraic data types";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "structured-cli";
-       version = "2.6.0.0";
-       sha256 = "1g0yq5kxidmh4x0izvspafhhir64krw986s0a5rkbvkjk7ahvm7y";
-       revision = "1";
-       editedCabalFile = "0gmviyrihzpm27s91ygs5fzdawk33aqw74dyasn354kfczq5vza7";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         base data-default exceptions haskeline mtl split transformers
-       ];
-       executableHaskellDepends = [ base data-default mtl split ];
-       description = "Application library for building interactive console CLIs";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "structured-cli_2_7_0_1" = callPackage
-    ({ mkDerivation, base, data-default, exceptions, haskeline, mtl
-     , split, transformers
-     }:
-     mkDerivation {
-       pname = "structured-cli";
        version = "2.7.0.1";
        sha256 = "18l4jy328djmrwhmcmli73592qlld85fwbwby95mghwdbdy2i68g";
        isLibrary = true;
···
        executableHaskellDepends = [ base data-default mtl split ];
        description = "Application library for building interactive console CLIs";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "structured-haskell-mode" = callPackage
···
      }:
      mkDerivation {
        pname = "subcategories";
-       version = "0.1.0.0";
-       sha256 = "0rrvlwfyjmv4wpvm9dbr4vxbmlr24pzdfwvz3hkshgxnrc58gslw";
+       version = "0.1.1.0";
+       sha256 = "09ri226jxcig4f3jxcjh63skvv48myis58ffj7zrmr12sfzkb279";
        libraryHaskellDepends = [
          base containers data-default foldl hashable mono-traversable
          pointed primitive reflection semialign template-haskell text these
···
          base containers lens mtl parsec pretty template-haskell
        ];
        description = "Toolchain of subleq computer";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base cmark hlint hspec template-haskell text
        ];
        description = "Extract a part from CommonMark/Markdown docs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring cassava containers optparse-generic text vector
        ];
        description = "Subsample data";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base containers ];
        testHaskellDepends = [ base containers hspec ];
        description = "Helps when going \"seed values\" -> alternatives and optional -> answers";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "success" = callPackage
···
        libraryHaskellDepends = [ base vector ];
        executableHaskellDepends = [ base HUnit ];
        description = "n log n implementation of suffix array";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "19fr1lzp8j0hmqqy1hyx85gmkgxc2hy8cz5zv6jlvni0qqibiksz";
        libraryHaskellDepends = [ array base ];
        description = "A support vector machine written in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "svm-light-utils" = callPackage
···
          random-shuffle readline system-fileio system-filepath text
        ];
        description = "Clojure without alphanumerics";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework test-framework-hunit text time
        ];
        description = "A semantic web toolkit";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
      }) {};
 
   "swiss-ephemeris" = callPackage
···
      }:
      mkDerivation {
        pname = "swiss-ephemeris";
-       version = "1.2.1.0";
-       sha256 = "0mbq3mzplxnnpr1zqbgg6k1ggh0fw4xlzvyg74rid863dxcldjpm";
+       version = "1.2.1.1";
+       sha256 = "1k584gv36xgj87qbrvcl5w9v8z2k7y4csmz737d5r2a8mvf8sf33";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base directory hspec QuickCheck ];
        testToolDepends = [ hspec-discover ];
        description = "Haskell bindings for the Swiss Ephemeris C library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text transformers
        ];
        description = "Library for Typed Tagless-Final Higher-Order Composable DSL";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty tasty-golden text time transformers treeseq
        ];
        description = "Library for reading and writing Atom";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1yvlvsr38b1ydplpz1jldy816sngmic273iajcmhr73rlyzk5y3d";
        libraryHaskellDepends = [ base ];
        description = "Basic symantics for writing Embedded Domain-Specific Languages (EDSL)";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "symantic-cli" = callPackage
···
          transformers
        ];
        description = "Symantics for parsing and documenting a CLI";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers tasty tasty-hunit text transformers
        ];
        description = "Document symantics";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "symantic-grammar" = callPackage
···
          base megaparsec tasty tasty-hunit text transformers
        ];
        description = "Library for symantic grammars";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "symantic-http" = callPackage
···
          text transformers
        ];
        description = "Symantic combinators for deriving clients or a server from an HTTP API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          symantic-http text time transformers word8
        ];
        description = "symantic-http applied to the derivation of HTTP clients";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          time transformers wai wai-extra warp
        ];
        description = "Demo for symantic-http and its companion libraries";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          symantic-http text time transformers word8
        ];
        description = "Streaming support through pipes for symantic-http";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text time transformers wai warp word8
        ];
        description = "symantic-http applied to the derivation of HTTP servers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers wai wai-extra warp
        ];
        description = "Test symantic-http and its companion libraries";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          tasty-hunit text transformers
        ];
        description = "Symantics for common types";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          symantic-base tasty tasty-golden text transformers treeseq
        ];
        description = "Library for reading, validating and writing XML";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          ansi-terminal base monad-loops random
        ];
        description = "Minimal implementation(s) of the classic electronic memory game";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "sync" = callPackage
···
      }) {};
 
   "tasty" = callPackage
-    ({ mkDerivation, ansi-terminal, async, base, clock, containers, mtl
-     , optparse-applicative, stm, tagged, unbounded-delays, unix
-     , wcwidth
-     }:
-     mkDerivation {
-       pname = "tasty";
-       version = "1.2.3";
-       sha256 = "0qpn0avpw4w1qq5r2gwh2piipj0llqq6ylagr3xnqiraq6mhg8cc";
-       libraryHaskellDepends = [
-         ansi-terminal async base clock containers mtl optparse-applicative
-         stm tagged unbounded-delays unix wcwidth
-       ];
-       description = "Modern and extensible testing framework";
-       license = lib.licenses.mit;
-     }) {};
-
-  "tasty_1_4_1" = callPackage
     ({ mkDerivation, ansi-terminal, base, clock, containers, mtl
      , optparse-applicative, stm, tagged, unbounded-delays, unix
      , wcwidth
···
        ];
        description = "Modern and extensible testing framework";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-ant-xml" = callPackage
···
      }:
      mkDerivation {
        pname = "tasty-ant-xml";
-       version = "1.1.7";
-       sha256 = "01br1jqmin3kislw59rdsgl4pggdf8miwddifj654dllfgg148vg";
-       libraryHaskellDepends = [
-         base containers directory filepath generic-deriving ghc-prim mtl
-         stm tagged tasty transformers xml
-       ];
-       description = "Render tasty output to XML for Jenkins";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "tasty-ant-xml_1_1_8" = callPackage
-    ({ mkDerivation, base, containers, directory, filepath
-     , generic-deriving, ghc-prim, mtl, stm, tagged, tasty, transformers
-     , xml
-     }:
-     mkDerivation {
-       pname = "tasty-ant-xml";
        version = "1.1.8";
        sha256 = "0h9mllhw9cd0rn34xhj8grwmbny7z7hpd8qmp9lfcdj0s4qx9vx8";
        libraryHaskellDepends = [
···
        ];
        description = "Render tasty output to XML for Jenkins";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "tasty-auto" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "tasty-bench_0_2_3" = callPackage
+    ({ mkDerivation, base, containers, deepseq, tasty }:
+     mkDerivation {
+       pname = "tasty-bench";
+       version = "0.2.3";
+       sha256 = "16273rxlvjh960mdlhkpggx8rbza1n18fxl9m9yi8dhkli4g0w6a";
+       libraryHaskellDepends = [ base containers deepseq tasty ];
+       description = "Featherlight benchmark framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tasty-dejafu" = callPackage
     ({ mkDerivation, base, dejafu, random, tagged, tasty }:
      mkDerivation {
···
   "tasty-golden" = callPackage
     ({ mkDerivation, async, base, bytestring, containers, deepseq
      , directory, filepath, mtl, optparse-applicative, process, tagged
-     , tasty, tasty-hunit, temporary, text
+     , tasty, tasty-hunit, temporary, text, unix-compat
      }:
      mkDerivation {
        pname = "tasty-golden";
-       version = "2.3.3.2";
-       sha256 = "19dif84p71hks8czmaff6nlylsz34bqy0nki7mclr4ysawz1hdm9";
+       version = "2.3.4";
+       sha256 = "1nskavqgfxx1cw7q6c0cmizlwj54rnlv93yhgssaa77gv1nbvwpn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          async base bytestring containers deepseq directory filepath mtl
          optparse-applicative process tagged tasty temporary text
+         unix-compat
        ];
        testHaskellDepends = [
          base directory filepath process tasty tasty-hunit temporary
···
        license = lib.licenses.mit;
      }) {};
 
-  "tasty-golden_2_3_4" = callPackage
-    ({ mkDerivation, async, base, bytestring, containers, deepseq
-     , directory, filepath, mtl, optparse-applicative, process, tagged
-     , tasty, tasty-hunit, temporary, text, unix-compat
+  "tasty-grading-system" = callPackage
+    ({ mkDerivation, aeson, base, containers, directory, filepath
+     , generic-deriving, mtl, stm, tagged, tasty, tasty-hunit, text
      }:
      mkDerivation {
-       pname = "tasty-golden";
-       version = "2.3.4";
-       sha256 = "1nskavqgfxx1cw7q6c0cmizlwj54rnlv93yhgssaa77gv1nbvwpn";
-       isLibrary = true;
-       isExecutable = true;
+       pname = "tasty-grading-system";
+       version = "0.1.0.0";
+       sha256 = "1r72gbylmv466naxkqsf56wlkp5kzhvyq0w3k7g47hs1rlslllmp";
+       revision = "2";
+       editedCabalFile = "1kr1113k6a0d8yd51lvl1689wdbq2lb2fp44rl6jzdaizxvj360f";
        libraryHaskellDepends = [
-         async base bytestring containers deepseq directory filepath mtl
-         optparse-applicative process tagged tasty temporary text
-         unix-compat
+         aeson base containers directory filepath generic-deriving mtl stm
+         tagged tasty text
        ];
-       testHaskellDepends = [
-         base directory filepath process tasty tasty-hunit temporary
-       ];
-       description = "Golden tests support for tasty";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
+       testHaskellDepends = [ aeson base tasty tasty-hunit ];
+       description = "Grade your tasty-testsuite";
+       license = lib.licenses.bsd3;
      }) {};
 
   "tasty-groundhog-converters" = callPackage
···
        pname = "tasty-hedgehog";
        version = "1.0.1.0";
        sha256 = "0vkmhqfydyxbvjjbwvwn0q1f1a2dl9wmhz0s7020frpzwqcjwm5b";
+       revision = "1";
+       editedCabalFile = "1yhj5jpgsr1mflsadf1fgaj8hh7y3dnfsg95m6bni7xprdnw6nf9";
        libraryHaskellDepends = [ base hedgehog tagged tasty ];
        testHaskellDepends = [
          base hedgehog tasty tasty-expected-failure
···
        pname = "tasty-hspec";
        version = "1.1.6";
        sha256 = "02s82ijs2ringqxsqbm7m3vcy5brmwxa617azxv0v2phi3rdkjvl";
+       revision = "1";
+       editedCabalFile = "0za15rg0szacxq9yfxxjzddr77ai7ng5827a20pj9dr5anjlnajj";
        libraryHaskellDepends = [
          base hspec hspec-core QuickCheck tasty tasty-quickcheck
          tasty-smallcheck
···
   "tasty-silver" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
      , deepseq, directory, filepath, mtl, optparse-applicative, process
-     , process-extras, regex-tdfa, semigroups, stm, tagged, tasty
-     , tasty-hunit, temporary, text, transformers
-     }:
-     mkDerivation {
-       pname = "tasty-silver";
-       version = "3.1.15";
-       sha256 = "07iiaw5q5jb6bxm5ys1s6bliw0qxsqp100awzxwkwfia03i1iz8z";
-       revision = "1";
-       editedCabalFile = "1pxwixy274w0z99zsx0aywcxcajnpgan3qri81mr1wb6afxrq8d6";
-       libraryHaskellDepends = [
-         ansi-terminal async base bytestring containers deepseq directory
-         filepath mtl optparse-applicative process process-extras regex-tdfa
-         semigroups stm tagged tasty temporary text
-       ];
-       testHaskellDepends = [
-         base directory filepath process tasty tasty-hunit temporary
-         transformers
-       ];
-       description = "A fancy test runner, including support for golden tests";
-       license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
-     }) {};
-
-  "tasty-silver_3_2_1" = callPackage
-    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
-     , deepseq, directory, filepath, mtl, optparse-applicative, process
      , process-extras, regex-tdfa, stm, tagged, tasty, tasty-hunit
      , temporary, text, transformers
      }:
···
          typed-process
        ];
        description = "Terminal user acceptance testing (UAT) via tmux";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "tasty-travis" = callPackage
···
          base dollaridoos profunctors semigroups
        ];
        description = "Types and combinators for taxes";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "tbox" = callPackage
···
          aeson base bytestring data-default http-conduit url utf8-string
        ];
        description = "Telegram API client";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          regex-pcre split tagsoup text time transformers
        ];
        description = "IRC tellbot";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers uri-encode
        ];
        description = "Template Toolkit implementation for Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "template-yj" = callPackage
···
        isExecutable = true;
        executableHaskellDepends = [ base mtl tagsoup uniplate ];
        description = "Make template from website";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        executableHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "Programmers' time tracker";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "tensor" = callPackage
···
        libraryHaskellDepends = [ base ghc-prim random vector ];
        testHaskellDepends = [ base QuickCheck random ];
        description = "A completely type-safe library for linear algebra";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base ];
        executableHaskellDepends = [ base cli ];
        description = "Composable terminal colors";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "terminal" = callPackage
···
          base containers mtl process syb transformers
        ];
        description = "A semantic parser for lojban";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base optparse-generic system-filepath text
        ];
        description = "Compile separate tex files with the same bibliography";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "tex2txt" = callPackage
···
        libraryHaskellDepends = [ base containers deepseq parsec ];
        executableHaskellDepends = [ base containers deepseq parsec ];
        description = "LaTeX to plain-text conversion";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          temporary unix
        ];
        description = "View your latex output while editing";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "texmath";
-       version = "0.12.1.1";
-       sha256 = "04clgbbzva9yxzkn9nf176mqj1lrv64h13awk86l4lrcfbb7kgh1";
+  "karver" = callPackage
+       sha256 = "0lqib59cnvxvgj6k8wk74g5xbamf63q3z7wnwc8r2d56z05djvxy";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          utf8-string xml
        ];
        description = "Conversion between formats used to represent mathematics";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "texrunner" = callPackage
···
          tasty-quickcheck text text-short vector
        ];
        description = "Memory-efficient string-indexed container types";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-quickcheck2 test-framework-th text text-icu
        ];
        description = "Dealing with Strict Text in NFC normalization";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
     ({ mkDerivation, base, criterion, tasty, tasty-hunit, text }:
      mkDerivation {
        pname = "text-manipulate";
-       version = "0.2.0.1";
-       sha256 = "0bwxyjj3ll45srxhsp2ihikgqglvjc6m02ixr8xpvyqwkcfwgsg0";
-       libraryHaskellDepends = [ base text ];
-       testHaskellDepends = [ base tasty tasty-hunit text ];
-       benchmarkHaskellDepends = [ base criterion text ];
-       description = "Case conversion, word boundary manipulation, and textual subjugation";
-       license = "unknown";
-       hydraPlatforms = lib.platforms.none;
-     }) {};
-
-  "text-manipulate_0_3_0_0" = callPackage
-    ({ mkDerivation, base, criterion, tasty, tasty-hunit, text }:
-     mkDerivation {
-       pname = "text-manipulate";
        version = "0.3.0.0";
        sha256 = "0pmzp38m3r0k6ps97b1wqplxlgvvlaid09x53jl3gxng0fwq910a";
        libraryHaskellDepends = [ base text ];
···
        benchmarkHaskellDepends = [ base criterion text ];
        description = "Case conversion, word boundary manipulation, and textual subjugation";
        license = lib.licenses.mpl20;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "text-markup" = callPackage
···
        pname = "text-show-instances";
        version = "3.8.4";
        sha256 = "1vsrf4vjq4z759srnzvyk3hn90ck4k91vy8cn625m8hy1zddqj2q";
-       revision = "1";
-       editedCabalFile = "1z7kgnxm9r9dgnqn4fyrfv3k8k2dac7g2hsf649jaxhh898z6dm6";
+       revision = "2";
+       editedCabalFile = "1k5q21j0276jafyy4icgncz45r5gab2mj8964xayhh548rzj5cm6";
        libraryHaskellDepends = [
          base base-compat-batteries bifunctors binary containers directory
          ghc-boot-th haskeline hpc old-locale old-time pretty random
···
     ({ mkDerivation, base, QuickCheck, utility-ht }:
      mkDerivation {
        pname = "tfp";
-       version = "1.0.1.1";
-       sha256 = "1qkcm4l09qpxy9996lnfn79c1wn1ca45s3i2iz2x3kvp0f999d3i";
+       version = "1.0.2";
+       sha256 = "02rm06cscj470ab6pla3050l1iygak69yfhsy0wc6cvavz181plf";
        libraryHaskellDepends = [ base utility-ht ];
        testHaskellDepends = [ base QuickCheck ];
        description = "Type-level integers, booleans, lists using type families";
···
      }:
      mkDerivation {
        pname = "th-compat";
-       version = "0.1.1";
-       sha256 = "1y83yq5ac067a631bd4kg0d14yp8hc23a0dsqsgbqdn279c21ylm";
-       libraryHaskellDepends = [ base template-haskell ];
-       testHaskellDepends = [
-         base base-compat hspec mtl template-haskell
-       ];
-       testToolDepends = [ hspec-discover ];
-       description = "Backward- (and forward-)compatible Quote and Code types";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "th-compat_0_1_2" = callPackage
-    ({ mkDerivation, base, base-compat, hspec, hspec-discover, mtl
-     , template-haskell
-     }:
-     mkDerivation {
-       pname = "th-compat";
        version = "0.1.2";
        sha256 = "009qc0yy5iq61kgnp9n6vdlqh8zmk4bjawcvpigccgfyk40mvi1b";
        libraryHaskellDepends = [ base template-haskell ];
···
        testToolDepends = [ hspec-discover ];
        description = "Backward- (and forward-)compatible Quote and Code types";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-constraint-compat" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "th-desugar_1_12" = callPackage
+    ({ mkDerivation, base, containers, ghc-prim, hspec, HUnit, mtl
+     , ordered-containers, syb, template-haskell, th-abstraction
+     , th-lift, th-orphans, transformers-compat
+     }:
+     mkDerivation {
+       pname = "th-desugar";
+       version = "1.12";
+       sha256 = "1bp47jpif299kbm27zhjaw1nhl12daa09vsc8f0jracq0jhxi3iv";
+       libraryHaskellDepends = [
+         base containers ghc-prim mtl ordered-containers syb
+         template-haskell th-abstraction th-lift th-orphans
+         transformers-compat
+       ];
+       testHaskellDepends = [
+         base containers hspec HUnit mtl syb template-haskell th-abstraction
+         th-lift th-orphans
+       ];
+       description = "Functions to desugar Template Haskell";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "th-dict-discovery" = callPackage
     ({ mkDerivation, base, constraints, template-haskell }:
      mkDerivation {
···
      }) {};
 
   "th-expand-syns" = callPackage
-    ({ mkDerivation, base, containers, syb, template-haskell }:
+    ({ mkDerivation, base, containers, syb, template-haskell
+     , th-abstraction
+     }:
      mkDerivation {
        pname = "th-expand-syns";
-       version = "0.4.6.0";
-       sha256 = "1dz8bl4yb6sis74knmvqxa21y9yws9l8gafzsi0chaqx15b5asxj";
-       libraryHaskellDepends = [ base containers syb template-haskell ];
-       testHaskellDepends = [ base template-haskell ];
-       description = "Expands type synonyms in Template Haskell ASTs";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "th-expand-syns_0_4_7_0" = callPackage
-    ({ mkDerivation, base, containers, syb, template-haskell }:
-     mkDerivation {
-       pname = "th-expand-syns";
-       version = "0.4.7.0";
-       sha256 = "1gmb89pgy3i0jpd760xmzx254xpg8pczfa8glgw9z1wak09kwv54";
-       revision = "1";
-       editedCabalFile = "0zh77kg86qmr285sn0xhhi2hbn8b9dx2pgmf2fipij8zj32k9ny4";
-       libraryHaskellDepends = [ base containers syb template-haskell ];
-       testHaskellDepends = [ base template-haskell ];
+  "karver" = callPackage
+       sha256 = "1mw0yxfbmicv0irfrcz4s6pn39za7yjd7zz09ialwym1b46624si";
+       libraryHaskellDepends = [
+         base containers syb template-haskell th-abstraction
+       ];
+       testHaskellDepends = [ base template-haskell th-abstraction ];
        description = "Expands type synonyms in Template Haskell ASTs";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "th-extras" = callPackage
···
        sha256 = "0xpfcabhlpnp883jb23sjcilan1cwwykvvlqvc6qzhda63fcyqp1";
        libraryHaskellDepends = [ base tuples-homogenous-h98 vector ];
        description = "3D Tic-Tac-Toe game";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        benchmarkHaskellDepends = [ base criterion weigh ];
        description = "Pattern language for improvised music";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "tidal-midi" = callPackage
···
          base containers PortMidi tidal time transformers
        ];
        description = "MIDI support for tidal";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring containers serialport tidal
        ];
        description = "Serial support for tidal";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        executableHaskellDepends = [ base ];
        description = "Visual rendering for Tidal patterns and osc messages";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0n05lw6zpcfr3lwy2qn7v0j3ym1la9x0mak8szaxc2nbkyc8drrb";
        libraryHaskellDepends = [ base base-io-access time ];
        description = "IO Access for time";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base doctest doctest-discover template-haskell time
        ];
        description = "Quasi-quoters for dates and times";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-hunit time
        ];
        description = "Generate recurring dates";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ array base containers mtl ];
        executableHaskellDepends = [ base ];
        description = "Time series analysis";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        isExecutable = true;
        executableHaskellDepends = [ base process time ];
        description = "time each line of terminal output";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "timeit" = callPackage
···
        executableHaskellDepends = [ base brick microlens time vty ];
        testHaskellDepends = [ base hspec microlens time ];
        description = "Time utilities";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
 
   "timezone-detect" = callPackage
-    ({ mkDerivation, base, directory, hspec, hspec-discover, time
-     , timezone-olson, timezone-series
+    ({ mkDerivation, base, directory, hspec, hspec-discover, QuickCheck
+     , time, timezone-olson, timezone-series
      }:
      mkDerivation {
        pname = "timezone-detect";
-       version = "0.3.0.0";
-       sha256 = "10pv88wmz8zqr1h3zh66skbkma2zz3gvwjaalnpfz5ii2dgl27yy";
+       version = "0.3.0.1";
+       sha256 = "1n4jmx0196zzq092b66kcrwpk00xsm7sj4s29ij5cl05sdaqalqx";
        libraryHaskellDepends = [
          base time timezone-olson timezone-series
        ];
        testHaskellDepends = [
-         base directory hspec time timezone-olson timezone-series
+         base directory hspec QuickCheck time timezone-olson timezone-series
        ];
        testToolDepends = [ hspec-discover ];
        description = "Haskell bindings for the zone-detect C library; plus tz-aware utils";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          keera-hails-reactivevalues mtl network network-bsd template-haskell
        ];
        description = "Testing Infrastructure for Temporal AbstractioNs - GUI to debug temporal programs";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base IfElse network network-bsd stm transformers Yampa
        ];
        description = "Testing Infrastructure for Temporal AbstractioNs - Interactive Yampa debugging layer";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0h7d4152nd8mx4slyjss4kf7n1xn99vc5hnk072apqfv301vpbx3";
        libraryHaskellDepends = [ base Yampa ];
        description = "Testing Infrastructure for Temporal AbstractioNs - Yampa record-and-replay layer";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring directory template text
        ];
        description = "simple executable for templating";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "tn" = callPackage
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base time ];
        description = "Rate limiter using lazy bucket algorithm";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "token-limiter" = callPackage
···
        sha256 = "0n8w923m8c803zcphims51q2xm6a0374zzh00d62mg92zbdsh9vn";
        libraryHaskellDepends = [ base bytestring text ];
        description = "An efficient and easy-to-use tokenizer monad";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "tokenizer-streaming" = callPackage
···
          streaming-commons text tokenizer-monad
        ];
        description = "A variant of tokenizer-monad that supports streaming";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base hspec ];
        description = "TokTok C code style checker";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ tokyocabinet tokyotyrant ];
        description = "FFI bindings to libtokyotyrant";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) tokyocabinet; inherit (pkgs) tokyotyrant;};
···
        pname = "toml";
        version = "0.1.3";
        sha256 = "0wby1jas854niwyac95n39liqc874xcd1ahqpw6ksi2nhv2ld6f2";
-       revision = "1";
-       editedCabalFile = "086a2dsv3nn04ak78c0q0by9kqdw92idfl1iyzp1qihfdi8mxb2f";
+       revision = "2";
+       editedCabalFile = "1qzlsicdd7qdys69iy838y2v4dkaq4d4ar664l338y5y7fg3axxv";
        libraryHaskellDepends = [
          attoparsec base bytestring containers old-locale time
        ];
···
        license = lib.licenses.mpl20;
      }) {};
 
+  "tomland_1_3_3_0" = callPackage
+    ({ mkDerivation, base, bytestring, containers, deepseq, directory
+     , hashable, hedgehog, hspec, hspec-hedgehog, hspec-megaparsec
+     , markdown-unlit, megaparsec, mtl, parser-combinators, text, time
+     , transformers, unordered-containers, validation-selective
+     }:
+     mkDerivation {
+       pname = "tomland";
+       version = "1.3.3.0";
+       sha256 = "1masnbr5x75727k2rmgcmxqm91139v9wy434ml5a4c3dsry7xyhv";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring containers deepseq hashable megaparsec mtl
+         parser-combinators text time transformers unordered-containers
+         validation-selective
+       ];
+       executableHaskellDepends = [
+         base bytestring containers hashable text time unordered-containers
+       ];
+       executableToolDepends = [ markdown-unlit ];
+       testHaskellDepends = [
+         base bytestring containers directory hashable hedgehog hspec
+         hspec-hedgehog hspec-megaparsec megaparsec text time
+         unordered-containers
+       ];
+       description = "Bidirectional TOML serialization";
+       license = lib.licenses.mpl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tomlcheck" = callPackage
     ({ mkDerivation, base, htoml-megaparsec, megaparsec
      , optparse-applicative, text
···
        ];
        executableHaskellDepends = [ base optparse-generic ];
        description = "Cluster single cells and analyze cell clade relationships";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          saltine text
        ];
        description = "A Tox protocol implementation in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          data-default-class hspec QuickCheck saltine
        ];
        description = "Haskell bindings to the C reference implementation of Tox";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {toxcore = null;};
···
          wai warp websockets wuss
        ];
        description = "Applications for interacting with the Pushbullet API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base containers criterion mtl multirec parsec QuickCheck
        ];
        description = "Generic representation of tree transformations";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "tree-diff" = callPackage
     ({ mkDerivation, aeson, ansi-terminal, ansi-wl-pprint, base
-     , base-compat, bytestring, bytestring-builder, containers, hashable
-     , parsec, parsers, pretty, QuickCheck, scientific, tagged, tasty
-     , tasty-golden, tasty-quickcheck, text, time, trifecta
-     , unordered-containers, uuid-types, vector
+     , base-compat, bytestring, bytestring-builder, containers
+     , criterion, deepseq, Diff, hashable, parsec, parsers, pretty
+     , primitive, QuickCheck, scientific, semialign, strict, tagged
+     , tasty, tasty-golden, tasty-quickcheck, text, these, time
+     , trifecta, unordered-containers, uuid-types, vector
      }:
      mkDerivation {
        pname = "tree-diff";
-       version = "0.1";
-       sha256 = "1156nbqn0pn9lp4zjsy4vv5g5wmy4zxwmbqdgvq349rydynh3ng3";
-       revision = "6";
-       editedCabalFile = "1wqfac660m9ggv6r85a7y29mk947hki9iydy124vdwcqzichja0d";
+       version = "0.2";
+       sha256 = "1ny7mi0n8cyb65q9ihbnm2gxiyya888dw2c4y0hjy8k882wdhf0x";
        libraryHaskellDepends = [
          aeson ansi-terminal ansi-wl-pprint base base-compat bytestring
-         bytestring-builder containers hashable parsec parsers pretty
-         QuickCheck scientific tagged text time unordered-containers
-         uuid-types vector
+         bytestring-builder containers deepseq hashable parsec parsers
+         pretty primitive QuickCheck scientific semialign strict tagged text
+         these time unordered-containers uuid-types vector
        ];
        testHaskellDepends = [
-         ansi-terminal ansi-wl-pprint base base-compat parsec QuickCheck
-         tagged tasty tasty-golden tasty-quickcheck trifecta
+         ansi-terminal ansi-wl-pprint base base-compat parsec primitive
+         QuickCheck tagged tasty tasty-golden tasty-quickcheck trifecta
        ];
+       benchmarkHaskellDepends = [ base criterion deepseq Diff ];
        description = "Diffing of (expression) trees";
        license = lib.licenses.gpl2Plus;
      }) {};
···
        sha256 = "07vgsps4kjld75ndnjjaigsk5vvg11vjp740pznhsw79k3qjbs9a";
        libraryHaskellDepends = [ base containers mtl ];
        description = "Library for functions pertaining to tree exploration and manipulation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "tree-monad" = callPackage
···
          tasty-hunit text transformers
        ];
        description = "A tree of Data.Map.";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "105gj9s8gp4xc4i7ank8m6pjc80kywl7vn53qdxfrndaljv4kark";
        libraryHaskellDepends = [ base containers ];
        description = "Library for a multi-way tree (rose tree), using Seq (finger tree) for forests";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "treeviz" = callPackage
···
          attoparsec base bytestring containers deepseq mtl network
        ];
        description = "Library for polling Tremulous servers";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0y0iyll7ml5qz271cqa0dc3w2j3w1d8jjaxwaf2flcidigws69z5";
        libraryHaskellDepends = [ base ];
        description = "Constraints that any type, resp. no type fulfills";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        benchmarkHaskellDepends = [ base criterion ];
        description = "A Tropical Geometry package for Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers
        ];
        description = "Write stream processing computations with side effects in a series of tubes";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base generics-sop ];
        testHaskellDepends = [ base generics-sop ];
        description = "functions on n-ary tuples using generics-sop";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "tuple-th" = callPackage
···
          base containers hspec hspecVariant QuickCheck QuickCheckVariant
        ];
        description = "An implementation of Turing Machine and Automaton";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "turtle";
-       version = "1.5.20";
-       sha256 = "1dk8ddp1p77l7gbg81ryqrkaxhrj3an24mx572b5wmhmjmbjfk9l";
-       libraryHaskellDepends = [
-         ansi-wl-pprint async base bytestring clock containers directory
-         exceptions foldl hostname managed optional-args
-         optparse-applicative process stm streaming-commons system-fileio
-         system-filepath temporary text time transformers unix unix-compat
-       ];
-       testHaskellDepends = [ base doctest system-filepath temporary ];
-       benchmarkHaskellDepends = [ base criterion text ];
-       description = "Shell programming, Haskell-style";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "turtle_1_5_21" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, async, base, bytestring, clock
-     , containers, criterion, directory, doctest, exceptions, foldl
-     , hostname, managed, optional-args, optparse-applicative, process
-     , stm, streaming-commons, system-fileio, system-filepath, temporary
-     , text, time, transformers, unix, unix-compat
-     }:
-     mkDerivation {
-       pname = "turtle";
        version = "1.5.21";
        sha256 = "0sb1xnmvqby1lcg3p92v0nkpxnm2qk0gcn41mxxgp3xdm24vkz36";
        libraryHaskellDepends = [
···
        benchmarkHaskellDepends = [ base criterion text ];
        description = "Shell programming, Haskell-style";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "turtle-options" = callPackage
···
        pname = "type-errors";
        version = "0.2.0.0";
        sha256 = "1d1fi4ij18q39rpibc056mgvly75zqixkba4l8bn307c62f50k8p";
-       revision = "1";
-       editedCabalFile = "157fjnr98fn5943siqwk1rd2wwnzd7nlbkbkzvdqv7d723cmh126";
+       revision = "2";
+       editedCabalFile = "1rlhswrkyvhaqhgk2yr9xk49yp196p5fy37hmyni9g7rx1d07qyj";
        libraryHaskellDepends = [
          base first-class-families syb template-haskell th-abstraction
        ];
···
          base ghc-typelits-knownnat mtl pretty-compact
        ];
        description = "Typed frontend to TensorFlow and higher-order deep learning";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }) {};
 
   "typenums" = callPackage
-    ({ mkDerivation, base, hspec, QuickCheck }:
+    ({ mkDerivation, base, hspec, hspec-discover, QuickCheck }:
      mkDerivation {
        pname = "typenums";
-       version = "0.1.2.1";
-       sha256 = "06wrsvbddv2ga7k39954697jnclb5r6g4m95pr0fmv34ws1y1d66";
+       version = "0.1.3";
+       sha256 = "0ampchndx0z8bhdqgp14smv270pizjvlr54ns3x79hwjpg9m01rc";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
        description = "Type level numbers using existing Nat functionality";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
···
          base containers parallel polynomials-bernstein vector
        ];
        description = "Drawings for printed text documents";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "typson-beam" = callPackage
···
        libraryPkgconfigDepends = [ systemd ];
        description = "libudev bindings";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) systemd;};
 
   "udp-conduit" = callPackage
···
          optparse-applicative
        ];
        description = "Minimal HTTP client library optimized for benchmarking";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "ui-command" = callPackage
···
        ];
        executableHaskellDepends = [ base bytestring cmdargs ];
        description = "Secure and resilient remote file storage utility";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        pname = "unescaping-print";
        version = "0.1";
        sha256 = "0a1ryvnpgsk668wagwwapksi7i9kbhhjfpqlvmg2z9kv1anr6mp5";
-       revision = "2";
-       editedCabalFile = "113p28z74lvsc7c6v93ilvbyp2fn5h1qsymksn3mi2ndxwq3vz3f";
+       revision = "3";
+       editedCabalFile = "0r2ggyy2qla75jxdhd3izqqkqb3ar6538jczfwlbbxrj4w1xkd47";
        libraryHaskellDepends = [ base ];
        description = "Tiny package providing unescaping versions of show and print";
        license = lib.licenses.bsd3;
···
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base ];
        description = "An extendable library for type-safe computations including units";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = "GPL";
      }) {};
 
+  "unlift-stm" = callPackage
+    ({ mkDerivation, base, stm, transformers, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "unlift-stm";
+       version = "0.1.0.0";
+       sha256 = "1580vrv09f0w7ipzv89pq8xsz5labf3vprxxicy29q0nwnnc6y3l";
+       libraryHaskellDepends = [
+         base stm transformers unliftio unliftio-core
+       ];
+       description = "(un)lifted classes and functions for the STM monad";
+       license = lib.licenses.bsd2;
+     }) {};
+
   "unlifted-list" = callPackage
     ({ mkDerivation, base, ghc-prim, semigroups }:
      mkDerivation {
···
        isExecutable = true;
        executableHaskellDepends = [ base storable-endian utility-ht ];
        description = "Extract useful information from Amiga MED files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "unordered-containers" = callPackage
···
      }) {};
 
   "utility-ht" = callPackage
-    ({ mkDerivation, base, QuickCheck }:
+    ({ mkDerivation, base, doctest-exitcode-stdio, doctest-lib
+     , QuickCheck
+     }:
      mkDerivation {
        pname = "utility-ht";
-       version = "0.0.15";
-       sha256 = "148gdz6pbl1i5qjvjrq5576pg58anmh18xha37n9fncjy36pjp44";
+       version = "0.0.16";
+       sha256 = "10dvmfhhhj5w4wz5drhvs6i0yv35kbbcbzhy6ci34r3ppcik5rdw";
        libraryHaskellDepends = [ base ];
-       testHaskellDepends = [ base QuickCheck ];
+       testHaskellDepends = [
+         base doctest-exitcode-stdio doctest-lib QuickCheck
+       ];
        description = "Various small helper functions for Lists, Maybes, Tuples, Functions";
        license = lib.licenses.bsd3;
      }) {};
···
        sha256 = "0qmp5k4wg5ja2382cwarf8fwjval2a5wdwvz32f965hvwgc9cd43";
        libraryHaskellDepends = [ base json MissingH mtl ];
        description = "Cross-language extensible representation for algebraic data type instances";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "0q6n18kqga839gkdgdwsfbnbpfm4hh1qjln17qnmfxm3ylh2l9la";
        libraryHaskellDepends = [ base process ];
        description = "Utility function for reading a source of loaded uzbl pages";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "v4l2" = callPackage
···
        ];
        testHaskellDepends = [ base process ];
        description = "the cabal companion";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "157wjx2shzfh6dfl6h8x017cn9ji3ql1p0gpi79ginz4s81f2ny1";
        libraryHaskellDepends = [ array base containers ghc-prim ];
        description = "Graph representation of the GHC heap";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "093ba6n30a6gyifnk3bd50rkx8qldjqq9vsk92pnq152ibs36b2m";
        libraryHaskellDepends = [ base filepath graphviz vacuum ];
        description = "A library for transforming vacuum graphs into GraphViz output";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "validation-selective";
-       version = "0.1.0.0";
-       sha256 = "0ia3g2c1137pa0ns97yf8vbfvwmjhqnqhzn9lzgxvxwzchvwpnf7";
-       revision = "1";
-       editedCabalFile = "19pcv1i7xcrgg248dbgyl83zx3gn9zilrxqs3arlmkwdi0jdj4nv";
+       version = "0.1.0.1";
+       sha256 = "005j45rm0bqjlyh3w67zi62hjv3fp0np7szz80s9nm203i8p6wzb";
        libraryHaskellDepends = [ base deepseq selective ];
        testHaskellDepends = [
          base doctest hedgehog hspec hspec-hedgehog selective text
···
          optparse-applicative process uniplate
        ];
        description = "Analyze and visualize expression trees";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          test-framework-hunit test-framework-quickcheck2
        ];
        description = "Vector clocks for versioning message flows";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        benchmarkHaskellDepends = [ base criterion lens ];
        description = "Random verilog generation and simulator testing";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          xmms2-client xmms2-client-glib
        ];
        description = "An XMMS2 client";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ vte ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the VTE library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) vte;};
···
        libraryPkgconfigDepends = [ vte ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the VTE library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) vte;};
···
        isExecutable = true;
        libraryHaskellDepends = [ base vty ];
        description = "A lib for displaying a menu and getting a selection using VTY";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ vulkan ];
        description = "Bindings to the Vulkan graphics API";
        license = lib.licenses.bsd3;
-       platforms = [ "x86_64-darwin" "x86_64-linux" ];
+       platforms = [ "aarch64-linux" "x86_64-darwin" "x86_64-linux" ];
      }) {vulkan = null;};
 
   "vulkan-api" = callPackage
···
          base bytestring conduit http-types text transformers wai wai-extra
        ];
        description = "DEPCRECATED (use package \"simple\" instead) A minimalist web framework for WAI web applications";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      , blaze-builder, blaze-html, bytestring, case-insensitive, cereal
      , clientsession, cookie, exceptions, hedgehog, hoauth2, http-client
      , http-client-tls, http-conduit, http-reverse-proxy, http-types
-     , jose, microlens, mtl, optparse-simple, regex-posix
-     , safe-exceptions, shakespeare, tasty, tasty-hedgehog, tasty-hunit
-     , text, time, unix-compat, unordered-containers, uri-bytestring
-     , vault, wai, wai-app-static, wai-extra, warp, yaml
+     , jose, microlens, mtl, optparse-applicative, optparse-simple
+     , regex-posix, safe-exceptions, shakespeare, tasty, tasty-hedgehog
+     , tasty-hunit, text, time, unix-compat, unordered-containers
+     , uri-bytestring, vault, wai, wai-app-static, wai-extra, warp, yaml
      }:
      mkDerivation {
        pname = "wai-middleware-auth";
-       version = "0.2.3.1";
-       sha256 = "0i5zg6pyrr3f9g39jpk557h5rqzrm36279dav3v8n6lrj919x01m";
+       version = "0.2.4.1";
+       sha256 = "1q8vj3ri5fvdhlwls7az4zcwk7iyc3fi4yf968086pkg92hpzcdl";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          uri-bytestring vault wai wai-app-static wai-extra yaml
        ];
        executableHaskellDepends = [
-         base bytestring cereal clientsession optparse-simple wai-extra warp
+         base bytestring cereal clientsession optparse-applicative
+         optparse-simple wai-extra warp
        ];
        testHaskellDepends = [
          aeson base binary bytestring clientsession cookie hedgehog hoauth2
···
          base Cabal directory mtl split text wai wai-middleware-static warp
        ];
        description = "WAI middleware for preprocessing static files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        broken = true;
      }) {};
 
+  "wai-middleware-validation" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, doctest
+     , filepath, here, hspec, http-types, insert-ordered-containers
+     , lens, openapi3, text, wai, wai-extra
+     }:
+     mkDerivation {
+       pname = "wai-middleware-validation";
+       version = "0.1.0.0";
+       sha256 = "0cbp32j31xkmniml56gnh278g94zhhfc8xlp842n8lll5hh13bf4";
+       libraryHaskellDepends = [
+         aeson base bytestring containers filepath http-types
+         insert-ordered-containers lens openapi3 text wai
+       ];
+       testHaskellDepends = [
+         base bytestring doctest here hspec http-types openapi3 wai
+         wai-extra
+       ];
+       description = "WAI Middleware to validate the request and response bodies";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "wai-middleware-verbs" = callPackage
     ({ mkDerivation, base, bytestring, exceptions, hashable, http-types
      , mmorph, monad-control, monad-control-aligned, monad-logger, mtl
···
          vector-algorithms wai
        ];
        description = "A simple cache for serving static files in a WAI middleware";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers unordered-containers vector wreq
        ];
        description = "Bindings to the WebDriver API";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ webkit ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the Webkit library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {webkit = null;};
 
···
        libraryPkgconfigDepends = [ webkitgtk24x-gtk3 ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "Binding to the Webkit library";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
      }) {inherit (pkgs) webkitgtk24x-gtk3;};
 
···
          base bytestring JuicyPixels tasty tasty-hunit
        ];
        description = "JuicyPixels support for WebP format";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {inherit (pkgs) libwebp;};
 
   "webpage" = callPackage
···
        libraryHaskellDepends = [ base bytestring deepseq ];
        librarySystemDepends = [ dnsapi ];
        description = "Domain Name Service (DNS) lookup via the <windns.h>/dnsapi.dll standard library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {dnsapi = null;};
···
        ];
        testHaskellDepends = [ base conduit hspec HUnit mtl ];
        description = "Run computations that depend on one or more elements in a stream";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "witherable" = callPackage
···
      }) {};
 
   "witherable-class" = callPackage
-    ({ mkDerivation, base, base-orphans, containers, hashable
-     , transformers, unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "witherable-class";
-       version = "0";
-       sha256 = "0jb8yq9i0rlbmcd5rbg95m2w26zbmi7iwph5v7wghiari751r2bp";
-       libraryHaskellDepends = [
-         base base-orphans containers hashable transformers
-         unordered-containers vector
-       ];
-       description = "Witherable = Traversable + Filterable";
-       license = lib.licenses.bsd3;
-     }) {};
-
-  "witherable-class_0_0_1" = callPackage
     ({ mkDerivation, base, witherable }:
      mkDerivation {
        pname = "witherable-class";
···
        libraryHaskellDepends = [ base witherable ];
        description = "Witherable = Traversable + Filterable";
        license = lib.licenses.bsd3;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "within" = callPackage
···
        libraryHaskellDepends = [ base binary containers ];
        testHaskellDepends = [ base binary containers hspec QuickCheck ];
        description = "Implementation of a finite trie over words";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "word-vector" = callPackage
···
        ];
        executableHaskellDepends = [ base ];
        description = "a \"Desktop Workflow\" monad with Objective-C bindings";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "wraxml";
-       version = "0.4.4.1";
-       sha256 = "04snqwr6plf1y179dzfjjmg9kjf4lbdgj22xqlhw6wllvd8953c2";
+       version = "0.4.4.2";
+       sha256 = "1cfbbr1fbp7wrm2w7rldvf3gvp8fzvnpa6c2mkxscarhmn5wl92z";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
          xml-basic
        ];
        description = "Lazy wrapper to HaXML, HXT, TagSoup via custom XML tree structure";
-       license = "GPL";
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring file-embed hspec network-uri
        ];
        description = "WSDL parsing in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bencode bytestring containers directory safe utf8-string
        ];
        description = "A small tool to list, add and remove webseeds from a torrent file";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          type-level
        ];
        description = "A embedded DSL for manipulating DSP languages in Haskell";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        description = "Haskell extended file attributes interface";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) attr;};
 
   "xbattbar" = callPackage
···
          base directory filepath process unix
        ];
        description = "XChat";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring containers mtl network transformers
        ];
        description = "Partial implementation of the XCP protocol with ethernet as transport layer";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryPkgconfigDepends = [ libxfconf ];
        libraryToolDepends = [ gtk2hs-buildtools ];
        description = "FFI bindings to xfconf";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {libxfconf = null;};
···
        ];
        libraryToolDepends = [ c2hs ];
        description = "An XMMS2 client library";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base haskell98 xmms2-client ];
        libraryToolDepends = [ c2hs ];
        description = "An XMMS2 client library — GLib integration";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        benchmarkHaskellDepends = [ base gauge mtl time ];
        description = "A Minimalistic Text Based Status Bar";
        license = lib.licenses.bsd3;
-       platforms = [ "armv7l-linux" "i686-linux" "x86_64-linux" ];
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs.xorg) libXpm; inherit (pkgs.xorg) libXrandr; 
          inherit (pkgs.xorg) libXrender; inherit (pkgs) wirelesstools;};
 
···
        sha256 = "1xs9qwzq9x552jw9wxdaddk2w1m5kc060mqahhk2f2q3zs9nk2n9";
        libraryHaskellDepends = [ base mtl xmonad xmonad-contrib ];
        description = "Third party extensions for xmonad";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        editedCabalFile = "1vxgv702wgr0k0kzd602v8xv11q5dap4mfhqifnr928bwf9scp28";
        libraryHaskellDepends = [ base magic mtl random unix xmonad ];
        description = "xmonad wallpaper extension";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
      }) {};
 
   "xmonad-windownames" = callPackage
···
      }) {};
 
   "xrefcheck" = callPackage
-    ({ mkDerivation, aeson, aeson-options, async, base, bytestring
+    ({ mkDerivation, aeson, aeson-casing, async, base, bytestring
      , cmark-gfm, containers, data-default, deepseq, directory
-     , directory-tree, filepath, fmt, Glob, hspec, hspec-discover
-     , http-client, http-types, lens, modern-uri, mtl, o-clock
-     , optparse-applicative, pretty-terminal, QuickCheck, req
-     , roman-numerals, template-haskell, text, text-metrics
-     , th-lift-instances, th-utilities, universum, with-utf8, yaml
+     , directory-tree, file-embed, filepath, fmt, Glob, hspec
+     , hspec-discover, http-client, http-types, HUnit, lens, modern-uri
+     , mtl, o-clock, optparse-applicative, pretty-terminal, QuickCheck
+     , regex-tdfa, req, roman-numerals, template-haskell, text
+     , text-metrics, th-lift-instances, th-utilities, transformers
+     , universum, with-utf8, yaml
      }:
      mkDerivation {
        pname = "xrefcheck";
-       version = "0.1.2";
-       sha256 = "0m3cya6rfx7ypq4sp172z9fnnl6n11v98f6bj003phrapl6s0vnn";
+       version = "0.1.3";
+       sha256 = "0v7ylf21kky36shq1l33mlcsg2iihqwqx7bxyjlmhndp9hi0dr8l";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
-         aeson aeson-options async base bytestring cmark-gfm containers
-         data-default deepseq directory directory-tree filepath fmt Glob
-         http-client http-types lens modern-uri mtl o-clock
-         optparse-applicative pretty-terminal req roman-numerals
+         aeson aeson-casing async base bytestring cmark-gfm containers
+         data-default deepseq directory directory-tree file-embed filepath
+         fmt Glob http-client http-types HUnit lens modern-uri mtl o-clock
+         optparse-applicative pretty-terminal regex-tdfa req roman-numerals
          template-haskell text text-metrics th-lift-instances th-utilities
-         universum with-utf8 yaml
+         transformers universum with-utf8 yaml
        ];
        executableHaskellDepends = [
-         aeson aeson-options async base bytestring cmark-gfm containers
-         data-default deepseq directory directory-tree filepath fmt Glob
-         http-client http-types lens modern-uri mtl o-clock
-         optparse-applicative pretty-terminal req roman-numerals
+         aeson aeson-casing async base bytestring cmark-gfm containers
+         data-default deepseq directory directory-tree file-embed filepath
+         fmt Glob http-client http-types HUnit lens modern-uri mtl o-clock
+         optparse-applicative pretty-terminal regex-tdfa req roman-numerals
          template-haskell text text-metrics th-lift-instances th-utilities
-         universum with-utf8 yaml
+         transformers universum with-utf8 yaml
        ];
        testHaskellDepends = [
-         aeson aeson-options async base bytestring cmark-gfm containers
-         data-default deepseq directory directory-tree filepath fmt Glob
-         hspec http-client http-types lens modern-uri mtl o-clock
-         optparse-applicative pretty-terminal QuickCheck req roman-numerals
-         template-haskell text text-metrics th-lift-instances th-utilities
-         universum with-utf8 yaml
+         aeson aeson-casing async base bytestring cmark-gfm containers
+         data-default deepseq directory directory-tree file-embed filepath
+         fmt Glob hspec http-client http-types HUnit lens modern-uri mtl
+         o-clock optparse-applicative pretty-terminal QuickCheck regex-tdfa
+         req roman-numerals template-haskell text text-metrics
+         th-lift-instances th-utilities transformers universum with-utf8
+         yaml
        ];
        testToolDepends = [ hspec-discover ];
        license = lib.licenses.mpl20;
···
          split text time
        ];
        description = "#plaimi's all-encompassing bot";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        librarySystemDepends = [ yajl ];
        libraryToolDepends = [ c2hs ];
        description = "Bindings for YAJL, an event-based JSON implementation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {inherit (pkgs) yajl;};
···
          base bytestring enumerator json-types text transformers yajl
        ];
        description = "Enumerator-based interface to YAJL, an event-based JSON implementation";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base GLFW-b newtype OpenGL vector-space Yampa
        ];
        description = "Connects GLFW-b (GLFW 3+) with the Yampa FRP library";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base GLUT newtype OpenGL vector-space Yampa-core
        ];
        description = "Connects Yampa and GLUT";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
      }:
      mkDerivation {
        pname = "yasi";
-       version = "0.1.1.1";
-       sha256 = "0b3ajgxf8bk2pjfwqmf748x1yzyq9knjsya2xzkdrjs5vffg1j9k";
+       version = "0.1.2.1";
+       sha256 = "0647z79wva7apkp0swj7gax780vqmhr5czxrvg88gl3bi03wcapl";
        libraryHaskellDepends = [ base bytestring template-haskell text ];
        testHaskellDepends = [
          base hedgehog tasty tasty-hedgehog tasty-hunit text
···
          th-abstraction transformers
        ];
        description = "Total recursion schemes";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "yaya-hedgehog" = callPackage
···
        sha256 = "0aw932d2yr3w84ia44y46w4w96bc8gdag63h66rhx3v7gwmkwdwg";
        libraryHaskellDepends = [ base deriving-compat hedgehog yaya ];
        description = "Hedgehog testing support for the Yaya recursion scheme library";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "yaya-test" = callPackage
···
          base deriving-compat hedgehog yaya yaya-hedgehog
        ];
        description = "Test suites for `yaya`";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bifunctors comonad either free lens yaya
        ];
        description = "Non-total extensions to the Yaya recursion scheme library";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
      }) {};
 
   "yaya-unsafe-test" = callPackage
···
          base hedgehog yaya yaya-hedgehog yaya-unsafe
        ];
        description = "Test suites for `yaya-unsafe`";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          aeson base numbered-semigroups tasty tasty-hunit tasty-quickcheck
        ];
        description = "Yesod-based server for interactive presentation slides";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yesod-auth yesod-core
        ];
        description = "A yesod-auth plugin for LTI 1.3";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base blaze-html hspec text ];
        description = "Tools for using markdown in a yesod application";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base cryptonite hspec QuickCheck ];
        description = "Executable specifications of composable cryptographic protocols";
-       license = lib.licenses.agpl3;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yi-mode-haskell yi-mode-javascript yi-rope
        ];
        description = "Yi editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yi-rope
        ];
        description = "Add-ons to Yi, the Haskell-Scriptable Editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        benchmarkHaskellDepends = [ base criterion deepseq yi-rope ];
        description = "Yi editor core library";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          transformers-base yi-core yi-rope
        ];
        description = "Dynamic configuration support for Yi";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        sha256 = "1kbds9s0r67bdvigjk0c58slbifnddp6ppv4jrgv6493pylp78qv";
        libraryHaskellDepends = [ base containers split yi-language ];
        description = "Simple mapping from colour names used in emacs to Color";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yi-language yi-rope
        ];
        description = "Pango frontend for Yi editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          stm text vty yi-core yi-language yi-rope
        ];
        description = "Vty frontend for Yi editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          yi-rope
        ];
        description = "Fuzzy open plugin for yi";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text yi-core yi-language yi-rope
        ];
        description = "Yi editor incremental reader";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base microlens-platform text yi-core yi-keymap-emacs yi-rope
        ];
        description = "Cua keymap for Yi editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          text transformers-base yi-core yi-language yi-misc-modes yi-rope
        ];
        description = "Emacs keymap for Yi editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers yi-core yi-language yi-rope
        ];
        description = "Vim keymap for Yi editor";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          unordered-containers
        ];
        description = "Collection of language-related Yi libraries";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryToolDepends = [ alex ];
        description = "Yi editor miscellaneous modes";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryToolDepends = [ alex ];
        description = "Yi editor haskell mode";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        libraryToolDepends = [ alex ];
        description = "Yi editor javascript mode";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        benchmarkHaskellDepends = [ base criterion deepseq text ];
        description = "A rope data structure used by Yi";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
      }) {};
 
   "yi-snippet" = callPackage
···
          base containers tasty-hunit tasty-th yi-rope
        ];
        description = "Snippet support for yi";
-       license = lib.licenses.gpl2;
+       license = lib.licenses.gpl2Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base cryptonite memory yu-utils ];
        testHaskellDepends = [ base MonadRandom random yu-utils ];
        description = "Auth module for Yu";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        libraryHaskellDepends = [ base yu-auth yu-utils ];
        testHaskellDepends = [ base blaze-markup hspec yu-utils ];
        description = "The core of Yu";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base cmdargs yaml yu-auth yu-core yu-utils
        ];
        description = "The launcher for Yu";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base cmdargs directory echo filepath process yu-auth yu-utils
        ];
        description = "Tool for Yu";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          warp xml-hamlet yesod-core
        ];
        description = "Utils for Yu";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          time transformers vector xml-conduit
        ];
        description = "Utilities for reading and writing Alteryx .yxdb files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
 
   "zeolite-lang" = callPackage
     ({ mkDerivation, base, containers, directory, filepath, hashable
-     , megaparsec, mtl, parser-combinators, regex-tdfa, time
-     , transformers, unix
+     , megaparsec, microlens, microlens-th, mtl, parser-combinators
+     , regex-tdfa, time, transformers, unix
      }:
      mkDerivation {
        pname = "zeolite-lang";
-       version = "0.12.0.0";
-       sha256 = "056brd93d1559wdz7s4wcvjglqg5p1bafhhgbqcqnd0q8msnilrv";
+       version = "0.13.0.0";
+       sha256 = "0baljnskj5vrw9vwkwddrqchqvk7i5dxr4d5aj7qvl73brchjx7c";
        isLibrary = false;
        isExecutable = true;
        enableSeparateDataOutput = true;
        libraryHaskellDepends = [
-         base containers directory filepath hashable megaparsec mtl
-         parser-combinators regex-tdfa time transformers unix
+         base containers directory filepath hashable megaparsec microlens
+         microlens-th mtl parser-combinators regex-tdfa time transformers
+         unix
        ];
        executableHaskellDepends = [
          base containers directory filepath unix
···
          transformers zeromq3-haskell
        ];
        description = "Conduit bindings for zeromq3-haskell";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        ];
        testHaskellDepends = [ base ];
        description = "Conduit wrapper around zeromq4-haskell";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          conduit-extra hspec lzma
        ];
        description = "Read and parse ZIM files";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
   "zinza" = callPackage
···
          directory filepath mtl parallel-io text zmidi-core
        ];
        description = "Representing MIDI a simple score";
-       license = lib.licenses.lgpl3;
+       license = lib.licenses.lgpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          mtl ui-command vector zoom-cache zoom-cache-pcm
        ];
        description = "Tools for generating zoom-cache-pcm files";
-       license = lib.licenses.lgpl21;
+       license = lib.licenses.lgpl21Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
          base bytestring containers fixed-vector storable-record
        ];
        description = "Haskell language binding for the Zydis library, a x86/x86-64 disassembler";
-       license = lib.licenses.gpl3;
+       license = lib.licenses.gpl3Only;
      }) {};
 
 }

pkgs/development/python-modules/gremlinpython/default.nix

···
-{ stdenv, lib, buildPythonPackage, fetchFromGitHub, python, pythonOlder
-, pytestCheckHook, pyhamcrest, pytestrunner, pytest
+{ lib, buildPythonPackage, fetchFromGitHub
+, pytestCheckHook, pyhamcrest, pytestrunner
 , six, isodate, tornado, aenum, radish-bdd, mock
 }:
 
 buildPythonPackage rec {
   pname = "gremlinpython";
-  version = "3.4.8";
+  version = "3.4.10";
 
   # pypi tarball doesn't include tests
   src = fetchFromGitHub {
     owner = "apache";
     repo = "tinkerpop";
     rev = version;
-    sha256 = "0kcyhfxz7z4f8i64gig8q1q9dhy24cprbh63vwsdiwryg74q4chl";
+    sha256 = "0i9lkrwbsmpx1h9480vf97pibm2v37sgw2qm2r1c0i8gg5bcmhj3";
   };
   sourceRoot = "source/gremlin-python/src/main/jython";
   postPatch = ''
     substituteInPlace setup.py \
+      --replace 'aenum>=1.4.5,<3.0.0' 'aenum' \
       --replace 'tornado>=4.4.1,<6.0' 'tornado' \
       --replace 'PyHamcrest>=1.9.0,<2.0.0' 'PyHamcrest' \
       --replace 'radish-bdd==0.8.6' 'radish-bdd' \

pkgs/development/python-modules/pylast/default.nix

···
-{ lib, buildPythonPackage, fetchPypi, isPy3k, certifi, six
-, setuptools_scm
+{ lib
+, buildPythonPackage
+, certifi
+, fetchPypi
+, flaky
+, pytestCheckHook
+, pythonOlder
+, setuptools-scm
+, six
 }:
 
 buildPythonPackage rec {
   pname = "pylast";
-  version = "4.1.0";
-
-  disabled = !isPy3k;
+  version = "4.2.0";
+  disabled = pythonOlder "3.6";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "ad084aec1bf7e307bc42d7cc1a003851f5bee1ad24fb697a9fdc300bbfe63932";
+    sha256 = "sha256-w/mkAUUgj7L7Xv+nz1pI1TYKfihH3S3MbxaNQ4VtoH0=";
   };
 
-  nativeBuildInputs = [ setuptools_scm ];
-  propagatedBuildInputs = [ certifi six ];
+  nativeBuildInputs = [ setuptools-scm ];
 
-  # tests require last.fm credentials
-  doCheck = false;
+  propagatedBuildInputs = [
+    certifi
+    six
+  ];
+
+  checkInputs = [
+    pytestCheckHook
+    flaky
+  ];
+
+  pythonImportsCheck = [ "pylast" ];
 
   meta = with lib; {
+    description = "Python interface to last.fm (and compatibles)";
     homepage = "https://github.com/pylast/pylast";
-    description = "A python interface to last.fm (and compatibles)";
     license = licenses.asl20;
     maintainers = with maintainers; [ rvolosatovs ];
   };

pkgs/development/python-modules/transformers/default.nix

···
 
 buildPythonPackage rec {
   pname = "transformers";
-  version = "4.3.3";
+  version = "4.4.2";
 
   src = fetchFromGitHub {
     owner = "huggingface";
     repo = pname;
     rev = "v${version}";
-    hash = "sha256-KII7ZR+vnCxCxUcBOQo9y0KxZa+XuIIAkSJejk8HrlA=";
+    hash = "sha256-kl1Z2FBo+yqVXUqLaUtet6IycmdcAtfydNTI4MNNrkc=";
   };
 
   propagatedBuildInputs = [

pkgs/development/tools/ccloud-cli/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ccloud-cli";
-  version = "0.202.0";
+  version = "1.25.0";
 
   # To get the latest version:
-  # curl -L 'https://s3-us-west-2.amazonaws.com/confluent.cloud?prefix=ccloud-cli/archives/&delimiter=/' | nix run nixpkgs.libxml2 -c xmllint --format -
+  # curl -L https://cnfl.io/ccloud-cli | sh -s -- -l | grep -v latest | sort -V | tail -n1
   src = fetchurl (if stdenv.hostPlatform.isDarwin then {
       url = "https://s3-us-west-2.amazonaws.com/confluent.cloud/ccloud-cli/archives/${version}/ccloud_v${version}_darwin_amd64.tar.gz";
-      sha256 = "1w7c7fwpjj6f26nmcgm6rkrl4v9zhdpygkh02la77n23lg8wxah5";
+      sha256 = "0306jg36dpccwyy239r2xvw3bvsrnrdc88390g26fhcb0048qmgb";
     } else {
       url = "https://s3-us-west-2.amazonaws.com/confluent.cloud/ccloud-cli/archives/${version}/ccloud_v${version}_linux_amd64.tar.gz";
-      sha256 = "1xbhv2viw8cbwv03rfq99jddnw5lwy812a8xby348290l323xi89";
+      sha256 = "02sly7cxqlrfd6chamlp05k9ar93mpfrkx5183js0hf595nlki61";
     });
 
   nativeBuildInputs = [ autoPatchelfHook ];
···
     homepage = "https://docs.confluent.io/current/cloud/cli/index.html";
     license = licenses.unfree;
     maintainers = with maintainers; [ kalbasit ];
-    platforms = platforms.linux ++ platforms.darwin;
+
+    # TODO: There's support for i686 systems but I do not have any such system
+    # to build it locally on, it's also unfree so I cannot rely on ofborg to
+    # build it. Get the list of supported system by looking at the list of
+    # files in the S3 bucket:
+    #
+    #   https://s3-us-west-2.amazonaws.com/confluent.cloud?prefix=ccloud-cli/archives/1.25.0/&delimiter=/%27
+    platforms = [ "x86_64-linux" "x86_64-darwin" ];
   };
 }

pkgs/development/tools/continuous-integration/fly/default.nix

···
 
 buildGoModule rec {
   pname = "fly";
-  version = "7.0.0";
+  version = "7.1.0";
 
   src = fetchFromGitHub {
     owner = "concourse";
     repo = "concourse";
     rev = "v${version}";
-    sha256 = "sha256-WpwMx8mPedunBKlRUDdcVA1sLWkZvuoaw6DEtvGSyAg=";
+    sha256 = "sha256-M0Jo4DyvPghhVLK3eFdew10lGUJJODxKoL+v16y9CW8=";
   };
 
-  vendorSha256 = "sha256-OxU+Hb8bX71SFuyAw583Z7bEu+b/j2i/fOGE5S9C91M=";
+  vendorSha256 = "sha256-W6m+nDNcZBVfa1OTkOHWf4E9LmEUewsTLT/56Iyp6+Y=";
 
   doCheck = false;
 

pkgs/development/tools/fission/default.nix

···
+{ lib, fetchFromGitHub, buildGoModule }:
+
+buildGoModule rec {
+  pname = "fission";
+  version = "1.12.0";
+
+  src = fetchFromGitHub {
+    owner = "fission";
+    repo = "fission";
+    rev = version;
+    sha256 = "0izvkjd7ydcxhr6zmgrbfm3ybz2kf4p27099lr07gd4x7c6xxmqr";
+  };
+
+  vendorSha256 = "12clw0wy4lypf45imqnabj39yxqpi348csr4m5d0d1rksxgvwngq";
+
+  buildFlagsArray = "-ldflags=-s -w -X info.Version=${version}";
+
+  subPackages = [ "cmd/fission-cli" ];
+
+  postInstall = ''
+    ln -s $out/bin/fission-cli $out/bin/fission
+  '';
+
+  meta = with lib; {
+    description = "The cli used by end user to interact Fission";
+    homepage = "https://fission.io";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ neverbehave ];
+  };
+}

pkgs/development/tools/haskell/haskell-language-server/withWrapper.nix

···
-{ lib, supportedGhcVersions ? [ "865" "884" "8104" ], stdenv, haskellPackages
+{ lib, supportedGhcVersions ? [ "884" "8104" ], stdenv, haskellPackages
 , haskell }:
 #
 # The recommended way to override this package is

pkgs/misc/tmux-plugins/default.nix

···
     }));
 
 in rec {
+  inherit mkTmuxPlugin;
+
+  mkDerivation = throw "tmuxPlugins.mkDerivation is deprecated, use tmuxPlugins.mkTmuxPlugin instead"; # added 2021-03-14
+
   battery = mkTmuxPlugin {
     pluginName = "battery";
     version = "unstable-2019-07-04";

pkgs/misc/vscode-extensions/default.nix

···
         };
       };
 
+      emmanuelbeziat.vscode-great-icons = buildVscodeMarketplaceExtension {
+        mktplcRef = {
+          name = "vscode-great-icons";
+          publisher = "emmanuelbeziat";
+          version = "2.1.64";
+          sha256 = "sha256-qsL1vWiEAYeWkMDNSrr1yzg0QxroEQQeznoDL3Ujy/o=";
+        };
+        meta = with lib; {
+          license = licenses.mit;
+        };
+      };
+
       esbenp.prettier-vscode = buildVscodeMarketplaceExtension {
         meta = with lib; {
           changelog = "https://marketplace.visualstudio.com/items/esbenp.prettier-vscode/changelog";
···
         mktplcRef = {
           name = "todo-tree";
           publisher = "Gruntfuggly";
-          version = "0.0.205";
-          sha256 = "0s7bmnsx40lz9wiijrh7cnazwqvmkhsbnidl832qx27pzk0977ix";
+          version = "0.0.206";
+          sha256 = "1xalwk2bndb73p8p2b4w5qz7m1n80xyw67wb5qlq1rrfjchhicyv";
         };
         meta = with lib; {
           license = licenses.mit;

pkgs/misc/vscode-extensions/terraform/default.nix

···
   mktplcRef = {
     name = "terraform";
     publisher = "hashicorp";
-    version = "2.8.2";
+    version = "2.8.3";
   };
 
   vsix = fetchurl {
     name = "${mktplcRef.publisher}-${mktplcRef.name}.zip";
     url = "https://github.com/hashicorp/vscode-terraform/releases/download/v${mktplcRef.version}/terraform-${mktplcRef.version}.vsix";
-    sha256 = "0f1ck3h8ckvr75j27w2lxjbwnr24nc6fjki0gnn715ynkqg7w9bi";
+    sha256 = "1cng82q9079qmn5q71h9knh9qzhqrl3phaamkqfjy1jallgi43b1";
   };
 
   patches = [ ./fix-terraform-ls.patch ];

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

···
 
 stdenv.mkDerivation rec {
   pname = "pam_mount";
-  version = "2.16";
+  version = "2.17";
 
   src = fetchurl {
-    url = "mirror://sourceforge/pam-mount/pam_mount/${version}/${pname}-${version}.tar.xz";
-    sha256 = "1rvi4irb7ylsbhvx1cr6islm2xxw1a4b19q6z4a9864ndkm0f0mf";
+    url = "mirror://sourceforge/pam-mount/pam_mount/${pname}-${version}.tar.xz";
+    sha256 = "1q2n6a2ah6nghdn8i6ad2wj247njwb5nx48cggxknaa6lqxylidy";
   };
 
   patches = [
     ./insert_utillinux_path_hooks.patch
-    ./support_luks2.patch
   ];
 
   postPatch = ''
···
     "--sbindir=${placeholder "out"}/bin"
     "--sysconfdir=${placeholder "out"}/etc"
     "--with-slibdir=${placeholder "out"}/lib"
-    "--with-ssbindir=${placeholder "out"}/bin"
   ];
 
   postInstall = ''

pkgs/os-specific/linux/pam_mount/support_luks2.patch

···
-commit d4434c05e7c0cf05d87089404cfa2deedc60811a
-Author: Ingo Franzki <[e-mail]>
-Date:   Mon Oct 29 16:47:40 2018 +0100
-
-    crypto: Add support for LUKS2
-    
-    Cryptsetup version 2.0 added support for LUKS2.
-    This patch adds support for mounting LUKS2 volumes with
-    pam_mount.
-    
-    Signed-off-by: Ingo Franzki <[e-mail]>
-
-diff --git a/src/crypto-dmc.c b/src/crypto-dmc.c
-index d0ab6ca..abd0358 100644
---- a/src/crypto-dmc.c
-+++ b/src/crypto-dmc.c
-@@ -21,6 +21,12 @@
- #include "libcryptmount.h"
- #include "pam_mount.h"
- 
-+#ifndef CRYPT_LUKS
-+	#define CRYPT_LUKS	NULL /* Passing NULL to crypt_load will
-+					default to LUKS(1) on older
-+					libcryptsetup versions. */
-+#endif
-+
- /**
-  * dmc_is_luks - check if @path points to a LUKS volume (cf. normal dm-crypt)
-  * @path:	path to the crypto container
-@@ -48,7 +54,7 @@ EXPORT_SYMBOL int ehd_is_luks(const char *path, bool blkdev)
- 
- 	ret = crypt_init(&cd, device);
- 	if (ret == 0) {
--		ret = crypt_load(cd, CRYPT_LUKS1, NULL);
-+		ret = crypt_load(cd, CRYPT_LUKS, NULL);
- 		if (ret == -EINVAL)
- 			ret = false;
- 		else if (ret == 0)
-@@ -106,7 +112,7 @@ static bool dmc_run(const struct ehd_mount_request *req,
- #endif
- 	}
- 
--	ret = crypt_load(cd, CRYPT_LUKS1, NULL);
-+	ret = crypt_load(cd, CRYPT_LUKS, NULL);
- 	if (ret == 0) {
- 		ret = crypt_activate_by_passphrase(cd, mt->crypto_name,
- 		      CRYPT_ANY_SLOT, req->key_data, req->key_size, flags);

pkgs/tools/archivers/7zz/default.nix

···
+{ lib, stdenv, fetchurl, autoPatchelfHook }:
+
+let platform =       if stdenv.isi686    then "x86"
+                else if stdenv.isx86_64  then "x64"
+                else if stdenv.isAarch32 then "arm"
+                else if stdenv.isAarch64 then "arm64"
+                else throw "Unsupported architecture";
+
+    url = "https://7-zip.org/a/7z2101-linux-${platform}.tar.xz";
+
+    hashes = {
+      x86 = "0k6vg85ld8i2pcv5sv3xbvf3swqh9qj8hf2jcpadssys3yyidqyj";
+      x64 = "1yfanx98fizj8d2s87yxgsy30zydx7h5w9wf4wy3blgsp0vkbjb3";
+      arm = "04iah9vijm86r8rbkhxig86fx3lpag4xi7i3vq7gfrlwkymclhm1";
+      arm64 = "0a26ginpb22aydcyvffxpbi7lxh4sgs9gb6cj96qqx7cnf7bk2ri";
+    };
+    sha256 = hashes."${platform}";
+
+in stdenv.mkDerivation {
+  pname = "7zz";
+  version = "21.01";
+
+  src = fetchurl { inherit url sha256; };
+  sourceRoot = ".";
+
+  nativeBuildInputs = [ autoPatchelfHook ];
+  buildInputs = [ stdenv.cc.cc.lib ];
+
+  dontBuild = true;
+
+  installPhase = ''
+    runHook preInstall
+    install -D -t $out/bin 7zz
+    runHook postInstall
+  '';
+
+  meta = with lib; {
+    description = "Command line archiver utility";
+    homepage = "https://www.7-zip.org";
+
+    # source not released yet. will be under LGPL 2.1+ with RAR exception
+    license = licenses.unfree;
+
+    platforms = [ "i686-linux" "x86_64-linux" "aarch64-linux" "armv7l-linux" ];
+    maintainers = with maintainers; [ anna328p ];
+  };
+}

pkgs/tools/package-management/cargo-about/default.nix

···
 { lib, rustPlatform, fetchFromGitHub }:
 rustPlatform.buildRustPackage rec {
   pname = "cargo-about";
-  version = "0.2.3";
+  version = "0.3.0";
 
   src = fetchFromGitHub {
     owner = "EmbarkStudios";
     repo = "cargo-about";
     rev = version;
-    sha256 = "1jdp5ksxm4rsqhirgl5zwpiahrz2lx046pkvf6xvr6ms70l2xiwj";
+    sha256 = "sha256-MsXNneKj2xCci1guj1TKcIrX7XByJ5/lWUmjxAsgzPY=";
   };
 
-  cargoSha256 = "07bjxsg5kgx8dg3wf6mvi5460db206l68irqc21hz10plz5llmnr";
+  cargoSha256 = "sha256-NdzgIB6uXMtGiLwOACEIeAb4iv7mYLnwRte3M/TkSMA=";
 
   meta = with lib; {
     description = "Cargo plugin to generate list of all licenses for a crate";

pkgs/top-level/all-packages.nix

···
 
   fishnet = callPackage ../servers/fishnet { };
 
+  fission = callPackage ../development/tools/fission { };
+
   authy = callPackage ../applications/misc/authy { };
 
   avro-tools = callPackage ../development/tools/avro-tools { };
···
   _1password-gui = callPackage ../applications/misc/1password-gui { };
 
   _6tunnel = callPackage ../tools/networking/6tunnel { };
+
+  _7zz = callPackage ../tools/archivers/7zz { };
 
   _9pfs = callPackage ../tools/filesystems/9pfs { };
 
···
 
   krank = haskell.lib.justStaticExecutables haskellPackages.krank;
 
-  # We use a version built with an older compiler because of https://github.com/pikajude/stylish-cabal/issues/12.
-  stylish-cabal = haskell.lib.justStaticExecutables haskell.packages.ghc865.stylish-cabal;
+  stylish-cabal = haskell.lib.justStaticExecutables haskellPackages.stylish-cabal;
 
   all-cabal-hashes = callPackage ../data/misc/hackage { };
 
···
 
   julia-mono = callPackage ../data/fonts/julia-mono { };
 
+  juno-theme = callPackage ../data/themes/juno { };
+
   kanji-stroke-order-font = callPackage ../data/fonts/kanji-stroke-order-font {};
 
   kawkab-mono-font = callPackage ../data/fonts/kawkab-mono {};
···
   coriander = callPackage ../applications/video/coriander {
     inherit (gnome2) libgnomeui GConf;
   };
+
+  corrscope = libsForQt5.callPackage ../applications/video/corrscope { };
 
   csa = callPackage ../applications/audio/csa { };
 

pkgs/top-level/haskell-packages.nix

···
 let
   # These are attributes in compiler and packages that don't support integer-simple.
   integerSimpleExcludes = [
-    "ghc822Binary"
     "ghc865Binary"
     "ghc8102Binary"
     "ghc8102BinaryMinimal"
-    "ghcjs"
-    "ghcjs86"
     "integer-simple"
     "native-bignum"
     "ghcHEAD"
···
 
   compiler = {
 
-    ghc822Binary = callPackage ../development/compilers/ghc/8.2.2-binary.nix { };
-
     ghc865Binary = callPackage ../development/compilers/ghc/8.6.5-binary.nix { };
 
     ghc8102Binary = callPackage ../development/compilers/ghc/8.10.2-binary.nix {
···
       minimal = true;
     };
 
-    ghc865 = callPackage ../development/compilers/ghc/8.6.5.nix {
-      bootPkgs = packages.ghc822Binary;
-      inherit (buildPackages.python3Packages) sphinx;
-      buildLlvmPackages = buildPackages.llvmPackages_6;
-      llvmPackages = pkgs.llvmPackages_6;
-    };
-    ghc882 = callPackage ../development/compilers/ghc/8.8.2.nix {
-      bootPkgs = packages.ghc865Binary;
-      inherit (buildPackages.python3Packages) sphinx;
-      buildLlvmPackages = buildPackages.llvmPackages_7;
-      llvmPackages = pkgs.llvmPackages_7;
-    };
-    ghc883 = callPackage ../development/compilers/ghc/8.8.3.nix {
-      bootPkgs = packages.ghc865Binary;
-      inherit (buildPackages.python3Packages) sphinx;
-      buildLlvmPackages = buildPackages.llvmPackages_7;
-      llvmPackages = pkgs.llvmPackages_7;
-    };
     ghc884 = callPackage ../development/compilers/ghc/8.8.4.nix {
       # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
       bootPkgs = if stdenv.isAarch64 then
···
       buildLlvmPackages = buildPackages.llvmPackages_7;
       llvmPackages = pkgs.llvmPackages_7;
     };
-    ghc8101 = callPackage ../development/compilers/ghc/8.10.1.nix {
-      bootPkgs = packages.ghc865Binary;
-      inherit (buildPackages.python3Packages) sphinx;
-      buildLlvmPackages = buildPackages.llvmPackages_9;
-      llvmPackages = pkgs.llvmPackages_9;
-    };
-    ghc8102 = callPackage ../development/compilers/ghc/8.10.2.nix {
-      # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
-      bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then
-          packages.ghc8102BinaryMinimal
-        else
-          packages.ghc865Binary;
-      inherit (buildPackages.python3Packages) sphinx;
-      buildLlvmPackages = buildPackages.llvmPackages_9;
-      llvmPackages = pkgs.llvmPackages_9;
-    };
-    ghc8103 = callPackage ../development/compilers/ghc/8.10.3.nix {
-      # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
-      bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then
-          packages.ghc8102BinaryMinimal
-        else
-          packages.ghc865Binary;
-      inherit (buildPackages.python3Packages) sphinx;
-      buildLlvmPackages = buildPackages.llvmPackages_9;
-      llvmPackages = pkgs.llvmPackages_9;
-    };
     ghc8104 = callPackage ../development/compilers/ghc/8.10.4.nix {
       # aarch64 ghc865Binary gets SEGVs due to haskell#15449 or similar
       bootPkgs = if stdenv.isAarch64 || stdenv.isAarch32 then
···
       llvmPackages = pkgs.llvmPackages_10;
     };
     ghcHEAD = callPackage ../development/compilers/ghc/head.nix {
-      bootPkgs = packages.ghc883; # no binary yet
+      bootPkgs = packages.ghc884; # no binary yet
       inherit (buildPackages.python3Packages) sphinx;
       buildLlvmPackages = buildPackages.llvmPackages_10;
       llvmPackages = pkgs.llvmPackages_10;
       libffi = pkgs.libffi;
     };
-    ghcjs = compiler.ghcjs86;
-    ghcjs86 = callPackage ../development/compilers/ghcjs-ng {
-      bootPkgs = packages.ghc865;
-      ghcjsSrcJson = ../development/compilers/ghcjs-ng/8.6/git.json;
-      stage0 = ../development/compilers/ghcjs-ng/8.6/stage0.nix;
-      ghcjsDepOverrides = callPackage ../development/compilers/ghcjs-ng/8.6/dep-overrides.nix {};
-    };
 
     # The integer-simple attribute set contains all the GHC compilers
     # build with integer-simple instead of integer-gmp.
···
   # Always get compilers from `buildPackages`
   packages = let bh = buildPackages.haskell; in {
 
-    ghc822Binary = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc822Binary;
-      ghc = bh.compiler.ghc822Binary;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.2.x.nix { };
-      packageSetConfig = bootstrapPackageSet;
-    };
     ghc865Binary = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghc865Binary;
       ghc = bh.compiler.ghc865Binary;
···
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };
       packageSetConfig = bootstrapPackageSet;
     };
-    ghc865 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc865;
-      ghc = bh.compiler.ghc865;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.6.x.nix { };
-    };
-    ghc882 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc882;
-      ghc = bh.compiler.ghc882;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.8.x.nix { };
-    };
-    ghc883 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc883;
-      ghc = bh.compiler.ghc883;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.8.x.nix { };
-    };
     ghc884 = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghc884;
       ghc = bh.compiler.ghc884;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.8.x.nix { };
     };
-    ghc8101 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc8101;
-      ghc = bh.compiler.ghc8101;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };
-    };
-    ghc8102 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc8102;
-      ghc = bh.compiler.ghc8102;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };
-    };
-    ghc8103 = callPackage ../development/haskell-modules {
-      buildHaskellPackages = bh.packages.ghc8103;
-      ghc = bh.compiler.ghc8103;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.10.x.nix { };
-    };
     ghc8104 = callPackage ../development/haskell-modules {
       buildHaskellPackages = bh.packages.ghc8104;
       ghc = bh.compiler.ghc8104;
···
       buildHaskellPackages = bh.packages.ghcHEAD;
       ghc = bh.compiler.ghcHEAD;
       compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-head.nix { };
-    };
-    ghcjs = packages.ghcjs86;
-    ghcjs86 = callPackage ../development/haskell-modules rec {
-      buildHaskellPackages = ghc.bootPkgs;
-      ghc = bh.compiler.ghcjs86;
-      compilerConfig = callPackage ../development/haskell-modules/configuration-ghc-8.6.x.nix { };
-      packageSetConfig = callPackage ../development/haskell-modules/configuration-ghcjs.nix { };
     };
 
     # The integer-simple attribute set contains package sets for all the GHC compilers